12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

release/4.3a0
Alex Cunningham 2012-07-10 14:21:58 +00:00
parent 6daa86f137
commit 5d58dbd512
16 changed files with 229 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
wrap/Class.h
View File

@ -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

2
wrap/Method.h
View File

@ -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_;

24
wrap/Module.cpp
View File

@ -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
BOOST_FOREACH(const Class& cls, classes) {
// create proxy class and wrapper code
BOOST_FOREACH(const Class& cls, classes) {
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

41
wrap/tests/expected/Point2.m
View File

@ -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};
geometry_wrapper(obj.self);
my_ptr = varargin{2};
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

15
wrap/tests/expected/Point3.m
View File

@ -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};
geometry_wrapper(obj.self);
my_ptr = varargin{2};
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

89
wrap/tests/expected/Test.m
View File

@ -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};
geometry_wrapper(obj.self);
my_ptr = varargin{2};
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

161
wrap/tests/expected/geometry_wrapper.cpp
View File

@ -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");
int result = obj->dim();
out[0] = wrap< int >(result);
Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
out[0] = wrap< int >(obj->dim());
}
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");
char result = obj->returnChar();
out[0] = wrap< char >(result);
Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
out[0] = wrap< char >(obj->returnChar());
}
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");
VectorNotEigen result = obj->vectorConfusion();
SharedVectorNotEigen* ret = new SharedVectorNotEigen(new VectorNotEigen(result));
Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
SharedVectorNotEigen* ret = new SharedVectorNotEigen(new VectorNotEigen(obj->vectorConfusion()));
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");
double result = obj->x();
out[0] = wrap< double >(result);
Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
out[0] = wrap< double >(obj->x());
}
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");
double result = obj->y();
out[0] = wrap< double >(result);
Shared obj = unwrap_shared_ptr<Point2>(in[0], "ptr_Point2");
out[0] = wrap< double >(obj->y());
}
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");
double result = obj->norm();
out[0] = wrap< double >(result);
Shared obj = unwrap_shared_ptr<Point3>(in[0], "ptr_Point3");
out[0] = wrap< double >(obj->norm());
}
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(result));
SharedPoint3* ret = new SharedPoint3(new Point3(Point3::StaticFunctionRet(z)));
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 >(result);
out[0] = wrap< double >(Point3::staticFunction());
}
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");
Matrix& value = *unwrap_shared_ptr< Matrix >(in[1], "Matrix");
Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
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");
pair< Test, SharedTest > result = obj->create_MixedPtrs();
SharedTest* ret = new SharedTest(new Test(result.first));
Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
SharedTest* ret = new SharedTest(new Test(obj->create_MixedPtrs().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");
pair< SharedTest, SharedTest > result = obj->create_ptrs();
SharedTest* ret = new SharedTest(result.first);
Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
SharedTest* ret = new SharedTest(obj->create_ptrs().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(result);
SharedPoint2* ret = new SharedPoint2(obj->return_Point2Ptr(value));
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");
boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "Test");
Test result = obj->return_Test(value);
SharedTest* ret = new SharedTest(new Test(result));
Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
SharedTest* ret = new SharedTest(new Test(obj->return_Test(value)));
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");
boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "Test");
SharedTest result = obj->return_TestPtr(value);
SharedTest* ret = new SharedTest(result);
Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
boost::shared_ptr<Test> value = unwrap_shared_ptr< Test >(in[1], "ptr_Test");
SharedTest* ret = new SharedTest(obj->return_TestPtr(value));
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 >(result);
out[0] = wrap< bool >(obj->return_bool(value));
}
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 >(result);
out[0] = wrap< double >(obj->return_double(value));
}
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");
Test& t = *unwrap_shared_ptr< Test >(in[1], "Test");
bool result = obj->return_field(t);
out[0] = wrap< bool >(result);
Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_Test");
Test& t = *unwrap_shared_ptr< Test >(in[1], "ptr_Test");
out[0] = wrap< bool >(obj->return_field(t));
}
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 >(result);
out[0] = wrap< int >(obj->return_int(value));
}
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 >(result);
out[0] = wrap< Matrix >(obj->return_matrix1(value));
}
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 >(result);
out[0] = wrap< Matrix >(obj->return_matrix2(value));
}
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 >(result.first);
out[1] = wrap< Matrix >(result.second);
out[0] = wrap< Vector >(obj->return_pair(v,A).first);
out[1] = wrap< Matrix >(obj->return_pair(v,A).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");
boost::shared_ptr<Test> p1 = unwrap_shared_ptr< Test >(in[1], "Test");
boost::shared_ptr<Test> p2 = unwrap_shared_ptr< Test >(in[2], "Test");
pair< SharedTest, SharedTest > result = obj->return_ptrs(p1,p2);
SharedTest* ret = new SharedTest(result.first);
Shared obj = unwrap_shared_ptr<Test>(in[0], "ptr_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], "ptr_Test");
SharedTest* ret = new SharedTest(obj->return_ptrs(p1,p2).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 >(result);
out[0] = wrap< size_t >(obj->return_size_t(value));
}
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 >(result);
out[0] = wrap< string >(obj->return_string(value));
}
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 >(result);
out[0] = wrap< Vector >(obj->return_vector1(value));
}
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 >(result);
out[0] = wrap< Vector >(obj->return_vector2(value));
}
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);

11
wrap/tests/expected_namespaces/ClassD.m
View File

@ -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};
testNamespaces_wrapper(obj.self);
my_ptr = varargin{2};
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

11
wrap/tests/expected_namespaces/ns1ClassA.m
View File

@ -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};
testNamespaces_wrapper(obj.self);
my_ptr = varargin{2};
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

11
wrap/tests/expected_namespaces/ns1ClassB.m
View File

@ -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};
testNamespaces_wrapper(obj.self);
my_ptr = varargin{2};
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

23
wrap/tests/expected_namespaces/ns2ClassA.m
View File

@ -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};
testNamespaces_wrapper(obj.self);
my_ptr = varargin{2};
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

11
wrap/tests/expected_namespaces/ns2ClassC.m
View File

@ -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};
testNamespaces_wrapper(obj.self);
my_ptr = varargin{2};
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

11
wrap/tests/expected_namespaces/ns2ns3ClassB.m
View File

@ -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};
testNamespaces_wrapper(obj.self);
my_ptr = varargin{2};
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

44
wrap/tests/expected_namespaces/testNamespaces_wrapper.cpp
View File

@ -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");
double result = obj->memberFunction();
out[0] = wrap< double >(result);
Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
out[0] = wrap< double >(obj->memberFunction());
}
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");
ns1::ClassB& arg = *unwrap_shared_ptr< ns1::ClassB >(in[1], "ns1ClassB");
int result = obj->nsArg(arg);
out[0] = wrap< int >(result);
Shared obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
ns1::ClassB& arg = *unwrap_shared_ptr< ns1::ClassB >(in[1], "ptr_ns1ClassB");
out[0] = wrap< int >(obj->nsArg(arg));
}
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(result));
SharedClassB* ret = new SharedClassB(new ns2::ns3::ClassB(obj->nsReturn(q)));
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 >(result);
out[0] = wrap< double >(ns2::ClassA::afunction());
}
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);

18
wrap/tests/testDependencies.h
View File

@ -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(Vector v);
Pose3(Matrix t);
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
void testMethodArg(const Rot3& r) const;
};

7
wrap/tests/testWrap.cpp
View File

@ -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";
// EXPECT(assert_equal(exp_forward, module.forward_declarations)); // FIXME: forward_declarations no longer a simple strvec
LONGS_EQUAL(2, module.forward_declarations.size());
EXPECT(assert_equal("VectorNotEigen", module.forward_declarations[0].name));
EXPECT(assert_equal("ns::OtherClass", module.forward_declarations[1].name));
// check first class, Point2
{