[ruby] add %typemap(directorin) and %typemap(directorout) for shared_ptr.

Examples/test-suite/cpp11_shared_ptr_director.i

@@ -5,23 +5,29 @@
 %}
 
 %include "std_shared_ptr.i";
-%shared_ptr(Created);
+%shared_ptr(C);
-%feature("director") Creator;
+%feature("director") Base;
 
 %inline %{
-struct Created {
+struct C {
-  Created() {};
+  C() : m(1) {};
-  int get_m() { return 1; };
+  C(int n) : m(n) {};
+  int get_m() { return m; };
+  int m;
 };
 
-struct Creator {
+struct Base {
-  Creator() {};
+  Base() {};
-  virtual std::shared_ptr<Created> create() = 0;
+  virtual std::shared_ptr<C> ret_c_shared_ptr() = 0;
-  virtual ~Creator() {}
+  virtual C ret_c_by_value() = 0;
+  virtual int take_c_by_value(C c) = 0;
+  virtual int take_c_shared_ptr_by_value(std::shared_ptr<C> c) = 0;
+  virtual int take_c_shared_ptr_by_ref(std::shared_ptr<C>& c) = 0;
+  virtual ~Base() {}
 };
 
-int crash(Creator* creator) {
+int call_ret_c_shared_ptr(Base* b) {
-  std::shared_ptr<Created> ptr = creator->create();
+  std::shared_ptr<C> ptr = b->ret_c_shared_ptr();
   if (ptr) {
     return ptr->get_m();
   } else {
@@ -29,4 +35,24 @@ int crash(Creator* creator) {
   }
 }
 
+int call_ret_c_by_value(Base* b) {
+  C c = b->ret_c_by_value();
+  return c.get_m();
+}
+
+int call_take_c_by_value(Base* b) {
+  C c(5);
+  return b->take_c_by_value(c);
+}
+
+int call_take_c_shared_ptr_by_value(Base* b) {
+  std::shared_ptr<C> ptr(new C(6));
+  return b->take_c_shared_ptr_by_value(ptr);
+}
+
+int call_take_c_shared_ptr_by_ref(Base* b) {
+  std::shared_ptr<C> ptr(new C(7));
+  return b->take_c_shared_ptr_by_ref(ptr);
+}
+
 %}

Examples/test-suite/ruby/cpp11_shared_ptr_director_runme.rb

@@ -2,23 +2,47 @@ require 'cpp11_shared_ptr_director'
 
 include Cpp11_shared_ptr_director
 
-class Derived < Creator
+class Derived < Base
 
   def initialize(flag)
     @return_none = flag
     super()
   end
 
-  def create
+  def ret_c_shared_ptr
     if @return_none
       nil
     else
-      Created.new
+      C.new
     end
   end
 
+  def ret_c_by_value
+    C.new
+  end
+
+  def take_c_by_value(c)
+    c.get_m
+  end
+
+  def take_c_shared_ptr_by_value(c)
+    c.get_m
+  end
+
+  def take_c_shared_ptr_by_ref(c)
+    c.get_m
+  end
+
 end
 
-p crash(Derived.new(false))
+a = Derived.new(false)
-p crash(Derived.new(true))
+b = Derived.new(true)
+
+raise unless call_ret_c_shared_ptr(a) ==  1
+raise unless call_ret_c_shared_ptr(b) == -1
+raise unless call_ret_c_by_value(a)   ==  1
+
+raise unless call_take_c_by_value(a)            == 5
+raise unless call_take_c_shared_ptr_by_value(a) == 6
+raise unless call_take_c_shared_ptr_by_ref(a)   == 7
 

Lib/ruby/boost_shared_ptr.i

@@ -24,7 +24,9 @@
 
 // Typemap customisations...
 
+//
 // plain value
+//
 %typemap(in) CONST TYPE (void *argp, int res = 0) {
   swig_ruby_owntype newmem = {0, 0};
   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
@@ -62,8 +64,28 @@
   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
 
+%typemap(directorout,noblock=1) CONST TYPE (void *argp, int res = 0) {
+  swig_ruby_owntype newmem = {0, 0};
+  res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
+  if (!SWIG_IsOK(res)) {
+    %dirout_fail(res, "$type");
+  }
+  if (!argp) {
+    %dirout_nullref("$type");
+  } else {
+    $result = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
+    if (newmem.own & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
+  }
+}
+%typemap(directorin,noblock=1) CONST TYPE {
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  $input = SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
+}
+
+//
 // plain pointer
 // Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+//
 %typemap(in) CONST TYPE * (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
   swig_ruby_owntype newmem = {0, 0};
   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
@@ -79,7 +101,6 @@
     $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
   }
 }
-
 %typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE * {
   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
@@ -108,7 +129,16 @@
   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
 
+%typemap(directorin,noblock=1) CONST TYPE * %{
+#error "directorin typemap for plain pointer not implemented"
+%}
+%typemap(directorout,noblock=1) CONST TYPE * %{
+#error "directorout typemap for plain pointer not implemented"
+%}
+
+//
 // plain reference
+//
 %typemap(in) CONST TYPE & (void  *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
   swig_ruby_owntype newmem = {0, 0};
   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
@@ -153,8 +183,17 @@
   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
 
+%typemap(directorin,noblock=1) CONST TYPE & %{
+#error "directorin typemap for plain reference not implemented"
+%}
+%typemap(directorout,noblock=1) CONST TYPE & %{
+#error "directorout typemap for plain reference not implemented"
+%}
+
+//
 // plain pointer by reference
 // Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
+//
 %typemap(in) TYPE *CONST& (void  *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
   swig_ruby_owntype newmem = {0, 0};
   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
@@ -182,7 +221,16 @@
 #error "varout typemap not implemented"
 %}
 
+%typemap(directorin,noblock=1) TYPE *CONST& %{
+#error "directorin typemap for plain pointer by reference not implemented"
+%}
+%typemap(directorout,noblock=1) TYPE *CONST& %{
+#error "directorout typemap for plain pointer by reference not implemented"
+%}
+
+//
 // shared_ptr by value
+//
 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
   swig_ruby_owntype newmem = {0, 0};
   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
@@ -197,18 +245,6 @@
   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
 
-%typemap(directorout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void * swig_argp, int swig_res = 0) {
-  if (NIL_P($input)) {
-    $result = $ltype();
-  } else {
-    swig_res = SWIG_ConvertPtr($input,&swig_argp,$&descriptor, %convertptr_flags);
-    if (!SWIG_IsOK(swig_res)) {
-      %dirout_fail(swig_res,"$type");
-    }
-    $result = *(%reinterpret_cast(swig_argp, $&ltype));
-  }
-}
-
 %typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
   swig_ruby_owntype newmem = {0, 0};
   void *argp = 0;
@@ -224,7 +260,21 @@
   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
 
+%typemap(directorout,noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void * swig_argp, int swig_res = 0) {
+  if (NIL_P($input)) {
+    $result = $ltype();
+  } else {
+    swig_res = SWIG_ConvertPtr($input,&swig_argp,$&descriptor, %convertptr_flags);
+    if (!SWIG_IsOK(swig_res)) {
+      %dirout_fail(swig_res,"$type");
+    }
+    $result = *(%reinterpret_cast(swig_argp, $&ltype));
+  }
+}
+
+//
 // shared_ptr by reference
+//
 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
   swig_ruby_owntype newmem = {0, 0};
   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
@@ -251,7 +301,9 @@
 #error "varout typemap not implemented"
 %}
 
+//
 // shared_ptr by pointer
+//
 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
   swig_ruby_owntype newmem = {0, 0};
   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);
@@ -279,7 +331,9 @@
 #error "varout typemap not implemented"
 %}
 
+//
 // shared_ptr by pointer reference
+//
 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
   swig_ruby_owntype newmem = {0, 0};
   res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), %convertptr_flags, &newmem);