Fixed testWrap so that it passes, fixed dependency checking in codegen, fixed warnings

wrap/Class.h

@@ -34,7 +34,7 @@ struct Class {
 	typedef std::map<std::string, StaticMethod> StaticMethods;
 
   /// Constructor creates an empty class
-  Class(bool verbose=true) : verbose_(verbose), isVirtual(false) {}
+  Class(bool verbose=true) : isVirtual(false), verbose_(verbose) {}
 
 	// Then the instance variables are set directly by the Module constructor
   std::string name;                         ///< Class name

wrap/Method.h

@@ -30,7 +30,7 @@ struct Method {
 
 	/// Constructor creates empty object
 	Method(bool verbose = true) :
-			verbose_(verbose) {}
+			verbose_(verbose), is_const_(false) {}
 
 	// Then the instance variables are set directly by the Module constructor
 	bool verbose_;

wrap/Module.cpp

@@ -348,8 +348,8 @@ void Module::matlab_code(const string& toolboxPath, const string& headerPath) co
 		//Create a list of parsed classes for dependency checking
     BOOST_FOREACH(const Class& cls, classes) {
 			validTypes.push_back(cls.qualifiedName("::"));
-    }
+    }
-
+
 		// Create type attributes table
 		ReturnValue::TypeAttributesTable typeAttributes;
 		BOOST_FOREACH(const ForwardDeclaration& fwDec, forward_declarations) {
@@ -363,6 +363,18 @@ void Module::matlab_code(const string& toolboxPath, const string& headerPath) co
 			// Check that class is virtual if it has a parent
 		}
 
+    // Check that all classes have been defined somewhere
+		BOOST_FOREACH(const Class& cls, classes) {
+      // verify all of the function arguments
+      //TODO:verifyArguments<ArgumentList>(validTypes, cls.constructor.args_list);
+      verifyArguments<StaticMethod>(validTypes, cls.static_methods);
+      verifyArguments<Method>(validTypes, cls.methods);
+
+      // verify function return types
+      verifyReturnTypes<StaticMethod>(validTypes, cls.static_methods);
+      verifyReturnTypes<Method>(validTypes, cls.methods);
+    }
+
 		// Generate all includes
 		BOOST_FOREACH(const Class& cls, classes) {
 			generateIncludes(wrapperFile, cls.name, cls.includes);
@@ -394,20 +406,10 @@ void Module::matlab_code(const string& toolboxPath, const string& headerPath) co
 		}
 		wrapperFile.oss << "}\n";
 
-    // generate proxy classes and wrappers
+		// create proxy class and wrapper code
 		BOOST_FOREACH(const Class& cls, classes) {
-      // create proxy class and wrapper code
       string classFile = toolboxPath + "/" + cls.qualifiedName() + ".m";
       cls.matlab_proxy(classFile, wrapperName, typeAttributes, wrapperFile, functionNames);
-
-      // verify all of the function arguments
-      //TODO:verifyArguments<ArgumentList>(validTypes, cls.constructor.args_list);
-      verifyArguments<StaticMethod>(validTypes, cls.static_methods);
-      verifyArguments<Method>(validTypes, cls.methods);
-
-      // verify function return types
-      verifyReturnTypes<StaticMethod>(validTypes, cls.static_methods);
-      verifyReturnTypes<Method>(validTypes, cls.methods);
     }  
 
 		// finish wrapper file

wrap/tests/expected/Point2.m

@@ -1,81 +1,82 @@
 % automatically generated by wrap
 classdef Point2 < handle
   properties
-    self = 0
+    ptr_Point2 = 0
   end
   methods
     function obj = Point2(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        geometry_wrapper(obj.self);
+        geometry_wrapper(0, my_ptr);
       elseif nargin == 0
-        obj.self = geometry_wrapper(1);
+        my_ptr = geometry_wrapper(1);
       elseif nargin == 2 && isa(varargin{1},'double') && isa(varargin{2},'double')
-        obj.self = geometry_wrapper(2,varargin{1},varargin{2});
+        my_ptr = geometry_wrapper(2, varargin{1}, varargin{2});
       else
         error('Arguments do not match any overload of Point2 constructor');
       end
+      obj.ptr_Point2 = my_ptr;
     end
 
     function delete(obj)
-      geometry_wrapper(3, obj.self);
+      geometry_wrapper(3, obj.ptr_Point2);
     end
 
     function display(obj), obj.print(''); end
 
     function disp(obj), obj.display; end
 
-    function varargout = argChar(self, varargin)
+    function varargout = argChar(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'char')
-        geometry_wrapper(4, self, varargin{:});
+        geometry_wrapper(4, this, varargin{:});
       else
         error('Arguments do not match any overload of function Point2.argChar');
       end
     end
 
-    function varargout = argUChar(self, varargin)
+    function varargout = argUChar(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'char')
-        geometry_wrapper(5, self, varargin{:});
+        geometry_wrapper(5, this, varargin{:});
       else
         error('Arguments do not match any overload of function Point2.argUChar');
       end
     end
 
-    function varargout = dim(self, varargin)
+    function varargout = dim(this, varargin)
       if length(varargin) == 0
-        varargout{1} = geometry_wrapper(6, self, varargin{:});
+        varargout{1} = geometry_wrapper(6, this, varargin{:});
       else
         error('Arguments do not match any overload of function Point2.dim');
       end
     end
 
-    function varargout = returnChar(self, varargin)
+    function varargout = returnChar(this, varargin)
       if length(varargin) == 0
-        varargout{1} = geometry_wrapper(7, self, varargin{:});
+        varargout{1} = geometry_wrapper(7, this, varargin{:});
       else
         error('Arguments do not match any overload of function Point2.returnChar');
       end
     end
 
-    function varargout = vectorConfusion(self, varargin)
+    function varargout = vectorConfusion(this, varargin)
       if length(varargin) == 0
-        varargout{1} = geometry_wrapper(8, self, varargin{:});
+        varargout{1} = geometry_wrapper(8, this, varargin{:});
       else
         error('Arguments do not match any overload of function Point2.vectorConfusion');
       end
     end
 
-    function varargout = x(self, varargin)
+    function varargout = x(this, varargin)
       if length(varargin) == 0
-        varargout{1} = geometry_wrapper(9, self, varargin{:});
+        varargout{1} = geometry_wrapper(9, this, varargin{:});
       else
         error('Arguments do not match any overload of function Point2.x');
       end
     end
 
-    function varargout = y(self, varargin)
+    function varargout = y(this, varargin)
       if length(varargin) == 0
-        varargout{1} = geometry_wrapper(10, self, varargin{:});
+        varargout{1} = geometry_wrapper(10, this, varargin{:});
       else
         error('Arguments do not match any overload of function Point2.y');
       end

wrap/tests/expected/Point3.m

@@ -1,31 +1,32 @@
 % automatically generated by wrap
 classdef Point3 < handle
   properties
-    self = 0
+    ptr_Point3 = 0
   end
   methods
     function obj = Point3(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        geometry_wrapper(obj.self);
+        geometry_wrapper(11, my_ptr);
       elseif nargin == 3 && isa(varargin{1},'double') && isa(varargin{2},'double') && isa(varargin{3},'double')
-        obj.self = geometry_wrapper(12,varargin{1},varargin{2},varargin{3});
+        my_ptr = geometry_wrapper(12, varargin{1}, varargin{2}, varargin{3});
       else
         error('Arguments do not match any overload of Point3 constructor');
       end
+      obj.ptr_Point3 = my_ptr;
     end
 
     function delete(obj)
-      geometry_wrapper(13, obj.self);
+      geometry_wrapper(13, obj.ptr_Point3);
     end
 
     function display(obj), obj.print(''); end
 
     function disp(obj), obj.display; end
 
-    function varargout = norm(self, varargin)
+    function varargout = norm(this, varargin)
       if length(varargin) == 0
-        varargout{1} = geometry_wrapper(14, self, varargin{:});
+        varargout{1} = geometry_wrapper(14, this, varargin{:});
       else
         error('Arguments do not match any overload of function Point3.norm');
       end

wrap/tests/expected/Test.m

@@ -1,177 +1,178 @@
 % automatically generated by wrap
 classdef Test < handle
   properties
-    self = 0
+    ptr_Test = 0
   end
   methods
     function obj = Test(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        geometry_wrapper(obj.self);
+        geometry_wrapper(17, my_ptr);
       elseif nargin == 0
-        obj.self = geometry_wrapper(18);
+        my_ptr = geometry_wrapper(18);
       elseif nargin == 2 && isa(varargin{1},'double') && isa(varargin{2},'double')
-        obj.self = geometry_wrapper(19,varargin{1},varargin{2});
+        my_ptr = geometry_wrapper(19, varargin{1}, varargin{2});
       else
         error('Arguments do not match any overload of Test constructor');
       end
+      obj.ptr_Test = my_ptr;
     end
 
     function delete(obj)
-      geometry_wrapper(20, obj.self);
+      geometry_wrapper(20, obj.ptr_Test);
     end
 
     function display(obj), obj.print(''); end
 
     function disp(obj), obj.display; end
 
-    function varargout = arg_EigenConstRef(self, varargin)
+    function varargout = arg_EigenConstRef(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'double')
-        geometry_wrapper(21, self, varargin{:});
+        geometry_wrapper(21, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.arg_EigenConstRef');
       end
     end
 
-    function varargout = create_MixedPtrs(self, varargin)
+    function varargout = create_MixedPtrs(this, varargin)
       if length(varargin) == 0
-        [ varargout{1} varargout{2} ] = geometry_wrapper(22, self, varargin{:});
+        [ varargout{1} varargout{2} ] = geometry_wrapper(22, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.create_MixedPtrs');
       end
     end
 
-    function varargout = create_ptrs(self, varargin)
+    function varargout = create_ptrs(this, varargin)
       if length(varargin) == 0
-        [ varargout{1} varargout{2} ] = geometry_wrapper(23, self, varargin{:});
+        [ varargout{1} varargout{2} ] = geometry_wrapper(23, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.create_ptrs');
       end
     end
 
-    function varargout = print(self, varargin)
+    function varargout = print(this, varargin)
       if length(varargin) == 0
-        geometry_wrapper(24, self, varargin{:});
+        geometry_wrapper(24, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.print');
       end
     end
 
-    function varargout = return_Point2Ptr(self, varargin)
+    function varargout = return_Point2Ptr(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'logical')
-        varargout{1} = geometry_wrapper(25, self, varargin{:});
+        varargout{1} = geometry_wrapper(25, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_Point2Ptr');
       end
     end
 
-    function varargout = return_Test(self, varargin)
+    function varargout = return_Test(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'Test')
-        varargout{1} = geometry_wrapper(26, self, varargin{:});
+        varargout{1} = geometry_wrapper(26, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_Test');
       end
     end
 
-    function varargout = return_TestPtr(self, varargin)
+    function varargout = return_TestPtr(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'Test')
-        varargout{1} = geometry_wrapper(27, self, varargin{:});
+        varargout{1} = geometry_wrapper(27, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_TestPtr');
       end
     end
 
-    function varargout = return_bool(self, varargin)
+    function varargout = return_bool(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'logical')
-        varargout{1} = geometry_wrapper(28, self, varargin{:});
+        varargout{1} = geometry_wrapper(28, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_bool');
       end
     end
 
-    function varargout = return_double(self, varargin)
+    function varargout = return_double(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'double')
-        varargout{1} = geometry_wrapper(29, self, varargin{:});
+        varargout{1} = geometry_wrapper(29, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_double');
       end
     end
 
-    function varargout = return_field(self, varargin)
+    function varargout = return_field(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'Test')
-        varargout{1} = geometry_wrapper(30, self, varargin{:});
+        varargout{1} = geometry_wrapper(30, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_field');
       end
     end
 
-    function varargout = return_int(self, varargin)
+    function varargout = return_int(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'numeric')
-        varargout{1} = geometry_wrapper(31, self, varargin{:});
+        varargout{1} = geometry_wrapper(31, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_int');
       end
     end
 
-    function varargout = return_matrix1(self, varargin)
+    function varargout = return_matrix1(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'double')
-        varargout{1} = geometry_wrapper(32, self, varargin{:});
+        varargout{1} = geometry_wrapper(32, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_matrix1');
       end
     end
 
-    function varargout = return_matrix2(self, varargin)
+    function varargout = return_matrix2(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'double')
-        varargout{1} = geometry_wrapper(33, self, varargin{:});
+        varargout{1} = geometry_wrapper(33, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_matrix2');
       end
     end
 
-    function varargout = return_pair(self, varargin)
+    function varargout = return_pair(this, varargin)
       if length(varargin) == 2 && isa(varargin{1},'double') && isa(varargin{2},'double')
-        [ varargout{1} varargout{2} ] = geometry_wrapper(34, self, varargin{:});
+        [ varargout{1} varargout{2} ] = geometry_wrapper(34, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_pair');
       end
     end
 
-    function varargout = return_ptrs(self, varargin)
+    function varargout = return_ptrs(this, varargin)
       if length(varargin) == 2 && isa(varargin{1},'Test') && isa(varargin{2},'Test')
-        [ varargout{1} varargout{2} ] = geometry_wrapper(35, self, varargin{:});
+        [ varargout{1} varargout{2} ] = geometry_wrapper(35, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_ptrs');
       end
     end
 
-    function varargout = return_size_t(self, varargin)
+    function varargout = return_size_t(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'numeric')
-        varargout{1} = geometry_wrapper(36, self, varargin{:});
+        varargout{1} = geometry_wrapper(36, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_size_t');
       end
     end
 
-    function varargout = return_string(self, varargin)
+    function varargout = return_string(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'char')
-        varargout{1} = geometry_wrapper(37, self, varargin{:});
+        varargout{1} = geometry_wrapper(37, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_string');
       end
     end
 
-    function varargout = return_vector1(self, varargin)
+    function varargout = return_vector1(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'double')
-        varargout{1} = geometry_wrapper(38, self, varargin{:});
+        varargout{1} = geometry_wrapper(38, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_vector1');
       end
     end
 
-    function varargout = return_vector2(self, varargin)
+    function varargout = return_vector2(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'double')
-        varargout{1} = geometry_wrapper(39, self, varargin{:});
+        varargout{1} = geometry_wrapper(39, this, varargin{:});
       else
         error('Arguments do not match any overload of function Test.return_vector2');
       end

wrap/tests/expected/geometry_wrapper.cpp

@@ -31,7 +31,7 @@ void _deleteAllObjects()
     collector_Test.erase(iter++);
   }
 }
-void Point2_constructor_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void Point2_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
   typedef boost::shared_ptr<Point2> Shared;
@@ -80,7 +80,7 @@ void Point2_argChar_4(int nargout, mxArray *out[], int nargin, const mxArray *in
 {
   typedef boost::shared_ptr<Point2> Shared;
   checkArguments("argChar",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Point2>(in[0], "Point2");
+  Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
   char a = unwrap< char >(in[1]);
   obj->argChar(a);
 }
@@ -89,7 +89,7 @@ void Point2_argUChar_5(int nargout, mxArray *out[], int nargin, const mxArray *i
 {
   typedef boost::shared_ptr<Point2> Shared;
   checkArguments("argUChar",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Point2>(in[0], "Point2");
+  Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
   unsigned char a = unwrap< unsigned char >(in[1]);
   obj->argUChar(a);
 }
@@ -98,18 +98,16 @@ void Point2_dim_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   typedef boost::shared_ptr<Point2> Shared;
   checkArguments("dim",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Point2>(in[0], "Point2");
+  Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
-  int result = obj->dim();
+  out[0] = wrap< int >(obj->dim());
-  out[0] = wrap< int >(result);
 }
 
 void Point2_returnChar_7(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   typedef boost::shared_ptr<Point2> Shared;
   checkArguments("returnChar",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Point2>(in[0], "Point2");
+  Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
-  char result = obj->returnChar();
+  out[0] = wrap< char >(obj->returnChar());
-  out[0] = wrap< char >(result);
 }
 
 void Point2_vectorConfusion_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -117,9 +115,8 @@ void Point2_vectorConfusion_8(int nargout, mxArray *out[], int nargin, const mxA
   typedef boost::shared_ptr<VectorNotEigen> SharedVectorNotEigen;
   typedef boost::shared_ptr<Point2> Shared;
   checkArguments("vectorConfusion",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Point2>(in[0], "Point2");
+  Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
-  VectorNotEigen result = obj->vectorConfusion();
+  SharedVectorNotEigen* ret = new SharedVectorNotEigen(new VectorNotEigen(obj->vectorConfusion()));
-  SharedVectorNotEigen* ret = new SharedVectorNotEigen(new VectorNotEigen(result));
   out[0] = wrap_shared_ptr(ret,"VectorNotEigen");
 }
 
@@ -127,21 +124,19 @@ void Point2_x_9(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   typedef boost::shared_ptr<Point2> Shared;
   checkArguments("x",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Point2>(in[0], "Point2");
+  Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
-  double result = obj->x();
+  out[0] = wrap< double >(obj->x());
-  out[0] = wrap< double >(result);
 }
 
 void Point2_y_10(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   typedef boost::shared_ptr<Point2> Shared;
   checkArguments("y",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Point2>(in[0], "Point2");
+  Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
-  double result = obj->y();
+  out[0] = wrap< double >(obj->y());
-  out[0] = wrap< double >(result);
 }
 
-void Point3_constructor_11(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void Point3_collectorInsertAndMakeBase_11(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
 using namespace geometry;
@@ -184,9 +179,8 @@ void Point3_norm_14(int nargout, mxArray *out[], int nargin, const mxArray *in[]
 using namespace geometry;
   typedef boost::shared_ptr<Point3> Shared;
   checkArguments("norm",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Point3>(in[0], "Point3");
+  Shared obj = unwrap_shared_ptr<Point3>(in[0], "ptr_Point3");
-  double result = obj->norm();
+  out[0] = wrap< double >(obj->norm());
-  out[0] = wrap< double >(result);
 }
 
 void Point3_StaticFunctionRet_15(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -196,8 +190,7 @@ using namespace geometry;
   typedef boost::shared_ptr<Point3> Shared;
   checkArguments("Point3.StaticFunctionRet",nargout,nargin,1);
   double z = unwrap< double >(in[0]);
-  Point3 result = Point3::StaticFunctionRet(z);
+    SharedPoint3* ret = new SharedPoint3(new Point3(Point3::StaticFunctionRet(z)));
-  SharedPoint3* ret = new SharedPoint3(new Point3(result));
   out[0] = wrap_shared_ptr(ret,"Point3");
 }
 
@@ -206,11 +199,10 @@ void Point3_staticFunction_16(int nargout, mxArray *out[], int nargin, const mxA
 using namespace geometry;
   typedef boost::shared_ptr<Point3> Shared;
   checkArguments("Point3.staticFunction",nargout,nargin,0);
-  double result = Point3::staticFunction();
+    out[0] = wrap< double >(Point3::staticFunction());
-  out[0] = wrap< double >(result);
 }
 
-void Test_constructor_17(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void Test_collectorInsertAndMakeBase_17(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
 using namespace geometry;
@@ -264,8 +256,8 @@ void Test_arg_EigenConstRef_21(int nargout, mxArray *out[], int nargin, const mx
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("arg_EigenConstRef",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  Matrix& value = *unwrap_shared_ptr< Matrix >(in[1], "Matrix");
+  Matrix& value = *unwrap_shared_ptr< Matrix >(in[1], "ptr_Matrix");
   obj->arg_EigenConstRef(value);
 }
 
@@ -276,11 +268,10 @@ using namespace geometry;
   typedef boost::shared_ptr<Test> SharedTest;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("create_MixedPtrs",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  pair< Test, SharedTest > result = obj->create_MixedPtrs();
+  SharedTest* ret = new SharedTest(new Test(obj->create_MixedPtrs().first));
-  SharedTest* ret = new SharedTest(new Test(result.first));
   out[0] = wrap_shared_ptr(ret,"Test");
-  SharedTest* ret = new SharedTest(result.second);
+  SharedTest* ret = new SharedTest(obj->create_MixedPtrs().second);
   out[1] = wrap_shared_ptr(ret,"Test");
 }
 
@@ -291,11 +282,10 @@ using namespace geometry;
   typedef boost::shared_ptr<Test> SharedTest;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("create_ptrs",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  pair< SharedTest, SharedTest > result = obj->create_ptrs();
+  SharedTest* ret = new SharedTest(obj->create_ptrs().first);
-  SharedTest* ret = new SharedTest(result.first);
   out[0] = wrap_shared_ptr(ret,"Test");
-  SharedTest* ret = new SharedTest(result.second);
+  SharedTest* ret = new SharedTest(obj->create_ptrs().second);
   out[1] = wrap_shared_ptr(ret,"Test");
 }
 
@@ -304,7 +294,7 @@ void Test_print_24(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("print",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   obj->print();
 }
 
@@ -314,10 +304,9 @@ using namespace geometry;
   typedef boost::shared_ptr<Point2> SharedPoint2;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_Point2Ptr",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   bool value = unwrap< bool >(in[1]);
-  SharedPoint2 result = obj->return_Point2Ptr(value);
+  SharedPoint2* ret = new SharedPoint2(obj->return_Point2Ptr(value));
-  SharedPoint2* ret = new SharedPoint2(result);
   out[0] = wrap_shared_ptr(ret,"Point2");
 }
 
@@ -327,10 +316,9 @@ using namespace geometry;
   typedef boost::shared_ptr<Test> SharedTest;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_Test",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "Test");
+  boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
-  Test result = obj->return_Test(value);
+  SharedTest* ret = new SharedTest(new Test(obj->return_Test(value)));
-  SharedTest* ret = new SharedTest(new Test(result));
   out[0] = wrap_shared_ptr(ret,"Test");
 }
 
@@ -340,10 +328,9 @@ using namespace geometry;
   typedef boost::shared_ptr<Test> SharedTest;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_TestPtr",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "Test");
+  boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
-  SharedTest result = obj->return_TestPtr(value);
+  SharedTest* ret = new SharedTest(obj->return_TestPtr(value));
-  SharedTest* ret = new SharedTest(result);
   out[0] = wrap_shared_ptr(ret,"Test");
 }
 
@@ -352,10 +339,9 @@ void Test_return_bool_28(int nargout, mxArray *out[], int nargin, const mxArray
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_bool",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   bool value = unwrap< bool >(in[1]);
-  bool result = obj->return_bool(value);
+  out[0] = wrap< bool >(obj->return_bool(value));
-  out[0] = wrap< bool >(result);
 }
 
 void Test_return_double_29(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -363,10 +349,9 @@ void Test_return_double_29(int nargout, mxArray *out[], int nargin, const mxArra
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_double",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   double value = unwrap< double >(in[1]);
-  double result = obj->return_double(value);
+  out[0] = wrap< double >(obj->return_double(value));
-  out[0] = wrap< double >(result);
 }
 
 void Test_return_field_30(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -374,10 +359,9 @@ void Test_return_field_30(int nargout, mxArray *out[], int nargin, const mxArray
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_field",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  Test& t = *unwrap_shared_ptr< Test >(in[1], "Test");
+  Test& t = *unwrap_shared_ptr< Test >(in[1], "ptr_Test");
-  bool result = obj->return_field(t);
+  out[0] = wrap< bool >(obj->return_field(t));
-  out[0] = wrap< bool >(result);
 }
 
 void Test_return_int_31(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -385,10 +369,9 @@ void Test_return_int_31(int nargout, mxArray *out[], int nargin, const mxArray *
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_int",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   int value = unwrap< int >(in[1]);
-  int result = obj->return_int(value);
+  out[0] = wrap< int >(obj->return_int(value));
-  out[0] = wrap< int >(result);
 }
 
 void Test_return_matrix1_32(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -396,10 +379,9 @@ void Test_return_matrix1_32(int nargout, mxArray *out[], int nargin, const mxArr
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_matrix1",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   Matrix value = unwrap< Matrix >(in[1]);
-  Matrix result = obj->return_matrix1(value);
+  out[0] = wrap< Matrix >(obj->return_matrix1(value));
-  out[0] = wrap< Matrix >(result);
 }
 
 void Test_return_matrix2_33(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -407,10 +389,9 @@ void Test_return_matrix2_33(int nargout, mxArray *out[], int nargin, const mxArr
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_matrix2",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   Matrix value = unwrap< Matrix >(in[1]);
-  Matrix result = obj->return_matrix2(value);
+  out[0] = wrap< Matrix >(obj->return_matrix2(value));
-  out[0] = wrap< Matrix >(result);
 }
 
 void Test_return_pair_34(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -418,12 +399,11 @@ void Test_return_pair_34(int nargout, mxArray *out[], int nargin, const mxArray
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_pair",nargout,nargin-1,2);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   Vector v = unwrap< Vector >(in[1]);
   Matrix A = unwrap< Matrix >(in[2]);
-  pair< Vector, Matrix > result = obj->return_pair(v,A);
+  out[0] = wrap< Vector >(obj->return_pair(v,A).first);
-  out[0] = wrap< Vector >(result.first);
+  out[1] = wrap< Matrix >(obj->return_pair(v,A).second);
-  out[1] = wrap< Matrix >(result.second);
 }
 
 void Test_return_ptrs_35(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -433,13 +413,12 @@ using namespace geometry;
   typedef boost::shared_ptr<Test> SharedTest;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_ptrs",nargout,nargin-1,2);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
-  boost::shared_ptr<Test> p1 = unwrap_shared_ptr< Test >(in[1], "Test");
+  boost::shared_ptr<Test> p1 = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
-  boost::shared_ptr<Test> p2 = unwrap_shared_ptr< Test >(in[2], "Test");
+  boost::shared_ptr<Test> p2 = unwrap_shared_ptr< Test >(in[2], "ptr_Test");
-  pair< SharedTest, SharedTest > result = obj->return_ptrs(p1,p2);
+  SharedTest* ret = new SharedTest(obj->return_ptrs(p1,p2).first);
-  SharedTest* ret = new SharedTest(result.first);
   out[0] = wrap_shared_ptr(ret,"Test");
-  SharedTest* ret = new SharedTest(result.second);
+  SharedTest* ret = new SharedTest(obj->return_ptrs(p1,p2).second);
   out[1] = wrap_shared_ptr(ret,"Test");
 }
 
@@ -448,10 +427,9 @@ void Test_return_size_t_36(int nargout, mxArray *out[], int nargin, const mxArra
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_size_t",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   size_t value = unwrap< size_t >(in[1]);
-  size_t result = obj->return_size_t(value);
+  out[0] = wrap< size_t >(obj->return_size_t(value));
-  out[0] = wrap< size_t >(result);
 }
 
 void Test_return_string_37(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -459,10 +437,9 @@ void Test_return_string_37(int nargout, mxArray *out[], int nargin, const mxArra
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_string",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   string value = unwrap< string >(in[1]);
-  string result = obj->return_string(value);
+  out[0] = wrap< string >(obj->return_string(value));
-  out[0] = wrap< string >(result);
 }
 
 void Test_return_vector1_38(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -470,10 +447,9 @@ void Test_return_vector1_38(int nargout, mxArray *out[], int nargin, const mxArr
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_vector1",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   Vector value = unwrap< Vector >(in[1]);
-  Vector result = obj->return_vector1(value);
+  out[0] = wrap< Vector >(obj->return_vector1(value));
-  out[0] = wrap< Vector >(result);
 }
 
 void Test_return_vector2_39(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -481,10 +457,9 @@ void Test_return_vector2_39(int nargout, mxArray *out[], int nargin, const mxArr
 using namespace geometry;
   typedef boost::shared_ptr<Test> Shared;
   checkArguments("return_vector2",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<Test>(in[0], "Test");
+  Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
   Vector value = unwrap< Vector >(in[1]);
-  Vector result = obj->return_vector2(value);
+  out[0] = wrap< Vector >(obj->return_vector2(value));
-  out[0] = wrap< Vector >(result);
 }
 
 void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -496,7 +471,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 
   switch(id) {
   case 0:
-    Point2_constructor_0(nargout, out, nargin-1, in+1);
+    Point2_collectorInsertAndMakeBase_0(nargout, out, nargin-1, in+1);
     break;
   case 1:
     Point2_constructor_1(nargout, out, nargin-1, in+1);
@@ -529,7 +504,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
     Point2_y_10(nargout, out, nargin-1, in+1);
     break;
   case 11:
-    Point3_constructor_11(nargout, out, nargin-1, in+1);
+    Point3_collectorInsertAndMakeBase_11(nargout, out, nargin-1, in+1);
     break;
   case 12:
     Point3_constructor_12(nargout, out, nargin-1, in+1);
@@ -547,7 +522,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
     Point3_staticFunction_16(nargout, out, nargin-1, in+1);
     break;
   case 17:
-    Test_constructor_17(nargout, out, nargin-1, in+1);
+    Test_collectorInsertAndMakeBase_17(nargout, out, nargin-1, in+1);
     break;
   case 18:
     Test_constructor_18(nargout, out, nargin-1, in+1);

wrap/tests/expected_namespaces/ClassD.m

@@ -1,22 +1,23 @@
 % automatically generated by wrap
 classdef ClassD < handle
   properties
-    self = 0
+    ptr_ClassD = 0
   end
   methods
     function obj = ClassD(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        testNamespaces_wrapper(obj.self);
+        testNamespaces_wrapper(19, my_ptr);
       elseif nargin == 0
-        obj.self = testNamespaces_wrapper(20);
+        my_ptr = testNamespaces_wrapper(20);
       else
         error('Arguments do not match any overload of ClassD constructor');
       end
+      obj.ptr_ClassD = my_ptr;
     end
 
     function delete(obj)
-      testNamespaces_wrapper(21, obj.self);
+      testNamespaces_wrapper(21, obj.ptr_ClassD);
     end
 
     function display(obj), obj.print(''); end

wrap/tests/expected_namespaces/ns1ClassA.m

@@ -1,22 +1,23 @@
 % automatically generated by wrap
 classdef ns1ClassA < handle
   properties
-    self = 0
+    ptr_ns1ClassA = 0
   end
   methods
     function obj = ns1ClassA(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        testNamespaces_wrapper(obj.self);
+        testNamespaces_wrapper(0, my_ptr);
       elseif nargin == 0
-        obj.self = testNamespaces_wrapper(1);
+        my_ptr = testNamespaces_wrapper(1);
       else
         error('Arguments do not match any overload of ns1ClassA constructor');
       end
+      obj.ptr_ns1ClassA = my_ptr;
     end
 
     function delete(obj)
-      testNamespaces_wrapper(2, obj.self);
+      testNamespaces_wrapper(2, obj.ptr_ns1ClassA);
     end
 
     function display(obj), obj.print(''); end

wrap/tests/expected_namespaces/ns1ClassB.m

@@ -1,22 +1,23 @@
 % automatically generated by wrap
 classdef ns1ClassB < handle
   properties
-    self = 0
+    ptr_ns1ClassB = 0
   end
   methods
     function obj = ns1ClassB(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        testNamespaces_wrapper(obj.self);
+        testNamespaces_wrapper(3, my_ptr);
       elseif nargin == 0
-        obj.self = testNamespaces_wrapper(4);
+        my_ptr = testNamespaces_wrapper(4);
       else
         error('Arguments do not match any overload of ns1ClassB constructor');
       end
+      obj.ptr_ns1ClassB = my_ptr;
     end
 
     function delete(obj)
-      testNamespaces_wrapper(5, obj.self);
+      testNamespaces_wrapper(5, obj.ptr_ns1ClassB);
     end
 
     function display(obj), obj.print(''); end

wrap/tests/expected_namespaces/ns2ClassA.m

@@ -1,47 +1,48 @@
 % automatically generated by wrap
 classdef ns2ClassA < handle
   properties
-    self = 0
+    ptr_ns2ClassA = 0
   end
   methods
     function obj = ns2ClassA(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        testNamespaces_wrapper(obj.self);
+        testNamespaces_wrapper(6, my_ptr);
       elseif nargin == 0
-        obj.self = testNamespaces_wrapper(7);
+        my_ptr = testNamespaces_wrapper(7);
       else
         error('Arguments do not match any overload of ns2ClassA constructor');
       end
+      obj.ptr_ns2ClassA = my_ptr;
     end
 
     function delete(obj)
-      testNamespaces_wrapper(8, obj.self);
+      testNamespaces_wrapper(8, obj.ptr_ns2ClassA);
     end
 
     function display(obj), obj.print(''); end
 
     function disp(obj), obj.display; end
 
-    function varargout = memberFunction(self, varargin)
+    function varargout = memberFunction(this, varargin)
       if length(varargin) == 0
-        varargout{1} = testNamespaces_wrapper(9, self, varargin{:});
+        varargout{1} = testNamespaces_wrapper(9, this, varargin{:});
       else
         error('Arguments do not match any overload of function ns2ClassA.memberFunction');
       end
     end
 
-    function varargout = nsArg(self, varargin)
+    function varargout = nsArg(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'ns1ClassB')
-        varargout{1} = testNamespaces_wrapper(10, self, varargin{:});
+        varargout{1} = testNamespaces_wrapper(10, this, varargin{:});
       else
         error('Arguments do not match any overload of function ns2ClassA.nsArg');
       end
     end
 
-    function varargout = nsReturn(self, varargin)
+    function varargout = nsReturn(this, varargin)
       if length(varargin) == 1 && isa(varargin{1},'double')
-        varargout{1} = testNamespaces_wrapper(11, self, varargin{:});
+        varargout{1} = testNamespaces_wrapper(11, this, varargin{:});
       else
         error('Arguments do not match any overload of function ns2ClassA.nsReturn');
       end

wrap/tests/expected_namespaces/ns2ClassC.m

@@ -1,22 +1,23 @@
 % automatically generated by wrap
 classdef ns2ClassC < handle
   properties
-    self = 0
+    ptr_ns2ClassC = 0
   end
   methods
     function obj = ns2ClassC(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        testNamespaces_wrapper(obj.self);
+        testNamespaces_wrapper(16, my_ptr);
       elseif nargin == 0
-        obj.self = testNamespaces_wrapper(17);
+        my_ptr = testNamespaces_wrapper(17);
       else
         error('Arguments do not match any overload of ns2ClassC constructor');
       end
+      obj.ptr_ns2ClassC = my_ptr;
     end
 
     function delete(obj)
-      testNamespaces_wrapper(18, obj.self);
+      testNamespaces_wrapper(18, obj.ptr_ns2ClassC);
     end
 
     function display(obj), obj.print(''); end

wrap/tests/expected_namespaces/ns2ns3ClassB.m

@@ -1,22 +1,23 @@
 % automatically generated by wrap
 classdef ns2ns3ClassB < handle
   properties
-    self = 0
+    ptr_ns2ns3ClassB = 0
   end
   methods
     function obj = ns2ns3ClassB(varargin)
       if nargin == 2 && isa(varargin{1}, 'uint64') && varargin{1} == uint64(5139824614673773682)
-        obj.self = varargin{2};
+        my_ptr = varargin{2};
-        testNamespaces_wrapper(obj.self);
+        testNamespaces_wrapper(13, my_ptr);
       elseif nargin == 0
-        obj.self = testNamespaces_wrapper(14);
+        my_ptr = testNamespaces_wrapper(14);
       else
         error('Arguments do not match any overload of ns2ns3ClassB constructor');
       end
+      obj.ptr_ns2ns3ClassB = my_ptr;
     end
 
     function delete(obj)
-      testNamespaces_wrapper(15, obj.self);
+      testNamespaces_wrapper(15, obj.ptr_ns2ns3ClassB);
     end
 
     function display(obj), obj.print(''); end

wrap/tests/expected_namespaces/testNamespaces_wrapper.cpp

@@ -58,7 +58,7 @@ void _deleteAllObjects()
     collector_ClassD.erase(iter++);
   }
 }
-void ns1ClassA_constructor_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void ns1ClassA_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
   typedef boost::shared_ptr<ns1::ClassA> Shared;
@@ -90,7 +90,7 @@ void ns1ClassA_deconstructor_2(int nargout, mxArray *out[], int nargin, const mx
   }
 }
 
-void ns1ClassB_constructor_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void ns1ClassB_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
   typedef boost::shared_ptr<ns1::ClassB> Shared;
@@ -122,7 +122,7 @@ void ns1ClassB_deconstructor_5(int nargout, mxArray *out[], int nargin, const mx
   }
 }
 
-void ns2ClassA_constructor_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void ns2ClassA_collectorInsertAndMakeBase_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
   typedef boost::shared_ptr<ns2::ClassA> Shared;
@@ -158,19 +158,17 @@ void ns2ClassA_memberFunction_9(int nargout, mxArray *out[], int nargin, const m
 {
   typedef boost::shared_ptr<ns2::ClassA> Shared;
   checkArguments("memberFunction",nargout,nargin-1,0);
-  Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ns2::ClassA");
+  Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
-  double result = obj->memberFunction();
+  out[0] = wrap< double >(obj->memberFunction());
-  out[0] = wrap< double >(result);
 }
 
 void ns2ClassA_nsArg_10(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   typedef boost::shared_ptr<ns2::ClassA> Shared;
   checkArguments("nsArg",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ns2::ClassA");
+  Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
-  ns1::ClassB& arg = *unwrap_shared_ptr< ns1::ClassB >(in[1], "ns1ClassB");
+  ns1::ClassB& arg = *unwrap_shared_ptr< ns1::ClassB >(in[1], "ptr_ns1ClassB");
-  int result = obj->nsArg(arg);
+  out[0] = wrap< int >(obj->nsArg(arg));
-  out[0] = wrap< int >(result);
 }
 
 void ns2ClassA_nsReturn_11(int nargout, mxArray *out[], int nargin, const mxArray *in[])
@@ -178,10 +176,9 @@ void ns2ClassA_nsReturn_11(int nargout, mxArray *out[], int nargin, const mxArra
   typedef boost::shared_ptr<ns2::ns3::ClassB> SharedClassB;
   typedef boost::shared_ptr<ns2::ClassA> Shared;
   checkArguments("nsReturn",nargout,nargin-1,1);
-  Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ns2::ClassA");
+  Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
   double q = unwrap< double >(in[1]);
-  ns2::ns3::ClassB result = obj->nsReturn(q);
+  SharedClassB* ret = new SharedClassB(new ns2::ns3::ClassB(obj->nsReturn(q)));
-  SharedClassB* ret = new SharedClassB(new ns2::ns3::ClassB(result));
   out[0] = wrap_shared_ptr(ret,"ns2ns3ClassB");
 }
 
@@ -189,11 +186,10 @@ void ns2ClassA_afunction_12(int nargout, mxArray *out[], int nargin, const mxArr
 {
   typedef boost::shared_ptr<ns2::ClassA> Shared;
   checkArguments("ns2ClassA.afunction",nargout,nargin,0);
-  double result = ns2::ClassA::afunction();
+    out[0] = wrap< double >(ns2::ClassA::afunction());
-  out[0] = wrap< double >(result);
 }
 
-void ns2ns3ClassB_constructor_13(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void ns2ns3ClassB_collectorInsertAndMakeBase_13(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
   typedef boost::shared_ptr<ns2::ns3::ClassB> Shared;
@@ -225,7 +221,7 @@ void ns2ns3ClassB_deconstructor_15(int nargout, mxArray *out[], int nargin, cons
   }
 }
 
-void ns2ClassC_constructor_16(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void ns2ClassC_collectorInsertAndMakeBase_16(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
   typedef boost::shared_ptr<ns2::ClassC> Shared;
@@ -257,7 +253,7 @@ void ns2ClassC_deconstructor_18(int nargout, mxArray *out[], int nargin, const m
   }
 }
 
-void ClassD_constructor_19(int nargout, mxArray *out[], int nargin, const mxArray *in[])
+void ClassD_collectorInsertAndMakeBase_19(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 {
   mexAtExit(&_deleteAllObjects);
   typedef boost::shared_ptr<ClassD> Shared;
@@ -298,7 +294,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
 
   switch(id) {
   case 0:
-    ns1ClassA_constructor_0(nargout, out, nargin-1, in+1);
+    ns1ClassA_collectorInsertAndMakeBase_0(nargout, out, nargin-1, in+1);
     break;
   case 1:
     ns1ClassA_constructor_1(nargout, out, nargin-1, in+1);
@@ -307,7 +303,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
     ns1ClassA_deconstructor_2(nargout, out, nargin-1, in+1);
     break;
   case 3:
-    ns1ClassB_constructor_3(nargout, out, nargin-1, in+1);
+    ns1ClassB_collectorInsertAndMakeBase_3(nargout, out, nargin-1, in+1);
     break;
   case 4:
     ns1ClassB_constructor_4(nargout, out, nargin-1, in+1);
@@ -316,7 +312,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
     ns1ClassB_deconstructor_5(nargout, out, nargin-1, in+1);
     break;
   case 6:
-    ns2ClassA_constructor_6(nargout, out, nargin-1, in+1);
+    ns2ClassA_collectorInsertAndMakeBase_6(nargout, out, nargin-1, in+1);
     break;
   case 7:
     ns2ClassA_constructor_7(nargout, out, nargin-1, in+1);
@@ -337,7 +333,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
     ns2ClassA_afunction_12(nargout, out, nargin-1, in+1);
     break;
   case 13:
-    ns2ns3ClassB_constructor_13(nargout, out, nargin-1, in+1);
+    ns2ns3ClassB_collectorInsertAndMakeBase_13(nargout, out, nargin-1, in+1);
     break;
   case 14:
     ns2ns3ClassB_constructor_14(nargout, out, nargin-1, in+1);
@@ -346,7 +342,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
     ns2ns3ClassB_deconstructor_15(nargout, out, nargin-1, in+1);
     break;
   case 16:
-    ns2ClassC_constructor_16(nargout, out, nargin-1, in+1);
+    ns2ClassC_collectorInsertAndMakeBase_16(nargout, out, nargin-1, in+1);
     break;
   case 17:
     ns2ClassC_constructor_17(nargout, out, nargin-1, in+1);
@@ -355,7 +351,7 @@ void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
     ns2ClassC_deconstructor_18(nargout, out, nargin-1, in+1);
     break;
   case 19:
-    ClassD_constructor_19(nargout, out, nargin-1, in+1);
+    ClassD_collectorInsertAndMakeBase_19(nargout, out, nargin-1, in+1);
     break;
   case 20:
     ClassD_constructor_20(nargout, out, nargin-1, in+1);

wrap/tests/testDependencies.h

@@ -1,24 +1,8 @@
 //Header file to test dependency checking
 //
 class Pose3 {
-	Pose3();
+	Pose3(const Rot3& r, const Point3& t); //What is Rot3? Throw here
-	Pose3(const Rot3& r, const Point3& t);//What is Rot3? Throw here
+	static Rot3 testStaticDep(Rot3& r);   //What is Rot3? Throw here
-	Pose3(Vector v);
+	Rot3 testReturnType() const;          // Throw here
-	Pose3(Matrix t);
+	void testMethodArg(const Rot3& r) const;
-	static Pose3 Expmap(Vector v);
-	static Vector Logmap(const Pose3& p);
-	static Rot3 testStaticDep(Rot3& r);//What is Rot3? Throw here
-	void print(string s) const;
-	bool equals(const Pose3& pose, double tol) const;
-	double x() const;
-	double y() const;
-	double z() const;
-	Rot3 testReturnType() const; // Throw here
-	Matrix matrix() const;
-	Matrix adjointMap() const;
-	Pose3 compose(const Pose3& p2);
-	Pose3 between(const Pose3& p2);
-	Pose3 retract(Vector v);
-	Point3 translation() const;
-	Rot3 rotation() const; //What is Rot3? Throw here
 };

wrap/tests/testWrap.cpp

@@ -58,7 +58,7 @@ TEST( wrap, ArgumentList ) {
 }
 
 /* ************************************************************************* */
-TEST( wrap, check_exception ) {
+TEST_UNSAFE( wrap, check_exception ) {
 	THROWS_EXCEPTION(Module("/notarealpath", "geometry",enable_verbose));
 	CHECK_EXCEPTION(Module("/alsonotarealpath", "geometry",enable_verbose), CantOpenFile);
 
@@ -80,8 +80,9 @@ TEST( wrap, parse ) {
 	strvec exp_using1, exp_using2; exp_using2 += "geometry";
 
 	// forward declarations
-	strvec exp_forward; exp_forward += "VectorNotEigen", "ns::OtherClass";
+	LONGS_EQUAL(2, module.forward_declarations.size());
-//	EXPECT(assert_equal(exp_forward, module.forward_declarations)); // FIXME: forward_declarations no longer a simple strvec
+	EXPECT(assert_equal("VectorNotEigen", module.forward_declarations[0].name));
+	EXPECT(assert_equal("ns::OtherClass", module.forward_declarations[1].name));
 
 	// check first class, Point2
 	{