Good progress on Argument

wrap/tests/testArgument.cpp

@@ -23,13 +23,14 @@
 using namespace std;
 using namespace wrap;
 
+static const bool T = true;
+
 /* ************************************************************************* */
 // http://boost-spirit.com/distrib/spirit_1_8_2/libs/spirit/doc/grammar.html
 struct ArgumentGrammar: public classic::grammar<ArgumentGrammar> {
 
   wrap::Argument& result_; ///< successful parse will be placed in here
   type_grammar argument_type_g;
-  Argument arg0;
 
   /// Construct type grammar and specify where result is placed
   ArgumentGrammar(wrap::Argument& result) :
@@ -51,19 +52,11 @@ struct ArgumentGrammar: public classic::grammar<ArgumentGrammar> {
 
       // NOTE: allows for pointers to all types
       // Slightly more permissive than before on basis/eigen type qualification
-      argument_p = //
-          !str_p("const")
-//          [assign_a(self.arg.is_const, true)] //
-              >> self.argument_type_g //
-              >> (!ch_p('&')
-//                  [assign_a(self.arg.is_ref, true)]
-                  | !ch_p('*')
-//                  [assign_a(self.arg.is_ptr, true)]
-              ) >> basic_rules<ScannerT>::name_p
-              // [assign_a[self.arg.name)]
-//              [push_back_a(self.result_, self.arg)]
-              // [assign_a(self.arg, self.arg0)]
-              ;
+      argument_p = !str_p("const")[assign_a(self.result_.is_const, T)] //
+          >> self.argument_type_g //
+          >> (!ch_p('&')[assign_a(self.result_.is_ref, T)]
+              | !ch_p('*')[assign_a(self.result_.is_ptr, T)])
+          >> basic_rules<ScannerT>::name_p[assign_a(self.result_.name)];
     }
 
     Rule const& start() const {
@@ -80,23 +73,73 @@ TEST( Argument, grammar ) {
   using classic::space_p;
 
   // Create type grammar that will place result in actual
-  Argument actual;
+  Argument actual, arg0;
   ArgumentGrammar g(actual);
 
   EXPECT(parse("const gtsam::Point2& p4", g, space_p).full);
+  EXPECT_LONGS_EQUAL(1, actual.type.namespaces.size());
+  EXPECT(actual.type.namespaces[0]=="gtsam");
+  EXPECT(actual.type.name=="Point2");
+  EXPECT(actual.name=="p4");
+  EXPECT(actual.is_const);
+  EXPECT(actual.is_ref);
+  EXPECT(!actual.is_ptr);
+  actual = arg0;
 
   EXPECT(parse("Point2 p", g, space_p).full);
+  EXPECT(actual.type.namespaces.empty());
+  EXPECT(actual.type.name=="Point2");
+  EXPECT(actual.name=="p");
+  EXPECT(!actual.is_const);
+  EXPECT(!actual.is_ref);
+  EXPECT(!actual.is_ptr);
+  actual = arg0;
 
   EXPECT(parse("gtsam::Point2 p3", g, space_p).full);
+  EXPECT_LONGS_EQUAL(1, actual.type.namespaces.size());
+  EXPECT(actual.type.namespaces[0]=="gtsam");
+  EXPECT(actual.type.name=="Point2");
+  EXPECT(actual.name=="p3");
+  EXPECT(!actual.is_const);
+  EXPECT(!actual.is_ref);
+  EXPECT(!actual.is_ptr);
+  actual = arg0;
 
   EXPECT(parse("char a", g, space_p).full);
+  EXPECT(actual.type.namespaces.empty());
+  EXPECT(actual.type.name=="char");
+  EXPECT(actual.name=="a");
+  EXPECT(!actual.is_const);
+  EXPECT(!actual.is_ref);
+  EXPECT(!actual.is_ptr);
+  actual = arg0;
 
   EXPECT(parse("unsigned char a", g, space_p).full);
+  EXPECT(actual.type.namespaces.empty());
+  EXPECT(actual.type.name=="unsigned char");
+  EXPECT(actual.name=="a");
+  EXPECT(!actual.is_const);
+  EXPECT(!actual.is_ref);
+  EXPECT(!actual.is_ptr);
+  actual = arg0;
 
   EXPECT(parse("Vector v", g, space_p).full);
+  EXPECT(actual.type.namespaces.empty());
+  EXPECT(actual.type.name=="Vector");
+  EXPECT(actual.name=="v");
+  EXPECT(!actual.is_const);
+  EXPECT(!actual.is_ref);
+  EXPECT(!actual.is_ptr);
+  actual = arg0;
 
-  EXPECT(parse("Matrix m", g, space_p).full);
-
+  EXPECT(parse("const Matrix& m", g, space_p).full);
+  EXPECT(actual.type.namespaces.empty());
+  EXPECT(actual.type.name=="Matrix");
+  EXPECT(actual.name=="m");
+  EXPECT(actual.is_const);
+  EXPECT(actual.is_ref);
+  EXPECT(!actual.is_ptr);
+  actual = arg0;
 }
 
 /* ************************************************************************* */