Improve function container

Benjamin Renard
1 parent 36749bea
Showing 3 changed files with 44 additions and 85 deletions Show diff stats
src/expressionParser/ExpressionContainer.hh
src/expressionParser/ExpressionPrinter.hh
src/expressionParser/ParserGrammar.hh
@@ -6,9 +6,6 @@ namespace parser {
  
 struct op_power{};
 struct op_powerTen{};
-struct fun_three{};
-struct fun_two{};
-struct fun_one{};
  
 struct Operator {
 	explicit Operator(std::string ihmSymbol, std::string kernelSymbol) : ihmSymbol(ihmSymbol), kernelSymbol(kernelSymbol) {};
@@ -20,24 +17,45 @@ struct Operator {
 namespace Expression{
  
 typedef std::string var;
+
 template <typename tag> struct binop;
-template <typename tag> struct comop;
 template <typename tag> struct funcop;
-template <typename tag> struct triop;
-template <typename tag> struct forop;
 struct BinaryOperation;
 struct UnaryOperation;
+struct FunctionOperation;
  
-typedef boost::variant<var,
+typedef boost::variant<
+	var,
 	boost::recursive_wrapper<UnaryOperation>,
 	boost::recursive_wrapper<BinaryOperation>,
+
+	boost::recursive_wrapper<FunctionOperation>,
+
 	boost::recursive_wrapper<funcop<op_power> >,
-	boost::recursive_wrapper<binop<op_powerTen> >,
-        boost::recursive_wrapper<binop<fun_one> >,
-        boost::recursive_wrapper<triop<fun_two> >,
-        boost::recursive_wrapper<forop<fun_three> >
+	boost::recursive_wrapper<binop<op_powerTen> >
 > ExpressionContainer;
  
+struct FunctionOperation
+{
+	explicit FunctionOperation(std::string func, const ExpressionContainer& arg1) : func(func) {
+		args.push_back(arg1);
+	}
+
+	explicit FunctionOperation(std::string func, const ExpressionContainer& arg1, const ExpressionContainer& arg2) : func(func) {
+		args.push_back(arg1);
+		args.push_back(arg2);
+	}
+
+	explicit FunctionOperation(std::string func, const ExpressionContainer& arg1, const ExpressionContainer& arg2, const ExpressionContainer& arg3) : func(func) {
+		args.push_back(arg1);
+		args.push_back(arg2);
+		args.push_back(arg3);
+	}
+
+	std::string func;
+	std::vector<ExpressionContainer> args;
+};
+
 struct UnaryOperation
 {
 	explicit UnaryOperation(Operator op, const ExpressionContainer& e) : op(op), e(e) {}
@@ -144,38 +162,12 @@ template &lt;typename tag&gt; struct binop
 	ExpressionContainer oper1, oper2;
 };
  
-template <typename tag> struct comop
-{
-    explicit comop(const ExpressionContainer& l, const ExpressionContainer& r) : oper1(l), oper2(r) { }
-    ExpressionContainer oper1, oper2;
-};
-
 template <typename tag> struct funcop
 {
 	explicit funcop(const ExpressionContainer& l, const ExpressionContainer& r) : oper1(l), oper2(r) { }
 	ExpressionContainer oper1, oper2;
 };
  
-template <typename tag> struct triop
-{
-    explicit triop(const ExpressionContainer& functionId,
-            const ExpressionContainer& l
-        , const ExpressionContainer& r)
-        : oper1(functionId), oper2(l), oper3(r) { }
-ExpressionContainer oper1, oper2, oper3;
-};
-
-template <typename tag> struct forop
-{
-    explicit forop(const ExpressionContainer& functionId,
-            const ExpressionContainer& l,
-            const ExpressionContainer& m,
-          const ExpressionContainer& r)
-        : oper1(functionId), oper2(l), oper3(m),oper4(r) { }
-ExpressionContainer oper1, oper2, oper3,oper4;
-};
-
-
 } /* namespace Expression */
  
 } /* namespace parser */
@@ -19,17 +19,24 @@ public:
     void operator()(const BinaryOperation& b) const { print(b.op.kernelSymbol, b.l, b.r); }
     void operator()(const UnaryOperation& u) const{ printUnique(u.op.kernelSymbol,u.e); }
  
+    void operator()(const FunctionOperation& f) const{
+	_os << f.func << "(";
+	for (unsigned int i = 0; i < f.args.size(); ++i) {
+		if (i != 0) {
+			_os << ",";
+		}
+		boost::apply_visitor(*this, f.args[i]);
+	}
+	_os << ")";
+    }
+
     // Logical
  
     // Power Math operators
-    void operator()(const funcop<op_power>& b) const { printFunc("pow", b.oper1, b.oper2); }
+    void operator()(const funcop<op_power>& b) const { _os << "power"; }
     void operator()(const binop<op_powerTen>& b) const { printPowerTen("e", b.oper1, b.oper2); }
  
     // Functions
-    void operator()(const forop<fun_three>& b) const { printFunctionThree(b.oper1, b.oper2, b.oper3,  b.oper4); }
-    void operator()(const triop<fun_two>& b) const { printFunctionTwo(b.oper1, b.oper2, b.oper3); }
-    void operator()(const binop<fun_one>& b) const { printFunctionOne(b.oper1, b.oper2); }
-    
     // printer
     void print(const std::string& op, const ExpressionContainer& l, const ExpressionContainer& r) const
     {
@@ -52,46 +59,6 @@ public:
             boost::apply_visitor(*this, r);
     }
  
-          void printFunc(const std::string& op, const ExpressionContainer& l, const ExpressionContainer& r) const
-    {
-        _os << op;
-        _os << "(";
-            boost::apply_visitor(*this, l);
-        _os << ",";
-            boost::apply_visitor(*this, r);
-        _os << ")";
-    }
-
-          void printFunctionThree(const ExpressionContainer& functionId, const ExpressionContainer& l, const ExpressionContainer& m, const ExpressionContainer& r) const
-    {
-        boost::apply_visitor(*this, functionId);
-        _os << "(";
-            boost::apply_visitor(*this, l);
-            _os << ',';
-            boost::apply_visitor(*this, m);
-            _os << ',';
-            boost::apply_visitor(*this, r);
-        _os << ")";
-    }
-          
-          void printFunctionTwo(const ExpressionContainer& functionId, const ExpressionContainer& l, const ExpressionContainer& r) const
-    {
-        boost::apply_visitor(*this, functionId);
-        _os << "(";
-            boost::apply_visitor(*this, l);
-            _os << ',';
-            boost::apply_visitor(*this, r);
-        _os << ")";
-    }
-    
-          void printFunctionOne(const ExpressionContainer& functionId, const ExpressionContainer& l) const
-    {
-        boost::apply_visitor(*this, functionId);
-        _os << "(";
-            boost::apply_visitor(*this, l);
-        _os << ")";
-    }
-
 };
  
 std::ostream& operator<<(std::ostream& os, const ExpressionContainer& e)
@@ -50,9 +50,9 @@ public:
         greater_=  fold<GreaterOperation>(lower_.alias())[greaterOperator_ >> lower_];
         lower_ = fold<LowerOperation>( functions_.alias())[lowerOperator_ >> functions_];
  
-        functions_ = (threeArgsFunction>>"(">>funArgs_>>componentOperator_>>funArgs_>>componentOperator_>>funArgs_>>")")[_val= boost::phoenix::construct<Expression::forop <fun_three>>(_1,_2,_3,_4)] ||
-        (twoArgsFunction>>"(">>funArgs_>>componentOperator_>>funArgs_>>")")[_val= boost::phoenix::construct<Expression::triop <fun_two>>(_1,_2,_3)]||
-        (oneArgsFunction>>"(">>funArgs_>>")")[_val= boost::phoenix::construct<Expression::binop <fun_one>>(_1,_2)]|not_[_val=_1];
+        functions_ = (threeArgsFunction>>"(">>funArgs_>>componentOperator_>>funArgs_>>componentOperator_>>funArgs_>>")")[_val= boost::phoenix::construct<FunctionOperation>(_1,_2,_3,_4)] ||
+        (twoArgsFunction>>"(">>funArgs_>>componentOperator_>>funArgs_>>")")[_val= boost::phoenix::construct<FunctionOperation>(_1,_2,_3)]||
+        (oneArgsFunction>>"(">>funArgs_>>")")[_val= boost::phoenix::construct<FunctionOperation>(_1,_2)]|not_[_val=_1];
 	// UNARY OPERATIONS
 	not_ = (notOperator_ > const_) [_val = boost::phoenix::construct<NotOperation>(_1)] | const_[_val = _1];