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

Cleaned up commented code, tweaked formatting

release/4.3a0
Alex Cunningham 2012-11-27 19:03:23 +00:00
parent 0030a28e45
commit d57838b4cb
1 changed files with 118 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
wrap/Module.cpp
View File

@ -144,7 +144,6 @@ void Module::parseMarkup(const std::string& data) {
Rule argEigenType_p = Rule argEigenType_p =
eigenType_p[assign_a(arg.type)]; eigenType_p[assign_a(arg.type)];
// >> !ch_p('*')[assign_a(arg.is_ptr,true)];
Rule eigenRef_p = Rule eigenRef_p =
!str_p("const") [assign_a(arg.is_const,true)] >> !str_p("const") [assign_a(arg.is_const,true)] >>
@ -155,7 +154,6 @@ void Module::parseMarkup(const std::string& data) {
!str_p("const") [assign_a(arg.is_const,true)] >> !str_p("const") [assign_a(arg.is_const,true)] >>
*namespace_arg_p >> *namespace_arg_p >>
className_p[assign_a(arg.type)] >> className_p[assign_a(arg.type)] >>
// !ch_p('*')[assign_a(arg.is_ptr,true)] >>
!ch_p('&')[assign_a(arg.is_ref,true)]; !ch_p('&')[assign_a(arg.is_ref,true)];
Rule name_p = lexeme_d[alpha_p >> *(alnum_p | '_')]; Rule name_p = lexeme_d[alpha_p >> *(alnum_p | '_')];
@ -200,11 +198,10 @@ void Module::parseMarkup(const std::string& data) {
'<' >> name_p[push_back_a(cls.templateArgs)] >> *(',' >> name_p[push_back_a(cls.templateArgs)]) >> '<' >> name_p[push_back_a(cls.templateArgs)] >> *(',' >> name_p[push_back_a(cls.templateArgs)]) >>
'>'); '>');
static const bool istrue = true; // NOTE: allows for pointers to all types
Rule argument_p = Rule argument_p =
((basisType_p[assign_a(arg.type)] | argEigenType_p | eigenRef_p | classArg_p) ((basisType_p[assign_a(arg.type)] | argEigenType_p | eigenRef_p | classArg_p)
>> !ch_p('*')[assign_a(arg.is_ptr,istrue)] >> !ch_p('*')[assign_a(arg.is_ptr,true)]
>> name_p[assign_a(arg.name)]) >> name_p[assign_a(arg.name)])
[push_back_a(args, arg)] [push_back_a(args, arg)]
[assign_a(arg,arg0)]; [assign_a(arg,arg0)];
@ -222,13 +219,12 @@ void Module::parseMarkup(const std::string& data) {
Rule namespace_ret_p = namespace_name_p[push_back_a(namespaces_return)] >> str_p("::"); Rule namespace_ret_p = namespace_name_p[push_back_a(namespaces_return)] >> str_p("::");
// HACK: use const values instead of using enums themselves // HACK: use const values instead of using enums themselves - somehow this doesn't result in values getting assigned to gibberish
static const ReturnValue::return_category RETURN_EIGEN = ReturnValue::EIGEN; static const ReturnValue::return_category RETURN_EIGEN = ReturnValue::EIGEN;
static const ReturnValue::return_category RETURN_BASIS = ReturnValue::BASIS; static const ReturnValue::return_category RETURN_BASIS = ReturnValue::BASIS;
static const ReturnValue::return_category RETURN_CLASS = ReturnValue::CLASS; static const ReturnValue::return_category RETURN_CLASS = ReturnValue::CLASS;
static const ReturnValue::return_category RETURN_VOID = ReturnValue::VOID; static const ReturnValue::return_category RETURN_VOID = ReturnValue::VOID;
// switching to using constants
Rule returnType1_p = Rule returnType1_p =
(basisType_p[assign_a(retVal.type1)][assign_a(retVal.category1, RETURN_BASIS)]) | (basisType_p[assign_a(retVal.type1)][assign_a(retVal.category1, RETURN_BASIS)]) |
((*namespace_ret_p)[assign_a(retVal.namespaces1, namespaces_return)][clear_a(namespaces_return)] ((*namespace_ret_p)[assign_a(retVal.namespaces1, namespaces_return)][clear_a(namespaces_return)]
@ -236,14 +232,6 @@ void Module::parseMarkup(const std::string& data) {
!ch_p('*')[assign_a(retVal.isPtr1,true)]) | !ch_p('*')[assign_a(retVal.isPtr1,true)]) |
(eigenType_p[assign_a(retVal.type1)][assign_a(retVal.category1, RETURN_EIGEN)]); (eigenType_p[assign_a(retVal.type1)][assign_a(retVal.category1, RETURN_EIGEN)]);
// Original
// Rule returnType1_p =
// (basisType_p[assign_a(retVal.type1)][assign_a(retVal.category1, ReturnValue::BASIS)]) |
// ((*namespace_ret_p)[assign_a(retVal.namespaces1, namespaces_return)][clear_a(namespaces_return)]
// >> (className_p[assign_a(retVal.type1)][assign_a(retVal.category1, ReturnValue::CLASS)]) >>
// !ch_p('*')[assign_a(retVal.isPtr1,true)]) |
// (eigenType_p[assign_a(retVal.type1)][assign_a(retVal.category1, ReturnValue::EIGEN)]);
Rule returnType2_p = Rule returnType2_p =
(basisType_p[assign_a(retVal.type2)][assign_a(retVal.category2, RETURN_BASIS)]) | (basisType_p[assign_a(retVal.type2)][assign_a(retVal.category2, RETURN_BASIS)]) |
((*namespace_ret_p)[assign_a(retVal.namespaces2, namespaces_return)][clear_a(namespaces_return)] ((*namespace_ret_p)[assign_a(retVal.namespaces2, namespaces_return)][clear_a(namespaces_return)]
@ -251,14 +239,6 @@ void Module::parseMarkup(const std::string& data) {
!ch_p('*') [assign_a(retVal.isPtr2,true)]) | !ch_p('*') [assign_a(retVal.isPtr2,true)]) |
(eigenType_p[assign_a(retVal.type2)][assign_a(retVal.category2, RETURN_EIGEN)]); (eigenType_p[assign_a(retVal.type2)][assign_a(retVal.category2, RETURN_EIGEN)]);
// Original
// Rule returnType2_p =
// (basisType_p[assign_a(retVal.type2)][assign_a(retVal.category2, ReturnValue::BASIS)]) |
// ((*namespace_ret_p)[assign_a(retVal.namespaces2, namespaces_return)][clear_a(namespaces_return)]
// >> (className_p[assign_a(retVal.type2)][assign_a(retVal.category2, ReturnValue::CLASS)]) >>
// !ch_p('*') [assign_a(retVal.isPtr2,true)]) |
// (eigenType_p[assign_a(retVal.type2)][assign_a(retVal.category2, ReturnValue::EIGEN)]);
Rule pair_p = Rule pair_p =
(str_p("pair") >> '<' >> returnType1_p >> ',' >> returnType2_p >> '>') (str_p("pair") >> '<' >> returnType1_p >> ',' >> returnType2_p >> '>')
[assign_a(retVal.isPair,true)]; [assign_a(retVal.isPair,true)];
@ -359,29 +339,29 @@ void Module::parseMarkup(const std::string& data) {
Rule module_p = *module_content_p >> !end_p; Rule module_p = *module_content_p >> !end_p;
// //---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// // for debugging, define BOOST_SPIRIT_DEBUG // for debugging, define BOOST_SPIRIT_DEBUG
//# ifdef BOOST_SPIRIT_DEBUG # ifdef BOOST_SPIRIT_DEBUG
// BOOST_SPIRIT_DEBUG_NODE(className_p); BOOST_SPIRIT_DEBUG_NODE(className_p);
// BOOST_SPIRIT_DEBUG_NODE(classPtr_p); BOOST_SPIRIT_DEBUG_NODE(classPtr_p);
// BOOST_SPIRIT_DEBUG_NODE(classRef_p); BOOST_SPIRIT_DEBUG_NODE(classRef_p);
// BOOST_SPIRIT_DEBUG_NODE(basisType_p); BOOST_SPIRIT_DEBUG_NODE(basisType_p);
// BOOST_SPIRIT_DEBUG_NODE(name_p); BOOST_SPIRIT_DEBUG_NODE(name_p);
// BOOST_SPIRIT_DEBUG_NODE(argument_p); BOOST_SPIRIT_DEBUG_NODE(argument_p);
// BOOST_SPIRIT_DEBUG_NODE(argumentList_p); BOOST_SPIRIT_DEBUG_NODE(argumentList_p);
// BOOST_SPIRIT_DEBUG_NODE(constructor_p); BOOST_SPIRIT_DEBUG_NODE(constructor_p);
// BOOST_SPIRIT_DEBUG_NODE(returnType1_p); BOOST_SPIRIT_DEBUG_NODE(returnType1_p);
// BOOST_SPIRIT_DEBUG_NODE(returnType2_p); BOOST_SPIRIT_DEBUG_NODE(returnType2_p);
// BOOST_SPIRIT_DEBUG_NODE(pair_p); BOOST_SPIRIT_DEBUG_NODE(pair_p);
// BOOST_SPIRIT_DEBUG_NODE(void_p); BOOST_SPIRIT_DEBUG_NODE(void_p);
// BOOST_SPIRIT_DEBUG_NODE(returnType_p); BOOST_SPIRIT_DEBUG_NODE(returnType_p);
// BOOST_SPIRIT_DEBUG_NODE(methodName_p); BOOST_SPIRIT_DEBUG_NODE(methodName_p);
// BOOST_SPIRIT_DEBUG_NODE(method_p); BOOST_SPIRIT_DEBUG_NODE(method_p);
// BOOST_SPIRIT_DEBUG_NODE(class_p); BOOST_SPIRIT_DEBUG_NODE(class_p);
// BOOST_SPIRIT_DEBUG_NODE(namespace_def_p); BOOST_SPIRIT_DEBUG_NODE(namespace_def_p);
// BOOST_SPIRIT_DEBUG_NODE(module_p); BOOST_SPIRIT_DEBUG_NODE(module_p);
//# endif # endif
// //---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// and parse contents // and parse contents
parse_info<const char*> info = parse(data.c_str(), module_p, space_p); parse_info<const char*> info = parse(data.c_str(), module_p, space_p);
@ -535,8 +515,7 @@ map<string, Method> Module::appendInheretedMethods(const Class& cls, const vecto
if(!cls.qualifiedParent.empty()) if(!cls.qualifiedParent.empty())
{ {
//Find Class //Find Class
BOOST_FOREACH(const Class& parent, classes) BOOST_FOREACH(const Class& parent, classes) {
{
//We found the class for our parent //We found the class for our parent
if(parent.name == cls.qualifiedParent.back()) if(parent.name == cls.qualifiedParent.back())
{ {
@ -544,9 +523,7 @@ map<string, Method> Module::appendInheretedMethods(const Class& cls, const vecto
methods.insert(inhereted.begin(), inhereted.end()); methods.insert(inhereted.begin(), inhereted.end());
} }
} }
} } else {
else
{
methods.insert(cls.methods.begin(), cls.methods.end()); methods.insert(cls.methods.begin(), cls.methods.end());
} }