revert wrap changes

wrap/DOCS.md

@@ -15,8 +15,8 @@ The python wrapper supports keyword arguments for functions/methods. Hence, the
     - Eigen types: `Matrix`, `Vector`.
     - C/C++ basic types: `string`, `bool`, `size_t`, `int`, `double`, `char`, `unsigned char`.
     - `void`
-    - Any class with which be copied with `std::make_shared()`.
+    - Any class with which be copied with `boost::make_shared()`.
-    - `std::shared_ptr` of any object type.
+    - `boost::shared_ptr` of any object type.
 
 - Constructors
     - Overloads are supported, but arguments of different types *have* to have different names.
@@ -37,8 +37,8 @@ The python wrapper supports keyword arguments for functions/methods. Hence, the
     - Eigen types: `Matrix`, `Vector`.
     - Eigen types and classes as an optionally const reference.
     - C/C++ basic types: `string`, `bool`, `size_t`, `size_t`, `double`, `char`, `unsigned char`.
-    - Any class with which be copied with `std::make_shared()` (except Eigen).
+    - Any class with which be copied with `boost::make_shared()` (except Eigen).
-    - `std::shared_ptr` of any object type (except Eigen).
+    - `boost::shared_ptr` of any object type (except Eigen).
 
 - Properties or Variables
     - You can specify class variables in the interface file as long as they are in the `public` scope, e.g.
@@ -142,7 +142,7 @@ The python wrapper supports keyword arguments for functions/methods. Hence, the
     - Signature of clone function - `clone()` will be called virtually, so must appear at least at the top of the inheritance tree
 
         ```cpp
-        virtual std::shared_ptr<CLASS_NAME> clone() const;
+        virtual boost::shared_ptr<CLASS_NAME> clone() const;
         ```
 
 - Templates

wrap/gtwrap/interface_parser/type.py

@@ -225,7 +225,7 @@ class Type:
         Treat Matrix and Vector as "const Matrix&" and "const Vector&" resp.
 
         Args:
-            use_boost: Flag indicating whether to use std::shared_ptr or std::shared_ptr.
+            use_boost: Flag indicating whether to use boost::shared_ptr or std::shared_ptr.
         """
         shared_ptr_ns = "boost" if use_boost else "std"
 
@@ -300,7 +300,7 @@ class TemplatedType:
         Generate the C++ code for wrapping.
 
         Args:
-            use_boost: Flag indicating whether to use std::shared_ptr or std::shared_ptr.
+            use_boost: Flag indicating whether to use boost::shared_ptr or std::shared_ptr.
         """
         # Use Type.to_cpp to do the heavy lifting for the template parameters.
         template_args = ", ".join(

wrap/gtwrap/matlab_wrapper/templates.py

@@ -10,7 +10,7 @@ class WrapperTemplate:
         """)
 
     typdef_collectors = textwrap.dedent('''\
-                typedef std::set<std::shared_ptr<{class_name_sep}>*> Collector_{class_name};
+                typedef std::set<boost::shared_ptr<{class_name_sep}>*> Collector_{class_name};
                 static Collector_{class_name} collector_{class_name};
             ''')
 
@@ -77,10 +77,10 @@ class WrapperTemplate:
     collector_function_upcast_from_void = textwrap.dedent('''\
             void {class_name}_upcastFromVoid_{id}(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {{
               mexAtExit(&_deleteAllObjects);
-              typedef std::shared_ptr<{cpp_name}> Shared;
+              typedef boost::shared_ptr<{cpp_name}> Shared;
-              std::shared_ptr<void> *asVoid = *reinterpret_cast<std::shared_ptr<void>**> (mxGetData(in[0]));
+              boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));
               out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
-              Shared *self = new Shared(std::static_pointer_cast<{cpp_name}>(*asVoid));
+              Shared *self = new Shared(boost::static_pointer_cast<{cpp_name}>(*asVoid));
               *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;
             }}\n
         ''')
@@ -102,7 +102,7 @@ class WrapperTemplate:
         ''')
 
     collector_function_serialize = textwrap.indent(textwrap.dedent("""\
-            typedef std::shared_ptr<{full_name}> Shared;
+            typedef boost::shared_ptr<{full_name}> Shared;
             checkArguments("string_serialize",nargout,nargin-1,0);
             Shared obj = unwrap_shared_ptr<{full_name}>(in[0], "ptr_{namespace}{class_name}");
             ostringstream out_archive_stream;
@@ -113,7 +113,7 @@ class WrapperTemplate:
                                                    prefix='  ')
 
     collector_function_deserialize = textwrap.indent(textwrap.dedent("""\
-            typedef std::shared_ptr<{full_name}> Shared;
+            typedef boost::shared_ptr<{full_name}> Shared;
             checkArguments("{namespace}{class_name}.string_deserialize",nargout,nargin,1);
             string serialized = unwrap< string >(in[0]);
             istringstream in_archive_stream(serialized);
@@ -143,7 +143,7 @@ class WrapperTemplate:
 
     collector_function_shared_return = textwrap.indent(textwrap.dedent('''\
             {{
-            std::shared_ptr<{name}> shared({shared_obj});
+            boost::shared_ptr<{name}> shared({shared_obj});
             out[{id}] = wrap_shared_ptr(shared,"{name}");
             }}{new_line}'''),
                                                        prefix='  ')

wrap/gtwrap/matlab_wrapper/wrapper.py

@@ -1192,7 +1192,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
             shared_obj = 'pairResult.' + pair_value
 
             if not (return_type.is_shared_ptr or return_type.is_ptr):
-                shared_obj = 'std::make_shared<{name}>({shared_obj})' \
+                shared_obj = 'boost::make_shared<{name}>({shared_obj})' \
                     .format(name=self._format_type_name(return_type.typename),
                             shared_obj='pairResult.' + pair_value)
 
@@ -1230,7 +1230,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
                     obj=obj, method_name_sep=sep_method_name('.'))
             else:
                 method_name_sep_dot = sep_method_name('.')
-                shared_obj_template = 'std::make_shared<{method_name_sep_col}>({obj}),' \
+                shared_obj_template = 'boost::make_shared<{method_name_sep_col}>({obj}),' \
                                         '"{method_name_sep_dot}"'
                 shared_obj = shared_obj_template \
                     .format(method_name_sep_col=sep_method_name(),
@@ -1351,7 +1351,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
             if collector_func[2] == 'collectorInsertAndMakeBase':
                 body += textwrap.indent(textwrap.dedent('''\
                     mexAtExit(&_deleteAllObjects);
-                    typedef std::shared_ptr<{class_name_sep}> Shared;\n
+                    typedef boost::shared_ptr<{class_name_sep}> Shared;\n
                     Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
                     collector_{class_name}.insert(self);
                 ''').format(class_name_sep=class_name_separated,
@@ -1360,7 +1360,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
 
                 if collector_func[1].parent_class:
                     body += textwrap.indent(textwrap.dedent('''
-                        typedef std::shared_ptr<{}> SharedBase;
+                        typedef boost::shared_ptr<{}> SharedBase;
                         out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
                         *reinterpret_cast<SharedBase**>(mxGetData(out[0])) = new SharedBase(*self);
                     ''').format(collector_func[1].parent_class),
@@ -1373,7 +1373,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
 
                 if collector_func[1].parent_class:
                     base += textwrap.indent(textwrap.dedent('''
-                        typedef std::shared_ptr<{}> SharedBase;
+                        typedef boost::shared_ptr<{}> SharedBase;
                         out[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
                         *reinterpret_cast<SharedBase**>(mxGetData(out[1])) = new SharedBase(*self);
                     ''').format(collector_func[1].parent_class),
@@ -1381,7 +1381,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
 
                 body += textwrap.dedent('''\
                       mexAtExit(&_deleteAllObjects);
-                      typedef std::shared_ptr<{class_name_sep}> Shared;\n
+                      typedef boost::shared_ptr<{class_name_sep}> Shared;\n
                     {body_args}  Shared *self = new Shared(new {class_name_sep}({params}));
                       collector_{class_name}.insert(self);
                       out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
@@ -1394,7 +1394,7 @@ class MatlabWrapper(CheckMixin, FormatMixin):
 
             elif collector_func[2] == 'deconstructor':
                 body += textwrap.indent(textwrap.dedent('''\
-                    typedef std::shared_ptr<{class_name_sep}> Shared;
+                    typedef boost::shared_ptr<{class_name_sep}> Shared;
                     checkArguments("delete_{class_name}",nargout,nargin,1);
                     Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
                     Collector_{class_name}::iterator item;

wrap/matlab.h

@@ -39,7 +39,7 @@ extern "C" {
 
 #include <boost/cstdint.hpp>
 #include <boost/make_shared.hpp>
-#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <list>
 #include <set>
@@ -453,28 +453,28 @@ mxArray* create_object(const std::string& classname, void *pointer, bool isVirtu
  class to matlab.
 */
 template <typename Class>
-mxArray* wrap_shared_ptr(std::shared_ptr< Class > shared_ptr, const std::string& matlabName, bool isVirtual) {
+mxArray* wrap_shared_ptr(boost::shared_ptr< Class > shared_ptr, const std::string& matlabName, bool isVirtual) {
   // Create actual class object from out pointer
   mxArray* result;
   if(isVirtual) {
-    std::shared_ptr<void> void_ptr(shared_ptr);
+    boost::shared_ptr<void> void_ptr(shared_ptr);
     result = create_object(matlabName, &void_ptr, isVirtual, typeid(*shared_ptr).name());
   } else {
-    std::shared_ptr<Class> *heapPtr = new std::shared_ptr<Class>(shared_ptr);
+    boost::shared_ptr<Class> *heapPtr = new boost::shared_ptr<Class>(shared_ptr);
     result = create_object(matlabName, heapPtr, isVirtual, "");
   }
   return result;
 }
 
 template <typename Class>
-std::shared_ptr<Class> unwrap_shared_ptr(const mxArray* obj, const string& propertyName) {
+boost::shared_ptr<Class> unwrap_shared_ptr(const mxArray* obj, const string& propertyName) {
 
   mxArray* mxh = mxGetProperty(obj,0, propertyName.c_str());
   if (mxGetClassID(mxh) != mxUINT32OR64_CLASS || mxIsComplex(mxh)
     || mxGetM(mxh) != 1 || mxGetN(mxh) != 1) error(
     "Parameter is not an Shared type.");
 
-  std::shared_ptr<Class>* spp = *reinterpret_cast<std::shared_ptr<Class>**> (mxGetData(mxh));
+  boost::shared_ptr<Class>* spp = *reinterpret_cast<boost::shared_ptr<Class>**> (mxGetData(mxh));
   return *spp;
 }
 

wrap/tests/expected/matlab/class_wrapper.cpp

@@ -15,27 +15,27 @@ typedef MultipleTemplates<int, double> MultipleTemplatesIntDouble;
 typedef MultipleTemplates<int, float> MultipleTemplatesIntFloat;
 typedef MyFactor<gtsam::Pose2, gtsam::Matrix> MyFactorPosePoint2;
 
-typedef std::set<std::shared_ptr<FunRange>*> Collector_FunRange;
+typedef std::set<boost::shared_ptr<FunRange>*> Collector_FunRange;
 static Collector_FunRange collector_FunRange;
-typedef std::set<std::shared_ptr<FunDouble>*> Collector_FunDouble;
+typedef std::set<boost::shared_ptr<FunDouble>*> Collector_FunDouble;
 static Collector_FunDouble collector_FunDouble;
-typedef std::set<std::shared_ptr<Test>*> Collector_Test;
+typedef std::set<boost::shared_ptr<Test>*> Collector_Test;
 static Collector_Test collector_Test;
-typedef std::set<std::shared_ptr<PrimitiveRefDouble>*> Collector_PrimitiveRefDouble;
+typedef std::set<boost::shared_ptr<PrimitiveRefDouble>*> Collector_PrimitiveRefDouble;
 static Collector_PrimitiveRefDouble collector_PrimitiveRefDouble;
-typedef std::set<std::shared_ptr<MyVector3>*> Collector_MyVector3;
+typedef std::set<boost::shared_ptr<MyVector3>*> Collector_MyVector3;
 static Collector_MyVector3 collector_MyVector3;
-typedef std::set<std::shared_ptr<MyVector12>*> Collector_MyVector12;
+typedef std::set<boost::shared_ptr<MyVector12>*> Collector_MyVector12;
 static Collector_MyVector12 collector_MyVector12;
-typedef std::set<std::shared_ptr<MultipleTemplatesIntDouble>*> Collector_MultipleTemplatesIntDouble;
+typedef std::set<boost::shared_ptr<MultipleTemplatesIntDouble>*> Collector_MultipleTemplatesIntDouble;
 static Collector_MultipleTemplatesIntDouble collector_MultipleTemplatesIntDouble;
-typedef std::set<std::shared_ptr<MultipleTemplatesIntFloat>*> Collector_MultipleTemplatesIntFloat;
+typedef std::set<boost::shared_ptr<MultipleTemplatesIntFloat>*> Collector_MultipleTemplatesIntFloat;
 static Collector_MultipleTemplatesIntFloat collector_MultipleTemplatesIntFloat;
-typedef std::set<std::shared_ptr<ForwardKinematics>*> Collector_ForwardKinematics;
+typedef std::set<boost::shared_ptr<ForwardKinematics>*> Collector_ForwardKinematics;
 static Collector_ForwardKinematics collector_ForwardKinematics;
-typedef std::set<std::shared_ptr<TemplatedConstructor>*> Collector_TemplatedConstructor;
+typedef std::set<boost::shared_ptr<TemplatedConstructor>*> Collector_TemplatedConstructor;
 static Collector_TemplatedConstructor collector_TemplatedConstructor;
-typedef std::set<std::shared_ptr<MyFactorPosePoint2>*> Collector_MyFactorPosePoint2;
+typedef std::set<boost::shared_ptr<MyFactorPosePoint2>*> Collector_MyFactorPosePoint2;
 static Collector_MyFactorPosePoint2 collector_MyFactorPosePoint2;
 
 
@@ -155,7 +155,7 @@ void _class_RTTIRegister() {
 void FunRange_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<FunRange> Shared;
+  typedef boost::shared_ptr<FunRange> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_FunRange.insert(self);
@@ -164,7 +164,7 @@ void FunRange_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int narg
 void FunRange_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<FunRange> Shared;
+  typedef boost::shared_ptr<FunRange> Shared;
 
   Shared *self = new Shared(new FunRange());
   collector_FunRange.insert(self);
@@ -174,7 +174,7 @@ void FunRange_constructor_1(int nargout, mxArray *out[], int nargin, const mxArr
 
 void FunRange_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<FunRange> Shared;
+  typedef boost::shared_ptr<FunRange> Shared;
   checkArguments("delete_FunRange",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_FunRange::iterator item;
@@ -190,19 +190,19 @@ void FunRange_range_3(int nargout, mxArray *out[], int nargin, const mxArray *in
   checkArguments("range",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<FunRange>(in[0], "ptr_FunRange");
   double d = unwrap< double >(in[1]);
-  out[0] = wrap_shared_ptr(std::make_shared<FunRange>(obj->range(d)),"FunRange", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<FunRange>(obj->range(d)),"FunRange", false);
 }
 
 void FunRange_create_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("FunRange.create",nargout,nargin,0);
-  out[0] = wrap_shared_ptr(std::make_shared<FunRange>(FunRange::create()),"FunRange", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<FunRange>(FunRange::create()),"FunRange", false);
 }
 
 void FunDouble_collectorInsertAndMakeBase_5(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<Fun<double>> Shared;
+  typedef boost::shared_ptr<Fun<double>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_FunDouble.insert(self);
@@ -210,7 +210,7 @@ void FunDouble_collectorInsertAndMakeBase_5(int nargout, mxArray *out[], int nar
 
 void FunDouble_deconstructor_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<Fun<double>> Shared;
+  typedef boost::shared_ptr<Fun<double>> Shared;
   checkArguments("delete_FunDouble",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_FunDouble::iterator item;
@@ -228,14 +228,14 @@ void FunDouble_multiTemplatedMethod_7(int nargout, mxArray *out[], int nargin, c
   double d = unwrap< double >(in[1]);
   string t = unwrap< string >(in[2]);
   size_t u = unwrap< size_t >(in[3]);
-  out[0] = wrap_shared_ptr(std::make_shared<Fun<double>>(obj->multiTemplatedMethod<string,size_t>(d,t,u)),"Fun<double>", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<Fun<double>>(obj->multiTemplatedMethod<string,size_t>(d,t,u)),"Fun<double>", false);
 }
 
 void FunDouble_sets_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("sets",nargout,nargin-1,0);
   auto obj = unwrap_shared_ptr<Fun<double>>(in[0], "ptr_FunDouble");
-  out[0] = wrap_shared_ptr(std::make_shared<std::map<double,Fun<double>::double>>(obj->sets()),"std.mapdoubledouble", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<std::map<double,Fun<double>::double>>(obj->sets()),"std.mapdoubledouble", false);
 }
 
 void FunDouble_templatedMethod_9(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -244,13 +244,13 @@ void FunDouble_templatedMethod_9(int nargout, mxArray *out[], int nargin, const
   auto obj = unwrap_shared_ptr<Fun<double>>(in[0], "ptr_FunDouble");
   double d = unwrap< double >(in[1]);
   string t = unwrap< string >(in[2]);
-  out[0] = wrap_shared_ptr(std::make_shared<Fun<double>>(obj->templatedMethod<string>(d,t)),"Fun<double>", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<Fun<double>>(obj->templatedMethod<string>(d,t)),"Fun<double>", false);
 }
 
 void FunDouble_staticMethodWithThis_10(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("Fun<double>.staticMethodWithThis",nargout,nargin,0);
-  out[0] = wrap_shared_ptr(std::make_shared<Fun<double>>(Fun<double>::staticMethodWithThis()),"Fundouble", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<Fun<double>>(Fun<double>::staticMethodWithThis()),"Fundouble", false);
 }
 
 void FunDouble_templatedStaticMethodInt_11(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -263,7 +263,7 @@ void FunDouble_templatedStaticMethodInt_11(int nargout, mxArray *out[], int narg
 void Test_collectorInsertAndMakeBase_12(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<Test> Shared;
+  typedef boost::shared_ptr<Test> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_Test.insert(self);
@@ -272,7 +272,7 @@ void Test_collectorInsertAndMakeBase_12(int nargout, mxArray *out[], int nargin,
 void Test_constructor_13(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<Test> Shared;
+  typedef boost::shared_ptr<Test> Shared;
 
   Shared *self = new Shared(new Test());
   collector_Test.insert(self);
@@ -283,7 +283,7 @@ void Test_constructor_13(int nargout, mxArray *out[], int nargin, const mxArray
 void Test_constructor_14(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<Test> Shared;
+  typedef boost::shared_ptr<Test> Shared;
 
   double a = unwrap< double >(in[0]);
   Matrix b = unwrap< Matrix >(in[1]);
@@ -295,7 +295,7 @@ void Test_constructor_14(int nargout, mxArray *out[], int nargin, const mxArray
 
 void Test_deconstructor_15(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<Test> Shared;
+  typedef boost::shared_ptr<Test> Shared;
   checkArguments("delete_Test",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_Test::iterator item;
@@ -319,7 +319,7 @@ void Test_create_MixedPtrs_17(int nargout, mxArray *out[], int nargin, const mxA
   checkArguments("create_MixedPtrs",nargout,nargin-1,0);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   auto pairResult = obj->create_MixedPtrs();
-  out[0] = wrap_shared_ptr(std::make_shared<Test>(pairResult.first),"Test", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<Test>(pairResult.first),"Test", false);
   out[1] = wrap_shared_ptr(pairResult.second,"Test", false);
 }
 
@@ -336,7 +336,7 @@ void Test_get_container_19(int nargout, mxArray *out[], int nargin, const mxArra
 {
   checkArguments("get_container",nargout,nargin-1,0);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  out[0] = wrap_shared_ptr(std::make_shared<std::vector<testing::Test>>(obj->get_container()),"std.vectorTest", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<std::vector<testing::Test>>(obj->get_container()),"std.vectorTest", false);
 }
 
 void Test_lambda_20(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -374,7 +374,7 @@ void Test_return_Point2Ptr_24(int nargout, mxArray *out[], int nargin, const mxA
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   bool value = unwrap< bool >(in[1]);
   {
-  std::shared_ptr<Point2> shared(obj->return_Point2Ptr(value));
+  boost::shared_ptr<Point2> shared(obj->return_Point2Ptr(value));
   out[0] = wrap_shared_ptr(shared,"Point2");
   }
 }
@@ -383,15 +383,15 @@ void Test_return_Test_25(int nargout, mxArray *out[], int nargin, const mxArray
 {
   checkArguments("return_Test",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  std::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
+  boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
-  out[0] = wrap_shared_ptr(std::make_shared<Test>(obj->return_Test(value)),"Test", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<Test>(obj->return_Test(value)),"Test", false);
 }
 
 void Test_return_TestPtr_26(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("return_TestPtr",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  std::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
+  boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
   out[0] = wrap_shared_ptr(obj->return_TestPtr(value),"Test", false);
 }
 
@@ -468,8 +468,8 @@ void Test_return_ptrs_35(int nargout, mxArray *out[], int nargin, const mxArray
 {
   checkArguments("return_ptrs",nargout,nargin-1,2);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  std::shared_ptr<Test> p1 = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
+  boost::shared_ptr<Test> p1 = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
-  std::shared_ptr<Test> p2 = unwrap_shared_ptr< Test >(in[2], "ptr_Test");
+  boost::shared_ptr<Test> p2 = unwrap_shared_ptr< Test >(in[2], "ptr_Test");
   auto pairResult = obj->return_ptrs(p1,p2);
   out[0] = wrap_shared_ptr(pairResult.first,"Test", false);
   out[1] = wrap_shared_ptr(pairResult.second,"Test", false);
@@ -511,7 +511,7 @@ void Test_set_container_40(int nargout, mxArray *out[], int nargin, const mxArra
 {
   checkArguments("set_container",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  std::shared_ptr<std::vector<testing::Test>> container = unwrap_shared_ptr< std::vector<testing::Test> >(in[1], "ptr_stdvectorTest");
+  boost::shared_ptr<std::vector<testing::Test>> container = unwrap_shared_ptr< std::vector<testing::Test> >(in[1], "ptr_stdvectorTest");
   obj->set_container(*container);
 }
 
@@ -519,7 +519,7 @@ void Test_set_container_41(int nargout, mxArray *out[], int nargin, const mxArra
 {
   checkArguments("set_container",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  std::shared_ptr<std::vector<testing::Test>> container = unwrap_shared_ptr< std::vector<testing::Test> >(in[1], "ptr_stdvectorTest");
+  boost::shared_ptr<std::vector<testing::Test>> container = unwrap_shared_ptr< std::vector<testing::Test> >(in[1], "ptr_stdvectorTest");
   obj->set_container(*container);
 }
 
@@ -527,7 +527,7 @@ void Test_set_container_42(int nargout, mxArray *out[], int nargin, const mxArra
 {
   checkArguments("set_container",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  std::shared_ptr<std::vector<testing::Test>> container = unwrap_shared_ptr< std::vector<testing::Test> >(in[1], "ptr_stdvectorTest");
+  boost::shared_ptr<std::vector<testing::Test>> container = unwrap_shared_ptr< std::vector<testing::Test> >(in[1], "ptr_stdvectorTest");
   obj->set_container(*container);
 }
 
@@ -542,7 +542,7 @@ void Test_set_model_ptr_44(int nargout, mxArray *out[], int nargin, const mxArra
 {
   checkArguments("model_ptr",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  std::shared_ptr<gtsam::noiseModel::Base> model_ptr = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[1], "ptr_gtsamnoiseModelBase");
+  boost::shared_ptr<gtsam::noiseModel::Base> model_ptr = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[1], "ptr_gtsamnoiseModelBase");
   obj->model_ptr = *model_ptr;
 }
 
@@ -579,7 +579,7 @@ void Test_set_name_48(int nargout, mxArray *out[], int nargin, const mxArray *in
 void PrimitiveRefDouble_collectorInsertAndMakeBase_49(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<PrimitiveRef<double>> Shared;
+  typedef boost::shared_ptr<PrimitiveRef<double>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_PrimitiveRefDouble.insert(self);
@@ -588,7 +588,7 @@ void PrimitiveRefDouble_collectorInsertAndMakeBase_49(int nargout, mxArray *out[
 void PrimitiveRefDouble_constructor_50(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<PrimitiveRef<double>> Shared;
+  typedef boost::shared_ptr<PrimitiveRef<double>> Shared;
 
   Shared *self = new Shared(new PrimitiveRef<double>());
   collector_PrimitiveRefDouble.insert(self);
@@ -598,7 +598,7 @@ void PrimitiveRefDouble_constructor_50(int nargout, mxArray *out[], int nargin,
 
 void PrimitiveRefDouble_deconstructor_51(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<PrimitiveRef<double>> Shared;
+  typedef boost::shared_ptr<PrimitiveRef<double>> Shared;
   checkArguments("delete_PrimitiveRefDouble",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_PrimitiveRefDouble::iterator item;
@@ -613,13 +613,13 @@ void PrimitiveRefDouble_Brutal_52(int nargout, mxArray *out[], int nargin, const
 {
   checkArguments("PrimitiveRef<double>.Brutal",nargout,nargin,1);
   double t = unwrap< double >(in[0]);
-  out[0] = wrap_shared_ptr(std::make_shared<PrimitiveRef<double>>(PrimitiveRef<double>::Brutal(t)),"PrimitiveRefdouble", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<PrimitiveRef<double>>(PrimitiveRef<double>::Brutal(t)),"PrimitiveRefdouble", false);
 }
 
 void MyVector3_collectorInsertAndMakeBase_53(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyVector<3>> Shared;
+  typedef boost::shared_ptr<MyVector<3>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MyVector3.insert(self);
@@ -628,7 +628,7 @@ void MyVector3_collectorInsertAndMakeBase_53(int nargout, mxArray *out[], int na
 void MyVector3_constructor_54(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyVector<3>> Shared;
+  typedef boost::shared_ptr<MyVector<3>> Shared;
 
   Shared *self = new Shared(new MyVector<3>());
   collector_MyVector3.insert(self);
@@ -638,7 +638,7 @@ void MyVector3_constructor_54(int nargout, mxArray *out[], int nargin, const mxA
 
 void MyVector3_deconstructor_55(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MyVector<3>> Shared;
+  typedef boost::shared_ptr<MyVector<3>> Shared;
   checkArguments("delete_MyVector3",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MyVector3::iterator item;
@@ -652,7 +652,7 @@ void MyVector3_deconstructor_55(int nargout, mxArray *out[], int nargin, const m
 void MyVector12_collectorInsertAndMakeBase_56(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyVector<12>> Shared;
+  typedef boost::shared_ptr<MyVector<12>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MyVector12.insert(self);
@@ -661,7 +661,7 @@ void MyVector12_collectorInsertAndMakeBase_56(int nargout, mxArray *out[], int n
 void MyVector12_constructor_57(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyVector<12>> Shared;
+  typedef boost::shared_ptr<MyVector<12>> Shared;
 
   Shared *self = new Shared(new MyVector<12>());
   collector_MyVector12.insert(self);
@@ -671,7 +671,7 @@ void MyVector12_constructor_57(int nargout, mxArray *out[], int nargin, const mx
 
 void MyVector12_deconstructor_58(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MyVector<12>> Shared;
+  typedef boost::shared_ptr<MyVector<12>> Shared;
   checkArguments("delete_MyVector12",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MyVector12::iterator item;
@@ -685,7 +685,7 @@ void MyVector12_deconstructor_58(int nargout, mxArray *out[], int nargin, const
 void MultipleTemplatesIntDouble_collectorInsertAndMakeBase_59(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MultipleTemplates<int, double>> Shared;
+  typedef boost::shared_ptr<MultipleTemplates<int, double>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MultipleTemplatesIntDouble.insert(self);
@@ -693,7 +693,7 @@ void MultipleTemplatesIntDouble_collectorInsertAndMakeBase_59(int nargout, mxArr
 
 void MultipleTemplatesIntDouble_deconstructor_60(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MultipleTemplates<int, double>> Shared;
+  typedef boost::shared_ptr<MultipleTemplates<int, double>> Shared;
   checkArguments("delete_MultipleTemplatesIntDouble",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MultipleTemplatesIntDouble::iterator item;
@@ -707,7 +707,7 @@ void MultipleTemplatesIntDouble_deconstructor_60(int nargout, mxArray *out[], in
 void MultipleTemplatesIntFloat_collectorInsertAndMakeBase_61(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MultipleTemplates<int, float>> Shared;
+  typedef boost::shared_ptr<MultipleTemplates<int, float>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MultipleTemplatesIntFloat.insert(self);
@@ -715,7 +715,7 @@ void MultipleTemplatesIntFloat_collectorInsertAndMakeBase_61(int nargout, mxArra
 
 void MultipleTemplatesIntFloat_deconstructor_62(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MultipleTemplates<int, float>> Shared;
+  typedef boost::shared_ptr<MultipleTemplates<int, float>> Shared;
   checkArguments("delete_MultipleTemplatesIntFloat",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MultipleTemplatesIntFloat::iterator item;
@@ -729,7 +729,7 @@ void MultipleTemplatesIntFloat_deconstructor_62(int nargout, mxArray *out[], int
 void ForwardKinematics_collectorInsertAndMakeBase_63(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ForwardKinematics> Shared;
+  typedef boost::shared_ptr<ForwardKinematics> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ForwardKinematics.insert(self);
@@ -738,7 +738,7 @@ void ForwardKinematics_collectorInsertAndMakeBase_63(int nargout, mxArray *out[]
 void ForwardKinematics_constructor_64(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ForwardKinematics> Shared;
+  typedef boost::shared_ptr<ForwardKinematics> Shared;
 
   gtdynamics::Robot& robot = *unwrap_shared_ptr< gtdynamics::Robot >(in[0], "ptr_gtdynamicsRobot");
   string& start_link_name = *unwrap_shared_ptr< string >(in[1], "ptr_string");
@@ -754,7 +754,7 @@ void ForwardKinematics_constructor_64(int nargout, mxArray *out[], int nargin, c
 void ForwardKinematics_constructor_65(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ForwardKinematics> Shared;
+  typedef boost::shared_ptr<ForwardKinematics> Shared;
 
   gtdynamics::Robot& robot = *unwrap_shared_ptr< gtdynamics::Robot >(in[0], "ptr_gtdynamicsRobot");
   string& start_link_name = *unwrap_shared_ptr< string >(in[1], "ptr_string");
@@ -768,7 +768,7 @@ void ForwardKinematics_constructor_65(int nargout, mxArray *out[], int nargin, c
 
 void ForwardKinematics_deconstructor_66(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ForwardKinematics> Shared;
+  typedef boost::shared_ptr<ForwardKinematics> Shared;
   checkArguments("delete_ForwardKinematics",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ForwardKinematics::iterator item;
@@ -782,7 +782,7 @@ void ForwardKinematics_deconstructor_66(int nargout, mxArray *out[], int nargin,
 void TemplatedConstructor_collectorInsertAndMakeBase_67(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_TemplatedConstructor.insert(self);
@@ -791,7 +791,7 @@ void TemplatedConstructor_collectorInsertAndMakeBase_67(int nargout, mxArray *ou
 void TemplatedConstructor_constructor_68(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   Shared *self = new Shared(new TemplatedConstructor());
   collector_TemplatedConstructor.insert(self);
@@ -802,7 +802,7 @@ void TemplatedConstructor_constructor_68(int nargout, mxArray *out[], int nargin
 void TemplatedConstructor_constructor_69(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   string& arg = *unwrap_shared_ptr< string >(in[0], "ptr_string");
   Shared *self = new Shared(new TemplatedConstructor(arg));
@@ -814,7 +814,7 @@ void TemplatedConstructor_constructor_69(int nargout, mxArray *out[], int nargin
 void TemplatedConstructor_constructor_70(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   int arg = unwrap< int >(in[0]);
   Shared *self = new Shared(new TemplatedConstructor(arg));
@@ -826,7 +826,7 @@ void TemplatedConstructor_constructor_70(int nargout, mxArray *out[], int nargin
 void TemplatedConstructor_constructor_71(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   double arg = unwrap< double >(in[0]);
   Shared *self = new Shared(new TemplatedConstructor(arg));
@@ -837,7 +837,7 @@ void TemplatedConstructor_constructor_71(int nargout, mxArray *out[], int nargin
 
 void TemplatedConstructor_deconstructor_72(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
   checkArguments("delete_TemplatedConstructor",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_TemplatedConstructor::iterator item;
@@ -851,7 +851,7 @@ void TemplatedConstructor_deconstructor_72(int nargout, mxArray *out[], int narg
 void MyFactorPosePoint2_collectorInsertAndMakeBase_73(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyFactor<gtsam::Pose2, gtsam::Matrix>> Shared;
+  typedef boost::shared_ptr<MyFactor<gtsam::Pose2, gtsam::Matrix>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MyFactorPosePoint2.insert(self);
@@ -860,12 +860,12 @@ void MyFactorPosePoint2_collectorInsertAndMakeBase_73(int nargout, mxArray *out[
 void MyFactorPosePoint2_constructor_74(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyFactor<gtsam::Pose2, gtsam::Matrix>> Shared;
+  typedef boost::shared_ptr<MyFactor<gtsam::Pose2, gtsam::Matrix>> Shared;
 
   size_t key1 = unwrap< size_t >(in[0]);
   size_t key2 = unwrap< size_t >(in[1]);
   double measured = unwrap< double >(in[2]);
-  std::shared_ptr<gtsam::noiseModel::Base> noiseModel = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[3], "ptr_gtsamnoiseModelBase");
+  boost::shared_ptr<gtsam::noiseModel::Base> noiseModel = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[3], "ptr_gtsamnoiseModelBase");
   Shared *self = new Shared(new MyFactor<gtsam::Pose2, gtsam::Matrix>(key1,key2,measured,noiseModel));
   collector_MyFactorPosePoint2.insert(self);
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
@@ -874,7 +874,7 @@ void MyFactorPosePoint2_constructor_74(int nargout, mxArray *out[], int nargin,
 
 void MyFactorPosePoint2_deconstructor_75(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MyFactor<gtsam::Pose2, gtsam::Matrix>> Shared;
+  typedef boost::shared_ptr<MyFactor<gtsam::Pose2, gtsam::Matrix>> Shared;
   checkArguments("delete_MyFactorPosePoint2",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MyFactorPosePoint2::iterator item;

wrap/tests/expected/matlab/functions_wrapper.cpp

@@ -62,7 +62,7 @@ void load2D_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("load2D",nargout,nargin,5);
   string filename = unwrap< string >(in[0]);
-  std::shared_ptr<Test> model = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
+  boost::shared_ptr<Test> model = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
   int maxID = unwrap< int >(in[2]);
   bool addNoise = unwrap< bool >(in[3]);
   bool smart = unwrap< bool >(in[4]);
@@ -74,7 +74,7 @@ void load2D_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("load2D",nargout,nargin,5);
   string filename = unwrap< string >(in[0]);
-  std::shared_ptr<gtsam::noiseModel::Diagonal> model = unwrap_shared_ptr< gtsam::noiseModel::Diagonal >(in[1], "ptr_gtsamnoiseModelDiagonal");
+  boost::shared_ptr<gtsam::noiseModel::Diagonal> model = unwrap_shared_ptr< gtsam::noiseModel::Diagonal >(in[1], "ptr_gtsamnoiseModelDiagonal");
   int maxID = unwrap< int >(in[2]);
   bool addNoise = unwrap< bool >(in[3]);
   bool smart = unwrap< bool >(in[4]);

wrap/tests/expected/matlab/geometry_wrapper.cpp

@@ -12,9 +12,9 @@
 BOOST_CLASS_EXPORT_GUID(gtsam::Point2, "gtsamPoint2");
 BOOST_CLASS_EXPORT_GUID(gtsam::Point3, "gtsamPoint3");
 
-typedef std::set<std::shared_ptr<gtsam::Point2>*> Collector_gtsamPoint2;
+typedef std::set<boost::shared_ptr<gtsam::Point2>*> Collector_gtsamPoint2;
 static Collector_gtsamPoint2 collector_gtsamPoint2;
-typedef std::set<std::shared_ptr<gtsam::Point3>*> Collector_gtsamPoint3;
+typedef std::set<boost::shared_ptr<gtsam::Point3>*> Collector_gtsamPoint3;
 static Collector_gtsamPoint3 collector_gtsamPoint3;
 
 
@@ -80,7 +80,7 @@ void _geometry_RTTIRegister() {
 void gtsamPoint2_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Point2> Shared;
+  typedef boost::shared_ptr<gtsam::Point2> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamPoint2.insert(self);
@@ -89,7 +89,7 @@ void gtsamPoint2_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int n
 void gtsamPoint2_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Point2> Shared;
+  typedef boost::shared_ptr<gtsam::Point2> Shared;
 
   Shared *self = new Shared(new gtsam::Point2());
   collector_gtsamPoint2.insert(self);
@@ -100,7 +100,7 @@ void gtsamPoint2_constructor_1(int nargout, mxArray *out[], int nargin, const mx
 void gtsamPoint2_constructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Point2> Shared;
+  typedef boost::shared_ptr<gtsam::Point2> Shared;
 
   double x = unwrap< double >(in[0]);
   double y = unwrap< double >(in[1]);
@@ -112,7 +112,7 @@ void gtsamPoint2_constructor_2(int nargout, mxArray *out[], int nargin, const mx
 
 void gtsamPoint2_deconstructor_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::Point2> Shared;
+  typedef boost::shared_ptr<gtsam::Point2> Shared;
   checkArguments("delete_gtsamPoint2",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamPoint2::iterator item;
@@ -135,7 +135,7 @@ void gtsamPoint2_argChar_5(int nargout, mxArray *out[], int nargin, const mxArra
 {
   checkArguments("argChar",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<gtsam::Point2>(in[0], "ptr_gtsamPoint2");
-  std::shared_ptr<char> a = unwrap_shared_ptr< char >(in[1], "ptr_char");
+  boost::shared_ptr<char> a = unwrap_shared_ptr< char >(in[1], "ptr_char");
   obj->argChar(a);
 }
 
@@ -159,7 +159,7 @@ void gtsamPoint2_argChar_8(int nargout, mxArray *out[], int nargin, const mxArra
 {
   checkArguments("argChar",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<gtsam::Point2>(in[0], "ptr_gtsamPoint2");
-  std::shared_ptr<char> a = unwrap_shared_ptr< char >(in[1], "ptr_char");
+  boost::shared_ptr<char> a = unwrap_shared_ptr< char >(in[1], "ptr_char");
   obj->argChar(a);
 }
 
@@ -214,7 +214,7 @@ void gtsamPoint2_vectorConfusion_15(int nargout, mxArray *out[], int nargin, con
 {
   checkArguments("vectorConfusion",nargout,nargin-1,0);
   auto obj = unwrap_shared_ptr<gtsam::Point2>(in[0], "ptr_gtsamPoint2");
-  out[0] = wrap_shared_ptr(std::make_shared<VectorNotEigen>(obj->vectorConfusion()),"VectorNotEigen", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<VectorNotEigen>(obj->vectorConfusion()),"VectorNotEigen", false);
 }
 
 void gtsamPoint2_x_16(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -234,7 +234,7 @@ void gtsamPoint2_y_17(int nargout, mxArray *out[], int nargin, const mxArray *in
 void gtsamPoint3_collectorInsertAndMakeBase_18(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Point3> Shared;
+  typedef boost::shared_ptr<gtsam::Point3> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamPoint3.insert(self);
@@ -243,7 +243,7 @@ void gtsamPoint3_collectorInsertAndMakeBase_18(int nargout, mxArray *out[], int
 void gtsamPoint3_constructor_19(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Point3> Shared;
+  typedef boost::shared_ptr<gtsam::Point3> Shared;
 
   double x = unwrap< double >(in[0]);
   double y = unwrap< double >(in[1]);
@@ -256,7 +256,7 @@ void gtsamPoint3_constructor_19(int nargout, mxArray *out[], int nargin, const m
 
 void gtsamPoint3_deconstructor_20(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::Point3> Shared;
+  typedef boost::shared_ptr<gtsam::Point3> Shared;
   checkArguments("delete_gtsamPoint3",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamPoint3::iterator item;
@@ -276,7 +276,7 @@ void gtsamPoint3_norm_21(int nargout, mxArray *out[], int nargin, const mxArray
 
 void gtsamPoint3_string_serialize_22(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::Point3> Shared;
+  typedef boost::shared_ptr<gtsam::Point3> Shared;
   checkArguments("string_serialize",nargout,nargin-1,0);
   Shared obj = unwrap_shared_ptr<gtsam::Point3>(in[0], "ptr_gtsamPoint3");
   ostringstream out_archive_stream;
@@ -299,7 +299,7 @@ void gtsamPoint3_staticFunction_24(int nargout, mxArray *out[], int nargin, cons
 
 void gtsamPoint3_string_deserialize_25(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::Point3> Shared;
+  typedef boost::shared_ptr<gtsam::Point3> Shared;
   checkArguments("gtsamPoint3.string_deserialize",nargout,nargin,1);
   string serialized = unwrap< string >(in[0]);
   istringstream in_archive_stream(serialized);

wrap/tests/expected/matlab/inheritance_wrapper.cpp

@@ -12,17 +12,17 @@ typedef MyTemplate<gtsam::Matrix> MyTemplateMatrix;
 typedef MyTemplate<A> MyTemplateA;
 typedef ParentHasTemplate<double> ParentHasTemplateDouble;
 
-typedef std::set<std::shared_ptr<MyBase>*> Collector_MyBase;
+typedef std::set<boost::shared_ptr<MyBase>*> Collector_MyBase;
 static Collector_MyBase collector_MyBase;
-typedef std::set<std::shared_ptr<MyTemplatePoint2>*> Collector_MyTemplatePoint2;
+typedef std::set<boost::shared_ptr<MyTemplatePoint2>*> Collector_MyTemplatePoint2;
 static Collector_MyTemplatePoint2 collector_MyTemplatePoint2;
-typedef std::set<std::shared_ptr<MyTemplateMatrix>*> Collector_MyTemplateMatrix;
+typedef std::set<boost::shared_ptr<MyTemplateMatrix>*> Collector_MyTemplateMatrix;
 static Collector_MyTemplateMatrix collector_MyTemplateMatrix;
-typedef std::set<std::shared_ptr<MyTemplateA>*> Collector_MyTemplateA;
+typedef std::set<boost::shared_ptr<MyTemplateA>*> Collector_MyTemplateA;
 static Collector_MyTemplateA collector_MyTemplateA;
-typedef std::set<std::shared_ptr<ForwardKinematicsFactor>*> Collector_ForwardKinematicsFactor;
+typedef std::set<boost::shared_ptr<ForwardKinematicsFactor>*> Collector_ForwardKinematicsFactor;
 static Collector_ForwardKinematicsFactor collector_ForwardKinematicsFactor;
-typedef std::set<std::shared_ptr<ParentHasTemplateDouble>*> Collector_ParentHasTemplateDouble;
+typedef std::set<boost::shared_ptr<ParentHasTemplateDouble>*> Collector_ParentHasTemplateDouble;
 static Collector_ParentHasTemplateDouble collector_ParentHasTemplateDouble;
 
 
@@ -118,7 +118,7 @@ void _inheritance_RTTIRegister() {
 void MyBase_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyBase> Shared;
+  typedef boost::shared_ptr<MyBase> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MyBase.insert(self);
@@ -126,16 +126,16 @@ void MyBase_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin
 
 void MyBase_upcastFromVoid_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyBase> Shared;
+  typedef boost::shared_ptr<MyBase> Shared;
-  std::shared_ptr<void> *asVoid = *reinterpret_cast<std::shared_ptr<void>**> (mxGetData(in[0]));
+  boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
-  Shared *self = new Shared(std::static_pointer_cast<MyBase>(*asVoid));
+  Shared *self = new Shared(boost::static_pointer_cast<MyBase>(*asVoid));
   *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;
 }
 
 void MyBase_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MyBase> Shared;
+  typedef boost::shared_ptr<MyBase> Shared;
   checkArguments("delete_MyBase",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MyBase::iterator item;
@@ -149,43 +149,43 @@ void MyBase_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArr
 void MyTemplatePoint2_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<gtsam::Point2>> Shared;
+  typedef boost::shared_ptr<MyTemplate<gtsam::Point2>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MyTemplatePoint2.insert(self);
 
-  typedef std::shared_ptr<MyBase> SharedBase;
+  typedef boost::shared_ptr<MyBase> SharedBase;
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<SharedBase**>(mxGetData(out[0])) = new SharedBase(*self);
 }
 
 void MyTemplatePoint2_upcastFromVoid_4(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<gtsam::Point2>> Shared;
+  typedef boost::shared_ptr<MyTemplate<gtsam::Point2>> Shared;
-  std::shared_ptr<void> *asVoid = *reinterpret_cast<std::shared_ptr<void>**> (mxGetData(in[0]));
+  boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
-  Shared *self = new Shared(std::static_pointer_cast<MyTemplate<gtsam::Point2>>(*asVoid));
+  Shared *self = new Shared(boost::static_pointer_cast<MyTemplate<gtsam::Point2>>(*asVoid));
   *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;
 }
 
 void MyTemplatePoint2_constructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<gtsam::Point2>> Shared;
+  typedef boost::shared_ptr<MyTemplate<gtsam::Point2>> Shared;
 
   Shared *self = new Shared(new MyTemplate<gtsam::Point2>());
   collector_MyTemplatePoint2.insert(self);
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
 
-  typedef std::shared_ptr<MyBase> SharedBase;
+  typedef boost::shared_ptr<MyBase> SharedBase;
   out[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<SharedBase**>(mxGetData(out[1])) = new SharedBase(*self);
 }
 
 void MyTemplatePoint2_deconstructor_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MyTemplate<gtsam::Point2>> Shared;
+  typedef boost::shared_ptr<MyTemplate<gtsam::Point2>> Shared;
   checkArguments("delete_MyTemplatePoint2",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MyTemplatePoint2::iterator item;
@@ -219,7 +219,7 @@ void MyTemplatePoint2_create_MixedPtrs_9(int nargout, mxArray *out[], int nargin
   auto pairResult = obj->create_MixedPtrs();
   out[0] = wrap< Point2 >(pairResult.first);
   {
-  std::shared_ptr<Point2> shared(pairResult.second);
+  boost::shared_ptr<Point2> shared(pairResult.second);
   out[1] = wrap_shared_ptr(shared,"Point2");
   }
 }
@@ -230,11 +230,11 @@ void MyTemplatePoint2_create_ptrs_10(int nargout, mxArray *out[], int nargin, co
   auto obj = unwrap_shared_ptr<MyTemplate<gtsam::Point2>>(in[0], "ptr_MyTemplatePoint2");
   auto pairResult = obj->create_ptrs();
   {
-  std::shared_ptr<Point2> shared(pairResult.first);
+  boost::shared_ptr<Point2> shared(pairResult.first);
   out[0] = wrap_shared_ptr(shared,"Point2");
   }
   {
-  std::shared_ptr<Point2> shared(pairResult.second);
+  boost::shared_ptr<Point2> shared(pairResult.second);
   out[1] = wrap_shared_ptr(shared,"Point2");
   }
 }
@@ -253,7 +253,7 @@ void MyTemplatePoint2_return_Tptr_12(int nargout, mxArray *out[], int nargin, co
   auto obj = unwrap_shared_ptr<MyTemplate<gtsam::Point2>>(in[0], "ptr_MyTemplatePoint2");
   Point2 value = unwrap< Point2 >(in[1]);
   {
-  std::shared_ptr<Point2> shared(obj->return_Tptr(value));
+  boost::shared_ptr<Point2> shared(obj->return_Tptr(value));
   out[0] = wrap_shared_ptr(shared,"Point2");
   }
 }
@@ -266,11 +266,11 @@ void MyTemplatePoint2_return_ptrs_13(int nargout, mxArray *out[], int nargin, co
   Point2 p2 = unwrap< Point2 >(in[2]);
   auto pairResult = obj->return_ptrs(p1,p2);
   {
-  std::shared_ptr<Point2> shared(pairResult.first);
+  boost::shared_ptr<Point2> shared(pairResult.first);
   out[0] = wrap_shared_ptr(shared,"Point2");
   }
   {
-  std::shared_ptr<Point2> shared(pairResult.second);
+  boost::shared_ptr<Point2> shared(pairResult.second);
   out[1] = wrap_shared_ptr(shared,"Point2");
   }
 }
@@ -311,49 +311,49 @@ void MyTemplatePoint2_Level_18(int nargout, mxArray *out[], int nargin, const mx
 {
   checkArguments("MyTemplate<gtsam::Point2>.Level",nargout,nargin,1);
   Point2 K = unwrap< Point2 >(in[0]);
-  out[0] = wrap_shared_ptr(std::make_shared<MyTemplate<Point2>>(MyTemplate<gtsam::Point2>::Level(K)),"MyTemplatePoint2", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<MyTemplate<Point2>>(MyTemplate<gtsam::Point2>::Level(K)),"MyTemplatePoint2", false);
 }
 
 void MyTemplateMatrix_collectorInsertAndMakeBase_19(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<gtsam::Matrix>> Shared;
+  typedef boost::shared_ptr<MyTemplate<gtsam::Matrix>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MyTemplateMatrix.insert(self);
 
-  typedef std::shared_ptr<MyBase> SharedBase;
+  typedef boost::shared_ptr<MyBase> SharedBase;
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<SharedBase**>(mxGetData(out[0])) = new SharedBase(*self);
 }
 
 void MyTemplateMatrix_upcastFromVoid_20(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<gtsam::Matrix>> Shared;
+  typedef boost::shared_ptr<MyTemplate<gtsam::Matrix>> Shared;
-  std::shared_ptr<void> *asVoid = *reinterpret_cast<std::shared_ptr<void>**> (mxGetData(in[0]));
+  boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
-  Shared *self = new Shared(std::static_pointer_cast<MyTemplate<gtsam::Matrix>>(*asVoid));
+  Shared *self = new Shared(boost::static_pointer_cast<MyTemplate<gtsam::Matrix>>(*asVoid));
   *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;
 }
 
 void MyTemplateMatrix_constructor_21(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<gtsam::Matrix>> Shared;
+  typedef boost::shared_ptr<MyTemplate<gtsam::Matrix>> Shared;
 
   Shared *self = new Shared(new MyTemplate<gtsam::Matrix>());
   collector_MyTemplateMatrix.insert(self);
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
 
-  typedef std::shared_ptr<MyBase> SharedBase;
+  typedef boost::shared_ptr<MyBase> SharedBase;
   out[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<SharedBase**>(mxGetData(out[1])) = new SharedBase(*self);
 }
 
 void MyTemplateMatrix_deconstructor_22(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MyTemplate<gtsam::Matrix>> Shared;
+  typedef boost::shared_ptr<MyTemplate<gtsam::Matrix>> Shared;
   checkArguments("delete_MyTemplateMatrix",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MyTemplateMatrix::iterator item;
@@ -387,7 +387,7 @@ void MyTemplateMatrix_create_MixedPtrs_25(int nargout, mxArray *out[], int nargi
   auto pairResult = obj->create_MixedPtrs();
   out[0] = wrap< Matrix >(pairResult.first);
   {
-  std::shared_ptr<Matrix> shared(pairResult.second);
+  boost::shared_ptr<Matrix> shared(pairResult.second);
   out[1] = wrap_shared_ptr(shared,"Matrix");
   }
 }
@@ -398,11 +398,11 @@ void MyTemplateMatrix_create_ptrs_26(int nargout, mxArray *out[], int nargin, co
   auto obj = unwrap_shared_ptr<MyTemplate<gtsam::Matrix>>(in[0], "ptr_MyTemplateMatrix");
   auto pairResult = obj->create_ptrs();
   {
-  std::shared_ptr<Matrix> shared(pairResult.first);
+  boost::shared_ptr<Matrix> shared(pairResult.first);
   out[0] = wrap_shared_ptr(shared,"Matrix");
   }
   {
-  std::shared_ptr<Matrix> shared(pairResult.second);
+  boost::shared_ptr<Matrix> shared(pairResult.second);
   out[1] = wrap_shared_ptr(shared,"Matrix");
   }
 }
@@ -421,7 +421,7 @@ void MyTemplateMatrix_return_Tptr_28(int nargout, mxArray *out[], int nargin, co
   auto obj = unwrap_shared_ptr<MyTemplate<gtsam::Matrix>>(in[0], "ptr_MyTemplateMatrix");
   Matrix value = unwrap< Matrix >(in[1]);
   {
-  std::shared_ptr<Matrix> shared(obj->return_Tptr(value));
+  boost::shared_ptr<Matrix> shared(obj->return_Tptr(value));
   out[0] = wrap_shared_ptr(shared,"Matrix");
   }
 }
@@ -434,11 +434,11 @@ void MyTemplateMatrix_return_ptrs_29(int nargout, mxArray *out[], int nargin, co
   Matrix p2 = unwrap< Matrix >(in[2]);
   auto pairResult = obj->return_ptrs(p1,p2);
   {
-  std::shared_ptr<Matrix> shared(pairResult.first);
+  boost::shared_ptr<Matrix> shared(pairResult.first);
   out[0] = wrap_shared_ptr(shared,"Matrix");
   }
   {
-  std::shared_ptr<Matrix> shared(pairResult.second);
+  boost::shared_ptr<Matrix> shared(pairResult.second);
   out[1] = wrap_shared_ptr(shared,"Matrix");
   }
 }
@@ -479,49 +479,49 @@ void MyTemplateMatrix_Level_34(int nargout, mxArray *out[], int nargin, const mx
 {
   checkArguments("MyTemplate<gtsam::Matrix>.Level",nargout,nargin,1);
   Matrix K = unwrap< Matrix >(in[0]);
-  out[0] = wrap_shared_ptr(std::make_shared<MyTemplate<Matrix>>(MyTemplate<gtsam::Matrix>::Level(K)),"MyTemplateMatrix", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<MyTemplate<Matrix>>(MyTemplate<gtsam::Matrix>::Level(K)),"MyTemplateMatrix", false);
 }
 
 void MyTemplateA_collectorInsertAndMakeBase_35(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<A>> Shared;
+  typedef boost::shared_ptr<MyTemplate<A>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_MyTemplateA.insert(self);
 
-  typedef std::shared_ptr<MyBase> SharedBase;
+  typedef boost::shared_ptr<MyBase> SharedBase;
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<SharedBase**>(mxGetData(out[0])) = new SharedBase(*self);
 }
 
 void MyTemplateA_upcastFromVoid_36(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<A>> Shared;
+  typedef boost::shared_ptr<MyTemplate<A>> Shared;
-  std::shared_ptr<void> *asVoid = *reinterpret_cast<std::shared_ptr<void>**> (mxGetData(in[0]));
+  boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
-  Shared *self = new Shared(std::static_pointer_cast<MyTemplate<A>>(*asVoid));
+  Shared *self = new Shared(boost::static_pointer_cast<MyTemplate<A>>(*asVoid));
   *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;
 }
 
 void MyTemplateA_constructor_37(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<MyTemplate<A>> Shared;
+  typedef boost::shared_ptr<MyTemplate<A>> Shared;
 
   Shared *self = new Shared(new MyTemplate<A>());
   collector_MyTemplateA.insert(self);
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
 
-  typedef std::shared_ptr<MyBase> SharedBase;
+  typedef boost::shared_ptr<MyBase> SharedBase;
   out[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<SharedBase**>(mxGetData(out[1])) = new SharedBase(*self);
 }
 
 void MyTemplateA_deconstructor_38(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<MyTemplate<A>> Shared;
+  typedef boost::shared_ptr<MyTemplate<A>> Shared;
   checkArguments("delete_MyTemplateA",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_MyTemplateA::iterator item;
@@ -544,7 +544,7 @@ void MyTemplateA_accept_Tptr_40(int nargout, mxArray *out[], int nargin, const m
 {
   checkArguments("accept_Tptr",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<MyTemplate<A>>(in[0], "ptr_MyTemplateA");
-  std::shared_ptr<A> value = unwrap_shared_ptr< A >(in[1], "ptr_A");
+  boost::shared_ptr<A> value = unwrap_shared_ptr< A >(in[1], "ptr_A");
   obj->accept_Tptr(value);
 }
 
@@ -553,7 +553,7 @@ void MyTemplateA_create_MixedPtrs_41(int nargout, mxArray *out[], int nargin, co
   checkArguments("create_MixedPtrs",nargout,nargin-1,0);
   auto obj = unwrap_shared_ptr<MyTemplate<A>>(in[0], "ptr_MyTemplateA");
   auto pairResult = obj->create_MixedPtrs();
-  out[0] = wrap_shared_ptr(std::make_shared<A>(pairResult.first),"A", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<A>(pairResult.first),"A", false);
   out[1] = wrap_shared_ptr(pairResult.second,"A", false);
 }
 
@@ -571,14 +571,14 @@ void MyTemplateA_return_T_43(int nargout, mxArray *out[], int nargin, const mxAr
   checkArguments("return_T",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<MyTemplate<A>>(in[0], "ptr_MyTemplateA");
   A* value = unwrap_ptr< A >(in[1], "ptr_A");
-  out[0] = wrap_shared_ptr(std::make_shared<A>(obj->return_T(value)),"A", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<A>(obj->return_T(value)),"A", false);
 }
 
 void MyTemplateA_return_Tptr_44(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("return_Tptr",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<MyTemplate<A>>(in[0], "ptr_MyTemplateA");
-  std::shared_ptr<A> value = unwrap_shared_ptr< A >(in[1], "ptr_A");
+  boost::shared_ptr<A> value = unwrap_shared_ptr< A >(in[1], "ptr_A");
   out[0] = wrap_shared_ptr(obj->return_Tptr(value),"A", false);
 }
 
@@ -586,8 +586,8 @@ void MyTemplateA_return_ptrs_45(int nargout, mxArray *out[], int nargin, const m
 {
   checkArguments("return_ptrs",nargout,nargin-1,2);
   auto obj = unwrap_shared_ptr<MyTemplate<A>>(in[0], "ptr_MyTemplateA");
-  std::shared_ptr<A> p1 = unwrap_shared_ptr< A >(in[1], "ptr_A");
+  boost::shared_ptr<A> p1 = unwrap_shared_ptr< A >(in[1], "ptr_A");
-  std::shared_ptr<A> p2 = unwrap_shared_ptr< A >(in[2], "ptr_A");
+  boost::shared_ptr<A> p2 = unwrap_shared_ptr< A >(in[2], "ptr_A");
   auto pairResult = obj->return_ptrs(p1,p2);
   out[0] = wrap_shared_ptr(pairResult.first,"A", false);
   out[1] = wrap_shared_ptr(pairResult.second,"A", false);
@@ -629,34 +629,34 @@ void MyTemplateA_Level_50(int nargout, mxArray *out[], int nargin, const mxArray
 {
   checkArguments("MyTemplate<A>.Level",nargout,nargin,1);
   A& K = *unwrap_shared_ptr< A >(in[0], "ptr_A");
-  out[0] = wrap_shared_ptr(std::make_shared<MyTemplate<A>>(MyTemplate<A>::Level(K)),"MyTemplateA", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<MyTemplate<A>>(MyTemplate<A>::Level(K)),"MyTemplateA", false);
 }
 
 void ForwardKinematicsFactor_collectorInsertAndMakeBase_51(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ForwardKinematicsFactor> Shared;
+  typedef boost::shared_ptr<ForwardKinematicsFactor> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ForwardKinematicsFactor.insert(self);
 
-  typedef std::shared_ptr<gtsam::BetweenFactor<gtsam::Pose3>> SharedBase;
+  typedef boost::shared_ptr<gtsam::BetweenFactor<gtsam::Pose3>> SharedBase;
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<SharedBase**>(mxGetData(out[0])) = new SharedBase(*self);
 }
 
 void ForwardKinematicsFactor_upcastFromVoid_52(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ForwardKinematicsFactor> Shared;
+  typedef boost::shared_ptr<ForwardKinematicsFactor> Shared;
-  std::shared_ptr<void> *asVoid = *reinterpret_cast<std::shared_ptr<void>**> (mxGetData(in[0]));
+  boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
-  Shared *self = new Shared(std::static_pointer_cast<ForwardKinematicsFactor>(*asVoid));
+  Shared *self = new Shared(boost::static_pointer_cast<ForwardKinematicsFactor>(*asVoid));
   *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;
 }
 
 void ForwardKinematicsFactor_deconstructor_53(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ForwardKinematicsFactor> Shared;
+  typedef boost::shared_ptr<ForwardKinematicsFactor> Shared;
   checkArguments("delete_ForwardKinematicsFactor",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ForwardKinematicsFactor::iterator item;
@@ -670,28 +670,28 @@ void ForwardKinematicsFactor_deconstructor_53(int nargout, mxArray *out[], int n
 void ParentHasTemplateDouble_collectorInsertAndMakeBase_54(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ParentHasTemplate<double>> Shared;
+  typedef boost::shared_ptr<ParentHasTemplate<double>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ParentHasTemplateDouble.insert(self);
 
-  typedef std::shared_ptr<MyTemplate<double>> SharedBase;
+  typedef boost::shared_ptr<MyTemplate<double>> SharedBase;
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
   *reinterpret_cast<SharedBase**>(mxGetData(out[0])) = new SharedBase(*self);
 }
 
 void ParentHasTemplateDouble_upcastFromVoid_55(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ParentHasTemplate<double>> Shared;
+  typedef boost::shared_ptr<ParentHasTemplate<double>> Shared;
-  std::shared_ptr<void> *asVoid = *reinterpret_cast<std::shared_ptr<void>**> (mxGetData(in[0]));
+  boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));
   out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
-  Shared *self = new Shared(std::static_pointer_cast<ParentHasTemplate<double>>(*asVoid));
+  Shared *self = new Shared(boost::static_pointer_cast<ParentHasTemplate<double>>(*asVoid));
   *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;
 }
 
 void ParentHasTemplateDouble_deconstructor_56(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ParentHasTemplate<double>> Shared;
+  typedef boost::shared_ptr<ParentHasTemplate<double>> Shared;
   checkArguments("delete_ParentHasTemplateDouble",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ParentHasTemplateDouble::iterator item;

wrap/tests/expected/matlab/multiple_files_wrapper.cpp

@@ -9,11 +9,11 @@
 
 
 
-typedef std::set<std::shared_ptr<gtsam::Class1>*> Collector_gtsamClass1;
+typedef std::set<boost::shared_ptr<gtsam::Class1>*> Collector_gtsamClass1;
 static Collector_gtsamClass1 collector_gtsamClass1;
-typedef std::set<std::shared_ptr<gtsam::Class2>*> Collector_gtsamClass2;
+typedef std::set<boost::shared_ptr<gtsam::Class2>*> Collector_gtsamClass2;
 static Collector_gtsamClass2 collector_gtsamClass2;
-typedef std::set<std::shared_ptr<gtsam::ClassA>*> Collector_gtsamClassA;
+typedef std::set<boost::shared_ptr<gtsam::ClassA>*> Collector_gtsamClassA;
 static Collector_gtsamClassA collector_gtsamClassA;
 
 
@@ -85,7 +85,7 @@ void _multiple_files_RTTIRegister() {
 void gtsamClass1_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Class1> Shared;
+  typedef boost::shared_ptr<gtsam::Class1> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamClass1.insert(self);
@@ -94,7 +94,7 @@ void gtsamClass1_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int n
 void gtsamClass1_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Class1> Shared;
+  typedef boost::shared_ptr<gtsam::Class1> Shared;
 
   Shared *self = new Shared(new gtsam::Class1());
   collector_gtsamClass1.insert(self);
@@ -104,7 +104,7 @@ void gtsamClass1_constructor_1(int nargout, mxArray *out[], int nargin, const mx
 
 void gtsamClass1_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::Class1> Shared;
+  typedef boost::shared_ptr<gtsam::Class1> Shared;
   checkArguments("delete_gtsamClass1",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamClass1::iterator item;
@@ -118,7 +118,7 @@ void gtsamClass1_deconstructor_2(int nargout, mxArray *out[], int nargin, const
 void gtsamClass2_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Class2> Shared;
+  typedef boost::shared_ptr<gtsam::Class2> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamClass2.insert(self);
@@ -127,7 +127,7 @@ void gtsamClass2_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int n
 void gtsamClass2_constructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Class2> Shared;
+  typedef boost::shared_ptr<gtsam::Class2> Shared;
 
   Shared *self = new Shared(new gtsam::Class2());
   collector_gtsamClass2.insert(self);
@@ -137,7 +137,7 @@ void gtsamClass2_constructor_4(int nargout, mxArray *out[], int nargin, const mx
 
 void gtsamClass2_deconstructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::Class2> Shared;
+  typedef boost::shared_ptr<gtsam::Class2> Shared;
   checkArguments("delete_gtsamClass2",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamClass2::iterator item;
@@ -151,7 +151,7 @@ void gtsamClass2_deconstructor_5(int nargout, mxArray *out[], int nargin, const
 void gtsamClassA_collectorInsertAndMakeBase_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::ClassA> Shared;
+  typedef boost::shared_ptr<gtsam::ClassA> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamClassA.insert(self);
@@ -160,7 +160,7 @@ void gtsamClassA_collectorInsertAndMakeBase_6(int nargout, mxArray *out[], int n
 void gtsamClassA_constructor_7(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::ClassA> Shared;
+  typedef boost::shared_ptr<gtsam::ClassA> Shared;
 
   Shared *self = new Shared(new gtsam::ClassA());
   collector_gtsamClassA.insert(self);
@@ -170,7 +170,7 @@ void gtsamClassA_constructor_7(int nargout, mxArray *out[], int nargin, const mx
 
 void gtsamClassA_deconstructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::ClassA> Shared;
+  typedef boost::shared_ptr<gtsam::ClassA> Shared;
   checkArguments("delete_gtsamClassA",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamClassA::iterator item;

wrap/tests/expected/matlab/namespaces_wrapper.cpp

@@ -14,19 +14,19 @@
 
 
 
-typedef std::set<std::shared_ptr<ns1::ClassA>*> Collector_ns1ClassA;
+typedef std::set<boost::shared_ptr<ns1::ClassA>*> Collector_ns1ClassA;
 static Collector_ns1ClassA collector_ns1ClassA;
-typedef std::set<std::shared_ptr<ns1::ClassB>*> Collector_ns1ClassB;
+typedef std::set<boost::shared_ptr<ns1::ClassB>*> Collector_ns1ClassB;
 static Collector_ns1ClassB collector_ns1ClassB;
-typedef std::set<std::shared_ptr<ns2::ClassA>*> Collector_ns2ClassA;
+typedef std::set<boost::shared_ptr<ns2::ClassA>*> Collector_ns2ClassA;
 static Collector_ns2ClassA collector_ns2ClassA;
-typedef std::set<std::shared_ptr<ns2::ns3::ClassB>*> Collector_ns2ns3ClassB;
+typedef std::set<boost::shared_ptr<ns2::ns3::ClassB>*> Collector_ns2ns3ClassB;
 static Collector_ns2ns3ClassB collector_ns2ns3ClassB;
-typedef std::set<std::shared_ptr<ns2::ClassC>*> Collector_ns2ClassC;
+typedef std::set<boost::shared_ptr<ns2::ClassC>*> Collector_ns2ClassC;
 static Collector_ns2ClassC collector_ns2ClassC;
-typedef std::set<std::shared_ptr<ClassD>*> Collector_ClassD;
+typedef std::set<boost::shared_ptr<ClassD>*> Collector_ClassD;
 static Collector_ClassD collector_ClassD;
-typedef std::set<std::shared_ptr<gtsam::Values>*> Collector_gtsamValues;
+typedef std::set<boost::shared_ptr<gtsam::Values>*> Collector_gtsamValues;
 static Collector_gtsamValues collector_gtsamValues;
 
 
@@ -122,7 +122,7 @@ void _namespaces_RTTIRegister() {
 void ns1ClassA_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns1::ClassA> Shared;
+  typedef boost::shared_ptr<ns1::ClassA> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ns1ClassA.insert(self);
@@ -131,7 +131,7 @@ void ns1ClassA_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nar
 void ns1ClassA_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns1::ClassA> Shared;
+  typedef boost::shared_ptr<ns1::ClassA> Shared;
 
   Shared *self = new Shared(new ns1::ClassA());
   collector_ns1ClassA.insert(self);
@@ -141,7 +141,7 @@ void ns1ClassA_constructor_1(int nargout, mxArray *out[], int nargin, const mxAr
 
 void ns1ClassA_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ns1::ClassA> Shared;
+  typedef boost::shared_ptr<ns1::ClassA> Shared;
   checkArguments("delete_ns1ClassA",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ns1ClassA::iterator item;
@@ -155,7 +155,7 @@ void ns1ClassA_deconstructor_2(int nargout, mxArray *out[], int nargin, const mx
 void ns1ClassB_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns1::ClassB> Shared;
+  typedef boost::shared_ptr<ns1::ClassB> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ns1ClassB.insert(self);
@@ -164,7 +164,7 @@ void ns1ClassB_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nar
 void ns1ClassB_constructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns1::ClassB> Shared;
+  typedef boost::shared_ptr<ns1::ClassB> Shared;
 
   Shared *self = new Shared(new ns1::ClassB());
   collector_ns1ClassB.insert(self);
@@ -174,7 +174,7 @@ void ns1ClassB_constructor_4(int nargout, mxArray *out[], int nargin, const mxAr
 
 void ns1ClassB_deconstructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ns1::ClassB> Shared;
+  typedef boost::shared_ptr<ns1::ClassB> Shared;
   checkArguments("delete_ns1ClassB",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ns1ClassB::iterator item;
@@ -193,7 +193,7 @@ void aGlobalFunction_6(int nargout, mxArray *out[], int nargin, const mxArray *i
 void ns2ClassA_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns2::ClassA> Shared;
+  typedef boost::shared_ptr<ns2::ClassA> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ns2ClassA.insert(self);
@@ -202,7 +202,7 @@ void ns2ClassA_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nar
 void ns2ClassA_constructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns2::ClassA> Shared;
+  typedef boost::shared_ptr<ns2::ClassA> Shared;
 
   Shared *self = new Shared(new ns2::ClassA());
   collector_ns2ClassA.insert(self);
@@ -212,7 +212,7 @@ void ns2ClassA_constructor_8(int nargout, mxArray *out[], int nargin, const mxAr
 
 void ns2ClassA_deconstructor_9(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ns2::ClassA> Shared;
+  typedef boost::shared_ptr<ns2::ClassA> Shared;
   checkArguments("delete_ns2ClassA",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ns2ClassA::iterator item;
@@ -243,7 +243,7 @@ void ns2ClassA_nsReturn_12(int nargout, mxArray *out[], int nargin, const mxArra
   checkArguments("nsReturn",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
   double q = unwrap< double >(in[1]);
-  out[0] = wrap_shared_ptr(std::make_shared<ns2::ns3::ClassB>(obj->nsReturn(q)),"ns2.ns3.ClassB", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<ns2::ns3::ClassB>(obj->nsReturn(q)),"ns2.ns3.ClassB", false);
 }
 
 void ns2ClassA_afunction_13(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -255,7 +255,7 @@ void ns2ClassA_afunction_13(int nargout, mxArray *out[], int nargin, const mxArr
 void ns2ns3ClassB_collectorInsertAndMakeBase_14(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns2::ns3::ClassB> Shared;
+  typedef boost::shared_ptr<ns2::ns3::ClassB> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ns2ns3ClassB.insert(self);
@@ -264,7 +264,7 @@ void ns2ns3ClassB_collectorInsertAndMakeBase_14(int nargout, mxArray *out[], int
 void ns2ns3ClassB_constructor_15(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns2::ns3::ClassB> Shared;
+  typedef boost::shared_ptr<ns2::ns3::ClassB> Shared;
 
   Shared *self = new Shared(new ns2::ns3::ClassB());
   collector_ns2ns3ClassB.insert(self);
@@ -274,7 +274,7 @@ void ns2ns3ClassB_constructor_15(int nargout, mxArray *out[], int nargin, const
 
 void ns2ns3ClassB_deconstructor_16(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ns2::ns3::ClassB> Shared;
+  typedef boost::shared_ptr<ns2::ns3::ClassB> Shared;
   checkArguments("delete_ns2ns3ClassB",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ns2ns3ClassB::iterator item;
@@ -288,7 +288,7 @@ void ns2ns3ClassB_deconstructor_16(int nargout, mxArray *out[], int nargin, cons
 void ns2ClassC_collectorInsertAndMakeBase_17(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns2::ClassC> Shared;
+  typedef boost::shared_ptr<ns2::ClassC> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ns2ClassC.insert(self);
@@ -297,7 +297,7 @@ void ns2ClassC_collectorInsertAndMakeBase_17(int nargout, mxArray *out[], int na
 void ns2ClassC_constructor_18(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ns2::ClassC> Shared;
+  typedef boost::shared_ptr<ns2::ClassC> Shared;
 
   Shared *self = new Shared(new ns2::ClassC());
   collector_ns2ClassC.insert(self);
@@ -307,7 +307,7 @@ void ns2ClassC_constructor_18(int nargout, mxArray *out[], int nargin, const mxA
 
 void ns2ClassC_deconstructor_19(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ns2::ClassC> Shared;
+  typedef boost::shared_ptr<ns2::ClassC> Shared;
   checkArguments("delete_ns2ClassC",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ns2ClassC::iterator item;
@@ -327,19 +327,19 @@ void overloadedGlobalFunction_21(int nargout, mxArray *out[], int nargin, const
 {
   checkArguments("overloadedGlobalFunction",nargout,nargin,1);
   ns1::ClassA& a = *unwrap_shared_ptr< ns1::ClassA >(in[0], "ptr_ns1ClassA");
-  out[0] = wrap_shared_ptr(std::make_shared<ns1::ClassA>(ns2::overloadedGlobalFunction(a)),"ns1.ClassA", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<ns1::ClassA>(ns2::overloadedGlobalFunction(a)),"ns1.ClassA", false);
 }
 void overloadedGlobalFunction_22(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("overloadedGlobalFunction",nargout,nargin,2);
   ns1::ClassA& a = *unwrap_shared_ptr< ns1::ClassA >(in[0], "ptr_ns1ClassA");
   double b = unwrap< double >(in[1]);
-  out[0] = wrap_shared_ptr(std::make_shared<ns1::ClassA>(ns2::overloadedGlobalFunction(a,b)),"ns1.ClassA", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<ns1::ClassA>(ns2::overloadedGlobalFunction(a,b)),"ns1.ClassA", false);
 }
 void ClassD_collectorInsertAndMakeBase_23(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ClassD> Shared;
+  typedef boost::shared_ptr<ClassD> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ClassD.insert(self);
@@ -348,7 +348,7 @@ void ClassD_collectorInsertAndMakeBase_23(int nargout, mxArray *out[], int nargi
 void ClassD_constructor_24(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ClassD> Shared;
+  typedef boost::shared_ptr<ClassD> Shared;
 
   Shared *self = new Shared(new ClassD());
   collector_ClassD.insert(self);
@@ -358,7 +358,7 @@ void ClassD_constructor_24(int nargout, mxArray *out[], int nargin, const mxArra
 
 void ClassD_deconstructor_25(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ClassD> Shared;
+  typedef boost::shared_ptr<ClassD> Shared;
   checkArguments("delete_ClassD",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ClassD::iterator item;
@@ -372,7 +372,7 @@ void ClassD_deconstructor_25(int nargout, mxArray *out[], int nargin, const mxAr
 void gtsamValues_collectorInsertAndMakeBase_26(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Values> Shared;
+  typedef boost::shared_ptr<gtsam::Values> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamValues.insert(self);
@@ -381,7 +381,7 @@ void gtsamValues_collectorInsertAndMakeBase_26(int nargout, mxArray *out[], int
 void gtsamValues_constructor_27(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Values> Shared;
+  typedef boost::shared_ptr<gtsam::Values> Shared;
 
   Shared *self = new Shared(new gtsam::Values());
   collector_gtsamValues.insert(self);
@@ -392,7 +392,7 @@ void gtsamValues_constructor_27(int nargout, mxArray *out[], int nargin, const m
 void gtsamValues_constructor_28(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::Values> Shared;
+  typedef boost::shared_ptr<gtsam::Values> Shared;
 
   gtsam::Values& other = *unwrap_shared_ptr< gtsam::Values >(in[0], "ptr_gtsamValues");
   Shared *self = new Shared(new gtsam::Values(other));
@@ -403,7 +403,7 @@ void gtsamValues_constructor_28(int nargout, mxArray *out[], int nargin, const m
 
 void gtsamValues_deconstructor_29(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::Values> Shared;
+  typedef boost::shared_ptr<gtsam::Values> Shared;
   checkArguments("delete_gtsamValues",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamValues::iterator item;

wrap/tests/expected/matlab/special_cases_wrapper.cpp

@@ -10,13 +10,13 @@
 typedef gtsam::PinholeCamera<gtsam::Cal3Bundler> PinholeCameraCal3Bundler;
 typedef gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3> GeneralSFMFactorCal3Bundler;
 
-typedef std::set<std::shared_ptr<gtsam::NonlinearFactorGraph>*> Collector_gtsamNonlinearFactorGraph;
+typedef std::set<boost::shared_ptr<gtsam::NonlinearFactorGraph>*> Collector_gtsamNonlinearFactorGraph;
 static Collector_gtsamNonlinearFactorGraph collector_gtsamNonlinearFactorGraph;
-typedef std::set<std::shared_ptr<gtsam::SfmTrack>*> Collector_gtsamSfmTrack;
+typedef std::set<boost::shared_ptr<gtsam::SfmTrack>*> Collector_gtsamSfmTrack;
 static Collector_gtsamSfmTrack collector_gtsamSfmTrack;
-typedef std::set<std::shared_ptr<PinholeCameraCal3Bundler>*> Collector_gtsamPinholeCameraCal3Bundler;
+typedef std::set<boost::shared_ptr<PinholeCameraCal3Bundler>*> Collector_gtsamPinholeCameraCal3Bundler;
 static Collector_gtsamPinholeCameraCal3Bundler collector_gtsamPinholeCameraCal3Bundler;
-typedef std::set<std::shared_ptr<GeneralSFMFactorCal3Bundler>*> Collector_gtsamGeneralSFMFactorCal3Bundler;
+typedef std::set<boost::shared_ptr<GeneralSFMFactorCal3Bundler>*> Collector_gtsamGeneralSFMFactorCal3Bundler;
 static Collector_gtsamGeneralSFMFactorCal3Bundler collector_gtsamGeneralSFMFactorCal3Bundler;
 
 
@@ -94,7 +94,7 @@ void _special_cases_RTTIRegister() {
 void gtsamNonlinearFactorGraph_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::NonlinearFactorGraph> Shared;
+  typedef boost::shared_ptr<gtsam::NonlinearFactorGraph> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamNonlinearFactorGraph.insert(self);
@@ -102,7 +102,7 @@ void gtsamNonlinearFactorGraph_collectorInsertAndMakeBase_0(int nargout, mxArray
 
 void gtsamNonlinearFactorGraph_deconstructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::NonlinearFactorGraph> Shared;
+  typedef boost::shared_ptr<gtsam::NonlinearFactorGraph> Shared;
   checkArguments("delete_gtsamNonlinearFactorGraph",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamNonlinearFactorGraph::iterator item;
@@ -119,14 +119,14 @@ void gtsamNonlinearFactorGraph_addPrior_2(int nargout, mxArray *out[], int nargi
   auto obj = unwrap_shared_ptr<gtsam::NonlinearFactorGraph>(in[0], "ptr_gtsamNonlinearFactorGraph");
   size_t key = unwrap< size_t >(in[1]);
   gtsam::PinholeCamera<gtsam::Cal3Bundler>& prior = *unwrap_shared_ptr< gtsam::PinholeCamera<gtsam::Cal3Bundler> >(in[2], "ptr_gtsamPinholeCameraCal3Bundler");
-  std::shared_ptr<gtsam::noiseModel::Base> noiseModel = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[3], "ptr_gtsamnoiseModelBase");
+  boost::shared_ptr<gtsam::noiseModel::Base> noiseModel = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[3], "ptr_gtsamnoiseModelBase");
   obj->addPrior<gtsam::PinholeCamera<gtsam::Cal3Bundler>>(key,prior,noiseModel);
 }
 
 void gtsamSfmTrack_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::SfmTrack> Shared;
+  typedef boost::shared_ptr<gtsam::SfmTrack> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamSfmTrack.insert(self);
@@ -134,7 +134,7 @@ void gtsamSfmTrack_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int
 
 void gtsamSfmTrack_deconstructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::SfmTrack> Shared;
+  typedef boost::shared_ptr<gtsam::SfmTrack> Shared;
   checkArguments("delete_gtsamSfmTrack",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamSfmTrack::iterator item;
@@ -149,21 +149,21 @@ void gtsamSfmTrack_get_measurements_5(int nargout, mxArray *out[], int nargin, c
 {
   checkArguments("measurements",nargout,nargin-1,0);
   auto obj = unwrap_shared_ptr<gtsam::SfmTrack>(in[0], "ptr_gtsamSfmTrack");
-  out[0] = wrap_shared_ptr(std::make_shared<std::vector<std::pair<size_t,Point2>>>(obj->measurements),"std.vectorpairsize_tPoint2", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<std::vector<std::pair<size_t,Point2>>>(obj->measurements),"std.vectorpairsize_tPoint2", false);
 }
 
 void gtsamSfmTrack_set_measurements_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("measurements",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<gtsam::SfmTrack>(in[0], "ptr_gtsamSfmTrack");
-  std::shared_ptr<std::vector<std::pair<size_t,Point2>>> measurements = unwrap_shared_ptr< std::vector<std::pair<size_t,Point2>> >(in[1], "ptr_stdvectorpairsize_tPoint2");
+  boost::shared_ptr<std::vector<std::pair<size_t,Point2>>> measurements = unwrap_shared_ptr< std::vector<std::pair<size_t,Point2>> >(in[1], "ptr_stdvectorpairsize_tPoint2");
   obj->measurements = *measurements;
 }
 
 void gtsamPinholeCameraCal3Bundler_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::PinholeCamera<gtsam::Cal3Bundler>> Shared;
+  typedef boost::shared_ptr<gtsam::PinholeCamera<gtsam::Cal3Bundler>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamPinholeCameraCal3Bundler.insert(self);
@@ -171,7 +171,7 @@ void gtsamPinholeCameraCal3Bundler_collectorInsertAndMakeBase_7(int nargout, mxA
 
 void gtsamPinholeCameraCal3Bundler_deconstructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::PinholeCamera<gtsam::Cal3Bundler>> Shared;
+  typedef boost::shared_ptr<gtsam::PinholeCamera<gtsam::Cal3Bundler>> Shared;
   checkArguments("delete_gtsamPinholeCameraCal3Bundler",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamPinholeCameraCal3Bundler::iterator item;
@@ -185,7 +185,7 @@ void gtsamPinholeCameraCal3Bundler_deconstructor_8(int nargout, mxArray *out[],
 void gtsamGeneralSFMFactorCal3Bundler_collectorInsertAndMakeBase_9(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>> Shared;
+  typedef boost::shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_gtsamGeneralSFMFactorCal3Bundler.insert(self);
@@ -193,7 +193,7 @@ void gtsamGeneralSFMFactorCal3Bundler_collectorInsertAndMakeBase_9(int nargout,
 
 void gtsamGeneralSFMFactorCal3Bundler_deconstructor_10(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>> Shared;
+  typedef boost::shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>> Shared;
   checkArguments("delete_gtsamGeneralSFMFactorCal3Bundler",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_gtsamGeneralSFMFactorCal3Bundler::iterator item;
@@ -208,14 +208,14 @@ void gtsamGeneralSFMFactorCal3Bundler_get_verbosity_11(int nargout, mxArray *out
 {
   checkArguments("verbosity",nargout,nargin-1,0);
   auto obj = unwrap_shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>>(in[0], "ptr_gtsamGeneralSFMFactorCal3Bundler");
-  out[0] = wrap_shared_ptr(std::make_shared<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity>(obj->verbosity),"gtsam.GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>.Verbosity", false);
+  out[0] = wrap_shared_ptr(boost::make_shared<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity>(obj->verbosity),"gtsam.GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>.Verbosity", false);
 }
 
 void gtsamGeneralSFMFactorCal3Bundler_set_verbosity_12(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   checkArguments("verbosity",nargout,nargin-1,1);
   auto obj = unwrap_shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>>(in[0], "ptr_gtsamGeneralSFMFactorCal3Bundler");
-  std::shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity> verbosity = unwrap_shared_ptr< gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity >(in[1], "ptr_gtsamGeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>Verbosity");
+  boost::shared_ptr<gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity> verbosity = unwrap_shared_ptr< gtsam::GeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>::Verbosity >(in[1], "ptr_gtsamGeneralSFMFactor<gtsam::PinholeCamera<gtsam::Cal3Bundler>, gtsam::Point3>Verbosity");
   obj->verbosity = *verbosity;
 }
 

wrap/tests/expected/matlab/template_wrapper.cpp

@@ -9,9 +9,9 @@
 
 typedef ScopedTemplate<Result> ScopedTemplateResult;
 
-typedef std::set<std::shared_ptr<TemplatedConstructor>*> Collector_TemplatedConstructor;
+typedef std::set<boost::shared_ptr<TemplatedConstructor>*> Collector_TemplatedConstructor;
 static Collector_TemplatedConstructor collector_TemplatedConstructor;
-typedef std::set<std::shared_ptr<ScopedTemplateResult>*> Collector_ScopedTemplateResult;
+typedef std::set<boost::shared_ptr<ScopedTemplateResult>*> Collector_ScopedTemplateResult;
 static Collector_ScopedTemplateResult collector_ScopedTemplateResult;
 
 
@@ -77,7 +77,7 @@ void _template_RTTIRegister() {
 void TemplatedConstructor_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_TemplatedConstructor.insert(self);
@@ -86,7 +86,7 @@ void TemplatedConstructor_collectorInsertAndMakeBase_0(int nargout, mxArray *out
 void TemplatedConstructor_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   Shared *self = new Shared(new TemplatedConstructor());
   collector_TemplatedConstructor.insert(self);
@@ -97,7 +97,7 @@ void TemplatedConstructor_constructor_1(int nargout, mxArray *out[], int nargin,
 void TemplatedConstructor_constructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   string& arg = *unwrap_shared_ptr< string >(in[0], "ptr_string");
   Shared *self = new Shared(new TemplatedConstructor(arg));
@@ -109,7 +109,7 @@ void TemplatedConstructor_constructor_2(int nargout, mxArray *out[], int nargin,
 void TemplatedConstructor_constructor_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   int arg = unwrap< int >(in[0]);
   Shared *self = new Shared(new TemplatedConstructor(arg));
@@ -121,7 +121,7 @@ void TemplatedConstructor_constructor_3(int nargout, mxArray *out[], int nargin,
 void TemplatedConstructor_constructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
 
   double arg = unwrap< double >(in[0]);
   Shared *self = new Shared(new TemplatedConstructor(arg));
@@ -132,7 +132,7 @@ void TemplatedConstructor_constructor_4(int nargout, mxArray *out[], int nargin,
 
 void TemplatedConstructor_deconstructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<TemplatedConstructor> Shared;
+  typedef boost::shared_ptr<TemplatedConstructor> Shared;
   checkArguments("delete_TemplatedConstructor",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_TemplatedConstructor::iterator item;
@@ -146,7 +146,7 @@ void TemplatedConstructor_deconstructor_5(int nargout, mxArray *out[], int nargi
 void ScopedTemplateResult_collectorInsertAndMakeBase_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ScopedTemplate<Result>> Shared;
+  typedef boost::shared_ptr<ScopedTemplate<Result>> Shared;
 
   Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
   collector_ScopedTemplateResult.insert(self);
@@ -155,7 +155,7 @@ void ScopedTemplateResult_collectorInsertAndMakeBase_6(int nargout, mxArray *out
 void ScopedTemplateResult_constructor_7(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
-  typedef std::shared_ptr<ScopedTemplate<Result>> Shared;
+  typedef boost::shared_ptr<ScopedTemplate<Result>> Shared;
 
   Result::Value& arg = *unwrap_shared_ptr< Result::Value >(in[0], "ptr_Result::Value");
   Shared *self = new Shared(new ScopedTemplate<Result>(arg));
@@ -166,7 +166,7 @@ void ScopedTemplateResult_constructor_7(int nargout, mxArray *out[], int nargin,
 
 void ScopedTemplateResult_deconstructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
-  typedef std::shared_ptr<ScopedTemplate<Result>> Shared;
+  typedef boost::shared_ptr<ScopedTemplate<Result>> Shared;
   checkArguments("delete_ScopedTemplateResult",nargout,nargin,1);
   Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
   Collector_ScopedTemplateResult::iterator item;

wrap/tests/test_interface_parser.py

@@ -91,7 +91,7 @@ class TestInterfaceParser(unittest.TestCase):
         self.assertTrue(t.is_shared_ptr)
         self.assertEqual("std::shared_ptr<gtsam::Pose3>",
                          t.to_cpp(use_boost=False))
-        self.assertEqual("std::shared_ptr<gtsam::Pose3>",
+        self.assertEqual("boost::shared_ptr<gtsam::Pose3>",
                          t.to_cpp(use_boost=True))
 
         # Check raw pointer
@@ -179,7 +179,7 @@ class TestInterfaceParser(unittest.TestCase):
                          args_list[0].ctype.to_cpp(False))
         self.assertEqual("vector<std::shared_ptr<T>>",
                          args_list[1].ctype.to_cpp(False))
-        self.assertEqual("vector<std::shared_ptr<T>>",
+        self.assertEqual("vector<boost::shared_ptr<T>>",
                          args_list[1].ctype.to_cpp(True))
 
     def test_default_arguments(self):