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

Standard BORG formatting

release/4.3a0
dellaert 2014-05-25 12:43:19 -04:00
parent 02c3fe9516
commit 82d6bae4b9
2 changed files with 474 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

253
wrap/Class.cpp
View File

@ -22,7 +22,6 @@
//#include <cstdint> // on Linux GCC: fails with error regarding needing C++0x std flags //#include <cstdint> // on Linux GCC: fails with error regarding needing C++0x std flags
//#include <cinttypes> // same failure as above //#include <cinttypes> // same failure as above
#include <stdint.h> // works on Linux GCC #include <stdint.h> // works on Linux GCC
#include <boost/foreach.hpp> #include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
@ -35,8 +34,8 @@ using namespace wrap;
/* ************************************************************************* */ /* ************************************************************************* */
void Class::matlab_proxy(const string& toolboxPath, const string& wrapperName, void Class::matlab_proxy(const string& toolboxPath, const string& wrapperName,
const TypeAttributesTable& typeAttributes, const TypeAttributesTable& typeAttributes, FileWriter& wrapperFile,
FileWriter& wrapperFile, vector<string>& functionNames) const { vector<string>& functionNames) const {
// Create namespace folders // Create namespace folders
createNamespaceStructure(namespaces, toolboxPath); createNamespaceStructure(namespaces, toolboxPath);
@ -49,7 +48,8 @@ void Class::matlab_proxy(const string& toolboxPath, const string& wrapperName,
FileWriter proxyFile(classFile, verbose_, "%"); FileWriter proxyFile(classFile, verbose_, "%");
// get the name of actual matlab object // get the name of actual matlab object
const string matlabQualName = qualifiedName("."), matlabUniqueName = qualifiedName(), cppName = qualifiedName("::"); const string matlabQualName = qualifiedName("."), matlabUniqueName =
qualifiedName(), cppName = qualifiedName("::");
const string matlabBaseName = wrap::qualifiedName(".", qualifiedParent); const string matlabBaseName = wrap::qualifiedName(".", qualifiedParent);
const string cppBaseName = wrap::qualifiedName("::", qualifiedParent); const string cppBaseName = wrap::qualifiedName("::", qualifiedParent);
@ -72,23 +72,26 @@ void Class::matlab_proxy(const string& toolboxPath, const string& wrapperName,
// other wrap modules - to add these to their collectors the pointer is // other wrap modules - to add these to their collectors the pointer is
// passed from one C++ module into matlab then back into the other C++ // passed from one C++ module into matlab then back into the other C++
// module. // module.
pointer_constructor_fragments(proxyFile, wrapperFile, wrapperName, functionNames); pointer_constructor_fragments(proxyFile, wrapperFile, wrapperName,
functionNames);
wrapperFile.oss << "\n"; wrapperFile.oss << "\n";
// Regular constructors // Regular constructors
BOOST_FOREACH(ArgumentList a, constructor.args_list) BOOST_FOREACH(ArgumentList a, constructor.args_list) {
{
const int id = (int) functionNames.size(); const int id = (int) functionNames.size();
constructor.proxy_fragment(proxyFile, wrapperName, !qualifiedParent.empty(), id, a); constructor.proxy_fragment(proxyFile, wrapperName, !qualifiedParent.empty(),
id, a);
const string wrapFunctionName = constructor.wrapper_fragment(wrapperFile, const string wrapFunctionName = constructor.wrapper_fragment(wrapperFile,
cppName, matlabUniqueName, cppBaseName, id, a); cppName, matlabUniqueName, cppBaseName, id, a);
wrapperFile.oss << "\n"; wrapperFile.oss << "\n";
functionNames.push_back(wrapFunctionName); functionNames.push_back(wrapFunctionName);
} }
proxyFile.oss << " else\n"; proxyFile.oss << " else\n";
proxyFile.oss << " error('Arguments do not match any overload of " << matlabQualName << " constructor');\n"; proxyFile.oss << " error('Arguments do not match any overload of "
<< matlabQualName << " constructor');\n";
proxyFile.oss << " end\n"; proxyFile.oss << " end\n";
if (!qualifiedParent.empty()) if (!qualifiedParent.empty())
proxyFile.oss << " obj = obj@" << matlabBaseName << "(uint64(" << ptr_constructor_key << "), base_ptr);\n"; proxyFile.oss << " obj = obj@" << matlabBaseName << "(uint64("
<< ptr_constructor_key << "), base_ptr);\n";
proxyFile.oss << " obj.ptr_" << matlabUniqueName << " = my_ptr;\n"; proxyFile.oss << " obj.ptr_" << matlabUniqueName << " = my_ptr;\n";
proxyFile.oss << " end\n\n"; proxyFile.oss << " end\n\n";
@ -97,17 +100,21 @@ void Class::matlab_proxy(const string& toolboxPath, const string& wrapperName,
const int id = (int) functionNames.size(); const int id = (int) functionNames.size();
deconstructor.proxy_fragment(proxyFile, wrapperName, matlabUniqueName, id); deconstructor.proxy_fragment(proxyFile, wrapperName, matlabUniqueName, id);
proxyFile.oss << "\n"; proxyFile.oss << "\n";
const string functionName = deconstructor.wrapper_fragment(wrapperFile, cppName, matlabUniqueName, id); const string functionName = deconstructor.wrapper_fragment(wrapperFile,
cppName, matlabUniqueName, id);
wrapperFile.oss << "\n"; wrapperFile.oss << "\n";
functionNames.push_back(functionName); functionNames.push_back(functionName);
} }
proxyFile.oss << " function display(obj), obj.print(''); end\n %DISPLAY Calls print on the object\n"; proxyFile.oss
proxyFile.oss << " function disp(obj), obj.display; end\n %DISP Calls print on the object\n"; << " function display(obj), obj.print(''); end\n %DISPLAY Calls print on the object\n";
proxyFile.oss
<< " function disp(obj), obj.display; end\n %DISP Calls print on the object\n";
// Methods // Methods
BOOST_FOREACH(const Methods::value_type& name_m, methods) { BOOST_FOREACH(const Methods::value_type& name_m, methods) {
const Method& m = name_m.second; const Method& m = name_m.second;
m.proxy_wrapper_fragments(proxyFile, wrapperFile, cppName, matlabQualName, matlabUniqueName, wrapperName, typeAttributes, functionNames); m.proxy_wrapper_fragments(proxyFile, wrapperFile, cppName, matlabQualName,
matlabUniqueName, wrapperName, typeAttributes, functionNames);
proxyFile.oss << "\n"; proxyFile.oss << "\n";
wrapperFile.oss << "\n"; wrapperFile.oss << "\n";
} }
@ -121,12 +128,14 @@ void Class::matlab_proxy(const string& toolboxPath, const string& wrapperName,
// Static methods // Static methods
BOOST_FOREACH(const StaticMethods::value_type& name_m, static_methods) { BOOST_FOREACH(const StaticMethods::value_type& name_m, static_methods) {
const StaticMethod& m = name_m.second; const StaticMethod& m = name_m.second;
m.proxy_wrapper_fragments(proxyFile, wrapperFile, cppName, matlabQualName, matlabUniqueName, wrapperName, typeAttributes, functionNames); m.proxy_wrapper_fragments(proxyFile, wrapperFile, cppName, matlabQualName,
matlabUniqueName, wrapperName, typeAttributes, functionNames);
proxyFile.oss << "\n"; proxyFile.oss << "\n";
wrapperFile.oss << "\n"; wrapperFile.oss << "\n";
} }
if (hasSerialization) if (hasSerialization)
deserialization_fragments(proxyFile, wrapperFile, wrapperName, functionNames); deserialization_fragments(proxyFile, wrapperFile, wrapperName,
functionNames);
proxyFile.oss << " end\n"; proxyFile.oss << " end\n";
proxyFile.oss << "end\n"; proxyFile.oss << "end\n";
@ -141,36 +150,45 @@ string Class::qualifiedName(const string& delim) const {
} }
/* ************************************************************************* */ /* ************************************************************************* */
void Class::pointer_constructor_fragments(FileWriter& proxyFile, FileWriter& wrapperFile, const string& wrapperName, vector<string>& functionNames) const { void Class::pointer_constructor_fragments(FileWriter& proxyFile,
FileWriter& wrapperFile, const string& wrapperName,
vector<string>& functionNames) const {
const string matlabUniqueName = qualifiedName(), cppName = qualifiedName("::"); const string matlabUniqueName = qualifiedName(), cppName = qualifiedName(
"::");
const string baseCppName = wrap::qualifiedName("::", qualifiedParent); const string baseCppName = wrap::qualifiedName("::", qualifiedParent);
const int collectorInsertId = (int) functionNames.size(); const int collectorInsertId = (int) functionNames.size();
const string collectorInsertFunctionName = matlabUniqueName + "_collectorInsertAndMakeBase_" + boost::lexical_cast<string>(collectorInsertId); const string collectorInsertFunctionName = matlabUniqueName
+ "_collectorInsertAndMakeBase_"
+ boost::lexical_cast<string>(collectorInsertId);
functionNames.push_back(collectorInsertFunctionName); functionNames.push_back(collectorInsertFunctionName);
int upcastFromVoidId; int upcastFromVoidId;
string upcastFromVoidFunctionName; string upcastFromVoidFunctionName;
if (isVirtual) { if (isVirtual) {
upcastFromVoidId = (int) functionNames.size(); upcastFromVoidId = (int) functionNames.size();
upcastFromVoidFunctionName = matlabUniqueName + "_upcastFromVoid_" + boost::lexical_cast<string>(upcastFromVoidId); upcastFromVoidFunctionName = matlabUniqueName + "_upcastFromVoid_"
+ boost::lexical_cast<string>(upcastFromVoidId);
functionNames.push_back(upcastFromVoidFunctionName); functionNames.push_back(upcastFromVoidFunctionName);
} }
// MATLAB constructor that assigns pointer to matlab object then calls c++ // MATLAB constructor that assigns pointer to matlab object then calls c++
// function to add the object to the collector. // function to add the object to the collector.
if (isVirtual) { if (isVirtual) {
proxyFile.oss << " if (nargin == 2 || (nargin == 3 && strcmp(varargin{3}, 'void')))"; proxyFile.oss
<< " if (nargin == 2 || (nargin == 3 && strcmp(varargin{3}, 'void')))";
} else { } else {
proxyFile.oss << " if nargin == 2"; proxyFile.oss << " if nargin == 2";
} }
proxyFile.oss << " && isa(varargin{1}, 'uint64') && varargin{1} == uint64(" << ptr_constructor_key << ")\n"; proxyFile.oss << " && isa(varargin{1}, 'uint64') && varargin{1} == uint64("
<< ptr_constructor_key << ")\n";
if (isVirtual) { if (isVirtual) {
proxyFile.oss << " if nargin == 2\n"; proxyFile.oss << " if nargin == 2\n";
proxyFile.oss << " my_ptr = varargin{2};\n"; proxyFile.oss << " my_ptr = varargin{2};\n";
proxyFile.oss << " else\n"; proxyFile.oss << " else\n";
proxyFile.oss << " my_ptr = " << wrapperName << "(" << upcastFromVoidId << ", varargin{2});\n"; proxyFile.oss << " my_ptr = " << wrapperName << "("
<< upcastFromVoidId << ", varargin{2});\n";
proxyFile.oss << " end\n"; proxyFile.oss << " end\n";
} else { } else {
proxyFile.oss << " my_ptr = varargin{2};\n"; proxyFile.oss << " my_ptr = varargin{2};\n";
@ -185,22 +203,27 @@ void Class::pointer_constructor_fragments(FileWriter& proxyFile, FileWriter& wra
// comes from a C++ return value; this mechanism allows the object to be added // comes from a C++ return value; this mechanism allows the object to be added
// to a collector in a different wrap module. If this class has a base class, // to a collector in a different wrap module. If this class has a base class,
// a new pointer to the base class is allocated and returned. // a new pointer to the base class is allocated and returned.
wrapperFile.oss << "void " << collectorInsertFunctionName << "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n"; wrapperFile.oss << "void " << collectorInsertFunctionName
<< "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n";
wrapperFile.oss << "{\n"; wrapperFile.oss << "{\n";
wrapperFile.oss << " mexAtExit(&_deleteAllObjects);\n"; wrapperFile.oss << " mexAtExit(&_deleteAllObjects);\n";
// Typedef boost::shared_ptr // Typedef boost::shared_ptr
wrapperFile.oss << " typedef boost::shared_ptr<" << cppName << "> Shared;\n"; wrapperFile.oss << " typedef boost::shared_ptr<" << cppName << "> Shared;\n";
wrapperFile.oss << "\n"; wrapperFile.oss << "\n";
// Get self pointer passed in // Get self pointer passed in
wrapperFile.oss << " Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));\n"; wrapperFile.oss
<< " Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));\n";
// Add to collector // Add to collector
wrapperFile.oss << " collector_" << matlabUniqueName << ".insert(self);\n"; wrapperFile.oss << " collector_" << matlabUniqueName << ".insert(self);\n";
// If we have a base class, return the base class pointer (MATLAB will call the base class collectorInsertAndMakeBase to add this to the collector and recurse the heirarchy) // If we have a base class, return the base class pointer (MATLAB will call the base class collectorInsertAndMakeBase to add this to the collector and recurse the heirarchy)
if (!qualifiedParent.empty()) { if (!qualifiedParent.empty()) {
wrapperFile.oss << "\n"; wrapperFile.oss << "\n";
wrapperFile.oss << " typedef boost::shared_ptr<" << baseCppName << "> SharedBase;\n"; wrapperFile.oss << " typedef boost::shared_ptr<" << baseCppName
wrapperFile.oss << " out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);\n"; << "> SharedBase;\n";
wrapperFile.oss << " *reinterpret_cast<SharedBase**>(mxGetData(out[0])) = new SharedBase(*self);\n"; wrapperFile.oss
<< " out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);\n";
wrapperFile.oss
<< " *reinterpret_cast<SharedBase**>(mxGetData(out[0])) = new SharedBase(*self);\n";
} }
wrapperFile.oss << "}\n"; wrapperFile.oss << "}\n";
@ -209,20 +232,26 @@ void Class::pointer_constructor_fragments(FileWriter& proxyFile, FileWriter& wra
// real underlying derived-most class when a C++ method returns a virtual // real underlying derived-most class when a C++ method returns a virtual
// base class. // base class.
if (isVirtual) if (isVirtual)
wrapperFile.oss << wrapperFile.oss << "\n"
"\n" "void " << upcastFromVoidFunctionName
"void " << upcastFromVoidFunctionName << "(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {\n" << "(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {\n"
" mexAtExit(&_deleteAllObjects);\n" " mexAtExit(&_deleteAllObjects);\n"
" typedef boost::shared_ptr<" << cppName << "> Shared;\n" " typedef boost::shared_ptr<" << cppName
<< "> Shared;\n"
" boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));\n" " boost::shared_ptr<void> *asVoid = *reinterpret_cast<boost::shared_ptr<void>**> (mxGetData(in[0]));\n"
" out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);\n" " out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);\n"
" Shared *self = new Shared(boost::static_pointer_cast<" << cppName << ">(*asVoid));\n" " Shared *self = new Shared(boost::static_pointer_cast<" << cppName
<< ">(*asVoid));\n"
" *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;\n" " *reinterpret_cast<Shared**>(mxGetData(out[0])) = self;\n"
"}\n"; "}\n";
} }
/* ************************************************************************* */ /* ************************************************************************* */
vector<ArgumentList> expandArgumentListsTemplate(const vector<ArgumentList>& argLists, const string& templateArg, const vector<string>& instName, const std::vector<string>& expandedClassNamespace, const string& expandedClassName) { vector<ArgumentList> expandArgumentListsTemplate(
const vector<ArgumentList>& argLists, const string& templateArg,
const vector<string>& instName,
const std::vector<string>& expandedClassNamespace,
const string& expandedClassName) {
vector<ArgumentList> result; vector<ArgumentList> result;
BOOST_FOREACH(const ArgumentList& argList, argLists) { BOOST_FOREACH(const ArgumentList& argList, argLists) {
ArgumentList instArgList; ArgumentList instArgList;
@ -232,7 +261,8 @@ vector<ArgumentList> expandArgumentListsTemplate(const vector<ArgumentList>& arg
instArg.namespaces.assign(instName.begin(), instName.end() - 1); instArg.namespaces.assign(instName.begin(), instName.end() - 1);
instArg.type = instName.back(); instArg.type = instName.back();
} else if (arg.type == "This") { } else if (arg.type == "This") {
instArg.namespaces.assign(expandedClassNamespace.begin(), expandedClassNamespace.end()); instArg.namespaces.assign(expandedClassNamespace.begin(),
expandedClassNamespace.end());
instArg.type = expandedClassName; instArg.type = expandedClassName;
} }
instArgList.push_back(instArg); instArgList.push_back(instArg);
@ -244,13 +274,17 @@ vector<ArgumentList> expandArgumentListsTemplate(const vector<ArgumentList>& arg
/* ************************************************************************* */ /* ************************************************************************* */
template<class METHOD> template<class METHOD>
map<string, METHOD> expandMethodTemplate(const map<string, METHOD>& methods, const string& templateArg, const vector<string>& instName, const std::vector<string>& expandedClassNamespace, const string& expandedClassName) { map<string, METHOD> expandMethodTemplate(const map<string, METHOD>& methods,
const string& templateArg, const vector<string>& instName,
const std::vector<string>& expandedClassNamespace,
const string& expandedClassName) {
map<string, METHOD> result; map<string, METHOD> result;
typedef pair<const string, METHOD> Name_Method; typedef pair<const string, METHOD> Name_Method;
BOOST_FOREACH(const Name_Method& name_method, methods) { BOOST_FOREACH(const Name_Method& name_method, methods) {
const METHOD& method = name_method.second; const METHOD& method = name_method.second;
METHOD instMethod = method; METHOD instMethod = method;
instMethod.argLists = expandArgumentListsTemplate(method.argLists, templateArg, instName, expandedClassNamespace, expandedClassName); instMethod.argLists = expandArgumentListsTemplate(method.argLists,
templateArg, instName, expandedClassNamespace, expandedClassName);
instMethod.returnVals.clear(); instMethod.returnVals.clear();
BOOST_FOREACH(const ReturnValue& retVal, method.returnVals) { BOOST_FOREACH(const ReturnValue& retVal, method.returnVals) {
ReturnValue instRetVal = retVal; ReturnValue instRetVal = retVal;
@ -258,14 +292,16 @@ map<string, METHOD> expandMethodTemplate(const map<string, METHOD>& methods, con
instRetVal.namespaces1.assign(instName.begin(), instName.end() - 1); instRetVal.namespaces1.assign(instName.begin(), instName.end() - 1);
instRetVal.type1 = instName.back(); instRetVal.type1 = instName.back();
} else if (retVal.type1 == "This") { } else if (retVal.type1 == "This") {
instRetVal.namespaces1.assign(expandedClassNamespace.begin(), expandedClassNamespace.end()); instRetVal.namespaces1.assign(expandedClassNamespace.begin(),
expandedClassNamespace.end());
instRetVal.type1 = expandedClassName; instRetVal.type1 = expandedClassName;
} }
if (retVal.type2 == templateArg) { if (retVal.type2 == templateArg) {
instRetVal.namespaces2.assign(instName.begin(), instName.end() - 1); instRetVal.namespaces2.assign(instName.begin(), instName.end() - 1);
instRetVal.type2 = instName.back(); instRetVal.type2 = instName.back();
} else if (retVal.type1 == "This") { } else if (retVal.type1 == "This") {
instRetVal.namespaces2.assign(expandedClassNamespace.begin(), expandedClassNamespace.end()); instRetVal.namespaces2.assign(expandedClassNamespace.begin(),
expandedClassNamespace.end());
instRetVal.type2 = expandedClassName; instRetVal.type2 = expandedClassName;
} }
instMethod.returnVals.push_back(instRetVal); instMethod.returnVals.push_back(instRetVal);
@ -276,7 +312,10 @@ map<string, METHOD> expandMethodTemplate(const map<string, METHOD>& methods, con
} }
/* ************************************************************************* */ /* ************************************************************************* */
Class expandClassTemplate(const Class& cls, const string& templateArg, const vector<string>& instName, const std::vector<string>& expandedClassNamespace, const string& expandedClassName) { Class expandClassTemplate(const Class& cls, const string& templateArg,
const vector<string>& instName,
const std::vector<string>& expandedClassNamespace,
const string& expandedClassName) {
Class inst; Class inst;
inst.name = cls.name; inst.name = cls.name;
inst.templateArgs = cls.templateArgs; inst.templateArgs = cls.templateArgs;
@ -284,11 +323,15 @@ Class expandClassTemplate(const Class& cls, const string& templateArg, const vec
inst.isVirtual = cls.isVirtual; inst.isVirtual = cls.isVirtual;
inst.isSerializable = cls.isSerializable; inst.isSerializable = cls.isSerializable;
inst.qualifiedParent = cls.qualifiedParent; inst.qualifiedParent = cls.qualifiedParent;
inst.methods = expandMethodTemplate(cls.methods, templateArg, instName, expandedClassNamespace, expandedClassName); inst.methods = expandMethodTemplate(cls.methods, templateArg, instName,
inst.static_methods = expandMethodTemplate(cls.static_methods, templateArg, instName, expandedClassNamespace, expandedClassName); expandedClassNamespace, expandedClassName);
inst.static_methods = expandMethodTemplate(cls.static_methods, templateArg,
instName, expandedClassNamespace, expandedClassName);
inst.namespaces = cls.namespaces; inst.namespaces = cls.namespaces;
inst.constructor = cls.constructor; inst.constructor = cls.constructor;
inst.constructor.args_list = expandArgumentListsTemplate(cls.constructor.args_list, templateArg, instName, expandedClassNamespace, expandedClassName); inst.constructor.args_list = expandArgumentListsTemplate(
cls.constructor.args_list, templateArg, instName, expandedClassNamespace,
expandedClassName);
inst.constructor.name = inst.name; inst.constructor.name = inst.name;
inst.deconstructor = cls.deconstructor; inst.deconstructor = cls.deconstructor;
inst.deconstructor.name = inst.name; inst.deconstructor.name = inst.name;
@ -297,22 +340,29 @@ Class expandClassTemplate(const Class& cls, const string& templateArg, const vec
} }
/* ************************************************************************* */ /* ************************************************************************* */
vector<Class> Class::expandTemplate(const string& templateArg, const vector<vector<string> >& instantiations) const { vector<Class> Class::expandTemplate(const string& templateArg,
const vector<vector<string> >& instantiations) const {
vector<Class> result; vector<Class> result;
BOOST_FOREACH(const vector<string>& instName, instantiations) { BOOST_FOREACH(const vector<string>& instName, instantiations) {
const string expandedName = name + instName.back(); const string expandedName = name + instName.back();
Class inst = expandClassTemplate(*this, templateArg, instName, this->namespaces, expandedName); Class inst = expandClassTemplate(*this, templateArg, instName,
this->namespaces, expandedName);
inst.name = expandedName; inst.name = expandedName;
inst.templateArgs.clear(); inst.templateArgs.clear();
inst.typedefName = qualifiedName("::") + "<" + wrap::qualifiedName("::", instName) + ">"; inst.typedefName = qualifiedName("::") + "<"
+ wrap::qualifiedName("::", instName) + ">";
result.push_back(inst); result.push_back(inst);
} }
return result; return result;
} }
/* ************************************************************************* */ /* ************************************************************************* */
Class Class::expandTemplate(const string& templateArg, const vector<string>& instantiation, const std::vector<string>& expandedClassNamespace, const string& expandedClassName) const { Class Class::expandTemplate(const string& templateArg,
return expandClassTemplate(*this, templateArg, instantiation, expandedClassNamespace, expandedClassName); const vector<string>& instantiation,
const std::vector<string>& expandedClassNamespace,
const string& expandedClassName) const {
return expandClassTemplate(*this, templateArg, instantiation,
expandedClassNamespace, expandedClassName);
} }
/* ************************************************************************* */ /* ************************************************************************* */
@ -331,8 +381,7 @@ std::string Class::getTypedef() const {
/* ************************************************************************* */ /* ************************************************************************* */
void Class::comment_fragment(FileWriter& proxyFile) const { void Class::comment_fragment(FileWriter& proxyFile) const {
proxyFile.oss << "%class " << name proxyFile.oss << "%class " << name << ", see Doxygen page for details\n";
<< ", see Doxygen page for details\n";
proxyFile.oss proxyFile.oss
<< "%at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html\n"; << "%at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html\n";
@ -396,15 +445,17 @@ void Class::comment_fragment(FileWriter& proxyFile) const {
if (hasSerialization) { if (hasSerialization) {
proxyFile.oss << "%\n%-------Serialization Interface-------\n"; proxyFile.oss << "%\n%-------Serialization Interface-------\n";
proxyFile.oss << "%string_serialize() : returns string\n"; proxyFile.oss << "%string_serialize() : returns string\n";
proxyFile.oss << "%string_deserialize(string serialized) : returns " << this->name << "\n"; proxyFile.oss << "%string_deserialize(string serialized) : returns "
<< this->name << "\n";
} }
proxyFile.oss << "%\n"; proxyFile.oss << "%\n";
} }
/* ************************************************************************* */ /* ************************************************************************* */
void Class::serialization_fragments(FileWriter& proxyFile, FileWriter& wrapperFile, void Class::serialization_fragments(FileWriter& proxyFile,
const std::string& wrapperName, std::vector<std::string>& functionNames) const { FileWriter& wrapperFile, const std::string& wrapperName,
std::vector<std::string>& functionNames) const {
//void Point3_string_serialize_17(int nargout, mxArray *out[], int nargin, const mxArray *in[]) //void Point3_string_serialize_17(int nargout, mxArray *out[], int nargin, const mxArray *in[])
//{ //{
@ -418,30 +469,34 @@ void Class::serialization_fragments(FileWriter& proxyFile, FileWriter& wrapperFi
//} //}
int serialize_id = functionNames.size(); int serialize_id = functionNames.size();
const string const string matlabQualName = qualifiedName("."), matlabUniqueName =
matlabQualName = qualifiedName("."), qualifiedName(), cppClassName = qualifiedName("::");
matlabUniqueName = qualifiedName(), const string wrapFunctionNameSerialize = matlabUniqueName
cppClassName = qualifiedName("::"); + "_string_serialize_" + boost::lexical_cast<string>(serialize_id);
const string wrapFunctionNameSerialize = matlabUniqueName + "_string_serialize_" + boost::lexical_cast<string>(serialize_id);
functionNames.push_back(wrapFunctionNameSerialize); functionNames.push_back(wrapFunctionNameSerialize);
// call // call
//void Point3_string_serialize_17(int nargout, mxArray *out[], int nargin, const mxArray *in[]) //void Point3_string_serialize_17(int nargout, mxArray *out[], int nargin, const mxArray *in[])
wrapperFile.oss << "void " << wrapFunctionNameSerialize << "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n"; wrapperFile.oss << "void " << wrapFunctionNameSerialize
<< "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n";
wrapperFile.oss << "{\n"; wrapperFile.oss << "{\n";
wrapperFile.oss << " typedef boost::shared_ptr<" << cppClassName << "> Shared;" << endl; wrapperFile.oss << " typedef boost::shared_ptr<" << cppClassName
<< "> Shared;" << endl;
// check arguments - for serialize, no arguments // check arguments - for serialize, no arguments
// example: checkArguments("string_serialize",nargout,nargin-1,0); // example: checkArguments("string_serialize",nargout,nargin-1,0);
wrapperFile.oss << " checkArguments(\"string_serialize\",nargout,nargin-1,0);\n"; wrapperFile.oss
<< " checkArguments(\"string_serialize\",nargout,nargin-1,0);\n";
// get class pointer // get class pointer
// example: Shared obj = unwrap_shared_ptr<Point3>(in[0], "ptr_Point3"); // example: Shared obj = unwrap_shared_ptr<Point3>(in[0], "ptr_Point3");
wrapperFile.oss << " Shared obj = unwrap_shared_ptr<" << cppClassName << ">(in[0], \"ptr_" << matlabUniqueName << "\");" << endl; wrapperFile.oss << " Shared obj = unwrap_shared_ptr<" << cppClassName
<< ">(in[0], \"ptr_" << matlabUniqueName << "\");" << endl;
// Serialization boilerplate // Serialization boilerplate
wrapperFile.oss << " std::ostringstream out_archive_stream;\n"; wrapperFile.oss << " std::ostringstream out_archive_stream;\n";
wrapperFile.oss << " boost::archive::text_oarchive out_archive(out_archive_stream);\n"; wrapperFile.oss
<< " boost::archive::text_oarchive out_archive(out_archive_stream);\n";
wrapperFile.oss << " out_archive << *obj;\n"; wrapperFile.oss << " out_archive << *obj;\n";
wrapperFile.oss << " out[0] = wrap< string >(out_archive_stream.str());\n"; wrapperFile.oss << " out[0] = wrap< string >(out_archive_stream.str());\n";
@ -459,13 +514,19 @@ void Class::serialization_fragments(FileWriter& proxyFile, FileWriter& wrapperFi
// end // end
// end // end
proxyFile.oss << " function varargout = string_serialize(this, varargin)\n"; proxyFile.oss
proxyFile.oss << " % STRING_SERIALIZE usage: string_serialize() : returns string\n"; << " function varargout = string_serialize(this, varargin)\n";
proxyFile.oss << " % Doxygen can be found at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html\n"; proxyFile.oss
<< " % STRING_SERIALIZE usage: string_serialize() : returns string\n";
proxyFile.oss
<< " % Doxygen can be found at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html\n";
proxyFile.oss << " if length(varargin) == 0\n"; proxyFile.oss << " if length(varargin) == 0\n";
proxyFile.oss << " varargout{1} = " << wrapperName << "(" << boost::lexical_cast<string>(serialize_id) << ", this, varargin{:});\n"; proxyFile.oss << " varargout{1} = " << wrapperName << "("
<< boost::lexical_cast<string>(serialize_id) << ", this, varargin{:});\n";
proxyFile.oss << " else\n"; proxyFile.oss << " else\n";
proxyFile.oss << " error('Arguments do not match any overload of function " << matlabQualName << ".string_serialize');\n"; proxyFile.oss
<< " error('Arguments do not match any overload of function "
<< matlabQualName << ".string_serialize');\n";
proxyFile.oss << " end\n"; proxyFile.oss << " end\n";
proxyFile.oss << " end\n\n"; proxyFile.oss << " end\n\n";
@ -476,14 +537,16 @@ void Class::serialization_fragments(FileWriter& proxyFile, FileWriter& wrapperFi
// end // end
proxyFile.oss << " function sobj = saveobj(obj)\n"; proxyFile.oss << " function sobj = saveobj(obj)\n";
proxyFile.oss << " % SAVEOBJ Saves the object to a matlab-readable format\n"; proxyFile.oss
<< " % SAVEOBJ Saves the object to a matlab-readable format\n";
proxyFile.oss << " sobj = obj.string_serialize();\n"; proxyFile.oss << " sobj = obj.string_serialize();\n";
proxyFile.oss << " end\n"; proxyFile.oss << " end\n";
} }
/* ************************************************************************* */ /* ************************************************************************* */
void Class::deserialization_fragments(FileWriter& proxyFile, FileWriter& wrapperFile, void Class::deserialization_fragments(FileWriter& proxyFile,
const std::string& wrapperName, std::vector<std::string>& functionNames) const { FileWriter& wrapperFile, const std::string& wrapperName,
std::vector<std::string>& functionNames) const {
//void Point3_string_deserialize_18(int nargout, mxArray *out[], int nargin, const mxArray *in[]) //void Point3_string_deserialize_18(int nargout, mxArray *out[], int nargin, const mxArray *in[])
//{ //{
// typedef boost::shared_ptr<Point3> Shared; // typedef boost::shared_ptr<Point3> Shared;
@ -496,28 +559,32 @@ void Class::deserialization_fragments(FileWriter& proxyFile, FileWriter& wrapper
// out[0] = wrap_shared_ptr(output,"Point3", false); // out[0] = wrap_shared_ptr(output,"Point3", false);
//} //}
int deserialize_id = functionNames.size(); int deserialize_id = functionNames.size();
const string const string matlabQualName = qualifiedName("."), matlabUniqueName =
matlabQualName = qualifiedName("."), qualifiedName(), cppClassName = qualifiedName("::");
matlabUniqueName = qualifiedName(), const string wrapFunctionNameDeserialize = matlabUniqueName
cppClassName = qualifiedName("::"); + "_string_deserialize_" + boost::lexical_cast<string>(deserialize_id);
const string wrapFunctionNameDeserialize = matlabUniqueName + "_string_deserialize_" + boost::lexical_cast<string>(deserialize_id);
functionNames.push_back(wrapFunctionNameDeserialize); functionNames.push_back(wrapFunctionNameDeserialize);
// call // call
wrapperFile.oss << "void " << wrapFunctionNameDeserialize << "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n"; wrapperFile.oss << "void " << wrapFunctionNameDeserialize
<< "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n";
wrapperFile.oss << "{\n"; wrapperFile.oss << "{\n";
wrapperFile.oss << " typedef boost::shared_ptr<" << cppClassName << "> Shared;" << endl; wrapperFile.oss << " typedef boost::shared_ptr<" << cppClassName
<< "> Shared;" << endl;
// check arguments - for deserialize, 1 string argument // check arguments - for deserialize, 1 string argument
wrapperFile.oss << " checkArguments(\"" << matlabUniqueName << ".string_deserialize\",nargout,nargin,1);\n"; wrapperFile.oss << " checkArguments(\"" << matlabUniqueName
<< ".string_deserialize\",nargout,nargin,1);\n";
// string argument with deserialization boilerplate // string argument with deserialization boilerplate
wrapperFile.oss << " string serialized = unwrap< string >(in[0]);\n"; wrapperFile.oss << " string serialized = unwrap< string >(in[0]);\n";
wrapperFile.oss << " std::istringstream in_archive_stream(serialized);\n"; wrapperFile.oss << " std::istringstream in_archive_stream(serialized);\n";
wrapperFile.oss << " boost::archive::text_iarchive in_archive(in_archive_stream);\n"; wrapperFile.oss
<< " boost::archive::text_iarchive in_archive(in_archive_stream);\n";
wrapperFile.oss << " Shared output(new " << cppClassName << "());\n"; wrapperFile.oss << " Shared output(new " << cppClassName << "());\n";
wrapperFile.oss << " in_archive >> *output;\n"; wrapperFile.oss << " in_archive >> *output;\n";
wrapperFile.oss << " out[0] = wrap_shared_ptr(output,\"" << matlabQualName << "\", false);\n"; wrapperFile.oss << " out[0] = wrap_shared_ptr(output,\"" << matlabQualName
<< "\", false);\n";
wrapperFile.oss << "}\n"; wrapperFile.oss << "}\n";
// Generate matlab function // Generate matlab function
@ -532,16 +599,21 @@ void Class::deserialization_fragments(FileWriter& proxyFile, FileWriter& wrapper
// end // end
proxyFile.oss << " function varargout = string_deserialize(varargin)\n"; proxyFile.oss << " function varargout = string_deserialize(varargin)\n";
proxyFile.oss << " % STRING_DESERIALIZE usage: string_deserialize() : returns " << matlabQualName << "\n"; proxyFile.oss
proxyFile.oss << " % Doxygen can be found at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html\n"; << " % STRING_DESERIALIZE usage: string_deserialize() : returns "
<< matlabQualName << "\n";
proxyFile.oss
<< " % Doxygen can be found at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html\n";
proxyFile.oss << " if length(varargin) == 1\n"; proxyFile.oss << " if length(varargin) == 1\n";
proxyFile.oss << " varargout{1} = " << wrapperName << "(" << boost::lexical_cast<string>(deserialize_id) << ", varargin{:});\n"; proxyFile.oss << " varargout{1} = " << wrapperName << "("
<< boost::lexical_cast<string>(deserialize_id) << ", varargin{:});\n";
proxyFile.oss << " else\n"; proxyFile.oss << " else\n";
proxyFile.oss << " error('Arguments do not match any overload of function " << matlabQualName << ".string_deserialize');\n"; proxyFile.oss
<< " error('Arguments do not match any overload of function "
<< matlabQualName << ".string_deserialize');\n";
proxyFile.oss << " end\n"; proxyFile.oss << " end\n";
proxyFile.oss << " end\n\n"; proxyFile.oss << " end\n\n";
// Generate matlab load function // Generate matlab load function
// function obj = loadobj(sobj) // function obj = loadobj(sobj)
// % LOADOBJ Saves the object to a matlab-readable format // % LOADOBJ Saves the object to a matlab-readable format
@ -549,14 +621,17 @@ void Class::deserialization_fragments(FileWriter& proxyFile, FileWriter& wrapper
// end // end
proxyFile.oss << " function obj = loadobj(sobj)\n"; proxyFile.oss << " function obj = loadobj(sobj)\n";
proxyFile.oss << " % LOADOBJ Saves the object to a matlab-readable format\n"; proxyFile.oss
proxyFile.oss << " obj = " << matlabQualName << ".string_deserialize(sobj);\n"; << " % LOADOBJ Saves the object to a matlab-readable format\n";
proxyFile.oss << " obj = " << matlabQualName
<< ".string_deserialize(sobj);\n";
proxyFile.oss << " end" << endl; proxyFile.oss << " end" << endl;
} }
/* ************************************************************************* */ /* ************************************************************************* */
std::string Class::getSerializationExport() const { std::string Class::getSerializationExport() const {
//BOOST_CLASS_EXPORT_GUID(gtsam::SharedDiagonal, "gtsamSharedDiagonal"); //BOOST_CLASS_EXPORT_GUID(gtsam::SharedDiagonal, "gtsamSharedDiagonal");
return "BOOST_CLASS_EXPORT_GUID(" + qualifiedName("::") + ", \"" + qualifiedName() + "\");"; return "BOOST_CLASS_EXPORT_GUID(" + qualifiedName("::") + ", \""
+ qualifiedName() + "\");";
} }
/* ************************************************************************* */ /* ************************************************************************* */

80
wrap/StaticMethod.cpp
View File

@ -28,7 +28,6 @@
using namespace std; using namespace std;
using namespace wrap; using namespace wrap;
/* ************************************************************************* */ /* ************************************************************************* */
void StaticMethod::addOverload(bool verbose, const std::string& name, void StaticMethod::addOverload(bool verbose, const std::string& name,
const ArgumentList& args, const ReturnValue& retVal) { const ArgumentList& args, const ReturnValue& retVal) {
@ -39,27 +38,24 @@ void StaticMethod::addOverload(bool verbose, const std::string& name,
} }
/* ************************************************************************* */ /* ************************************************************************* */
void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wrapperFile, void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile,
const string& cppClassName, FileWriter& wrapperFile, const string& cppClassName,
const std::string& matlabQualName, const std::string& matlabQualName, const std::string& matlabUniqueName,
const std::string& matlabUniqueName, const string& wrapperName, const TypeAttributesTable& typeAttributes,
const string& wrapperName,
const TypeAttributesTable& typeAttributes,
vector<string>& functionNames) const { vector<string>& functionNames) const {
string upperName = name; upperName[0] = std::toupper(upperName[0], std::locale()); string upperName = name;
upperName[0] = std::toupper(upperName[0], std::locale());
proxyFile.oss << " function varargout = " << upperName << "(varargin)\n"; proxyFile.oss << " function varargout = " << upperName << "(varargin)\n";
//Comments for documentation //Comments for documentation
string up_name = boost::to_upper_copy(name); string up_name = boost::to_upper_copy(name);
proxyFile.oss << " % " << up_name << " usage:"; proxyFile.oss << " % " << up_name << " usage:";
unsigned int argLCount = 0; unsigned int argLCount = 0;
BOOST_FOREACH(ArgumentList argList, argLists) BOOST_FOREACH(ArgumentList argList, argLists) {
{
proxyFile.oss << " " << name << "("; proxyFile.oss << " " << name << "(";
unsigned int i = 0; unsigned int i = 0;
BOOST_FOREACH(const Argument& arg, argList) BOOST_FOREACH(const Argument& arg, argList) {
{
if (i != argList.size() - 1) if (i != argList.size() - 1)
proxyFile.oss << arg.type << " " << arg.name << ", "; proxyFile.oss << arg.type << " " << arg.name << ", ";
else else
@ -69,19 +65,20 @@ void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wr
if (argLCount != argLists.size() - 1) if (argLCount != argLists.size() - 1)
proxyFile.oss << "), "; proxyFile.oss << "), ";
else else
proxyFile.oss << ") : returns " << returnVals[0].return_type(false, returnVals[0].pair) << endl; proxyFile.oss << ") : returns "
<< returnVals[0].return_type(false, returnVals[0].pair) << endl;
argLCount++; argLCount++;
} }
proxyFile.oss << " % " << "Doxygen can be found at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html" << endl; proxyFile.oss << " % "
<< "Doxygen can be found at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html"
<< endl;
proxyFile.oss << " % " << "" << endl; proxyFile.oss << " % " << "" << endl;
proxyFile.oss << " % " << "Usage" << endl; proxyFile.oss << " % " << "Usage" << endl;
BOOST_FOREACH(ArgumentList argList, argLists) BOOST_FOREACH(ArgumentList argList, argLists) {
{
proxyFile.oss << " % " << up_name << "("; proxyFile.oss << " % " << up_name << "(";
unsigned int i = 0; unsigned int i = 0;
BOOST_FOREACH(const Argument& arg, argList) BOOST_FOREACH(const Argument& arg, argList) {
{
if (i != argList.size() - 1) if (i != argList.size() - 1)
proxyFile.oss << arg.type << " " << arg.name << ", "; proxyFile.oss << arg.type << " " << arg.name << ", ";
else else
@ -91,7 +88,6 @@ void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wr
proxyFile.oss << ")" << endl; proxyFile.oss << ")" << endl;
} }
for (size_t overload = 0; overload < argLists.size(); ++overload) { for (size_t overload = 0; overload < argLists.size(); ++overload) {
const ArgumentList& args = argLists[overload]; const ArgumentList& args = argLists[overload];
const ReturnValue& returnVal = returnVals[overload]; const ReturnValue& returnVal = returnVals[overload];
@ -102,13 +98,17 @@ void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wr
// Output proxy matlab code // Output proxy matlab code
// check for number of arguments... // check for number of arguments...
proxyFile.oss << " " << (overload==0?"":"else") << "if length(varargin) == " << nrArgs; proxyFile.oss << " " << (overload == 0 ? "" : "else")
if (nrArgs>0) proxyFile.oss << " && "; << "if length(varargin) == " << nrArgs;
if (nrArgs > 0)
proxyFile.oss << " && ";
// ...and their types // ...and their types
bool first = true; bool first = true;
for (size_t i = 0; i < nrArgs; i++) { for (size_t i = 0; i < nrArgs; i++) {
if (!first) proxyFile.oss << " && "; if (!first)
proxyFile.oss << "isa(varargin{" << i+1 << "},'" << args[i].matlabClass(".") << "')"; proxyFile.oss << " && ";
proxyFile.oss << "isa(varargin{" << i + 1 << "},'"
<< args[i].matlabClass(".") << "')";
first = false; first = false;
} }
proxyFile.oss << "\n"; proxyFile.oss << "\n";
@ -121,12 +121,13 @@ void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wr
output = ""; output = "";
else else
output = "varargout{1} = "; output = "varargout{1} = ";
proxyFile.oss << " " << output << wrapperName << "(" << id << ", varargin{:});\n"; proxyFile.oss << " " << output << wrapperName << "(" << id
<< ", varargin{:});\n";
// Output C++ wrapper code // Output C++ wrapper code
const string wrapFunctionName = wrapper_fragment( const string wrapFunctionName = wrapper_fragment(wrapperFile, cppClassName,
wrapperFile, cppClassName, matlabUniqueName, (int)overload, id, typeAttributes); matlabUniqueName, (int) overload, id, typeAttributes);
// Add to function list // Add to function list
functionNames.push_back(wrapFunctionName); functionNames.push_back(wrapFunctionName);
@ -134,8 +135,9 @@ void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wr
} }
proxyFile.oss << " else\n"; proxyFile.oss << " else\n";
proxyFile.oss << " error('Arguments do not match any overload of function " << proxyFile.oss
matlabQualName << "." << upperName << "');" << endl; << " error('Arguments do not match any overload of function "
<< matlabQualName << "." << upperName << "');" << endl;
proxyFile.oss << " end\n"; proxyFile.oss << " end\n";
proxyFile.oss << " end\n"; proxyFile.oss << " end\n";
@ -143,38 +145,40 @@ void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wr
/* ************************************************************************* */ /* ************************************************************************* */
string StaticMethod::wrapper_fragment(FileWriter& file, string StaticMethod::wrapper_fragment(FileWriter& file,
const string& cppClassName, const string& cppClassName, const string& matlabUniqueName, int overload,
const string& matlabUniqueName, int id, const TypeAttributesTable& typeAttributes) const {
int overload,
int id,
const TypeAttributesTable& typeAttributes) const {
// generate code // generate code
const string wrapFunctionName = matlabUniqueName + "_" + name + "_" + boost::lexical_cast<string>(id); const string wrapFunctionName = matlabUniqueName + "_" + name + "_"
+ boost::lexical_cast<string>(id);
const ArgumentList& args = argLists[overload]; const ArgumentList& args = argLists[overload];
const ReturnValue& returnVal = returnVals[overload]; const ReturnValue& returnVal = returnVals[overload];
// call // call
file.oss << "void " << wrapFunctionName << "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n"; file.oss << "void " << wrapFunctionName
<< "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n";
// start // start
file.oss << "{\n"; file.oss << "{\n";
returnVal.wrapTypeUnwrap(file); returnVal.wrapTypeUnwrap(file);
file.oss << " typedef boost::shared_ptr<" << cppClassName << "> Shared;" << endl; file.oss << " typedef boost::shared_ptr<" << cppClassName << "> Shared;"
<< endl;
// check arguments // check arguments
// NOTE: for static functions, there is no object passed // NOTE: for static functions, there is no object passed
file.oss << " checkArguments(\"" << matlabUniqueName << "." << name << "\",nargout,nargin," << args.size() << ");\n"; file.oss << " checkArguments(\"" << matlabUniqueName << "." << name
<< "\",nargout,nargin," << args.size() << ");\n";
// unwrap arguments, see Argument.cpp // unwrap arguments, see Argument.cpp
args.matlab_unwrap(file, 0); // We start at 0 because there is no self object args.matlab_unwrap(file, 0); // We start at 0 because there is no self object
// call method with default type and wrap result // call method with default type and wrap result
if (returnVal.type1 != "void") if (returnVal.type1 != "void")
returnVal.wrap_result(cppClassName+"::"+name+"("+args.names()+")", file, typeAttributes); returnVal.wrap_result(cppClassName + "::" + name + "(" + args.names() + ")",
file, typeAttributes);
else else
file.oss << cppClassName + "::" + name + "(" + args.names() + ");\n"; file.oss << cppClassName + "::" + name + "(" + args.names() + ");\n";