.. _program_listing_file__tmp_ws_src_ros2_planning_system_plansys2_pddl_parser_include_plansys2_pddl_parser_Expression.h:

Program Listing for File Expression.h
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_ros2_planning_system_plansys2_pddl_parser_include_plansys2_pddl_parser_Expression.h>` (``/tmp/ws/src/ros2_planning_system/plansys2_pddl_parser/include/plansys2_pddl_parser/Expression.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   #pragma once
   
   #include "plansys2_msgs/msg/node.hpp"
   #include "plansys2_msgs/msg/tree.hpp"
   
   #include "plansys2_pddl_parser/Condition.h"
   
   namespace parser { namespace pddl {
   
   class Instance;
   
   class Expression : public Condition {
   
   public:
   
       virtual ~Expression() {}
       virtual std::string info() const = 0;
       virtual double evaluate() = 0;
       virtual double evaluate( Instance & ins, const StringVec & par ) = 0;
       virtual IntSet params() = 0;
   
       // inherit
       virtual void print( std::ostream & stream ) const {
           stream << info();
       }
   
       virtual void parse( Stringreader & f, TokenStruct< std::string > & ts, Domain & d ) {}
       virtual void addParams( int m, unsigned n ) {}
   };
   
   Expression * createExpression( Stringreader & f, TokenStruct< std::string > & ts, Domain & d );
   
   class CompositeExpression : public Expression {
   
   public:
   
       std::string op;
       Expression * left;
       Expression * right;
   
       CompositeExpression( const std::string& c ) : op( c ) {}
   
       CompositeExpression( const std::string& c, Expression * l, Expression * r ) : op( c ), left( l ), right( r ) {}
   
       ~CompositeExpression() {
           delete left;
           delete right;
       }
   
       void parse( Stringreader & f, TokenStruct< std::string > & ts, Domain & d ) {
           f.next();
           left = createExpression( f, ts, d );
           right = createExpression( f, ts, d );
           f.next();
           f.assert_token( ")" );
       }
   
       std::string info() const {
           std::ostringstream os;
           os << "(" << op << " " << left->info() << " " << right->info() << ")";
           return os.str();
       }
   
       void PDDLPrint( std::ostream & s, unsigned indent, const TokenStruct< std::string > & ts, const Domain & d ) const override {
     tabindent(s, indent);
           s << "( " << op << " ";
           left->PDDLPrint( s, indent, ts, d );
           s << " ";
           right->PDDLPrint( s, indent, ts, d );
           s << " )";
       }
   
       plansys2_msgs::msg::Node::SharedPtr getTree( plansys2_msgs::msg::Tree & tree, const Domain & d, const std::vector<std::string> & replace = {} ) const override {
           plansys2_msgs::msg::Node::SharedPtr node = std::make_shared<plansys2_msgs::msg::Node>();
           node->node_type = plansys2_msgs::msg::Node::EXPRESSION;
           node->expression_type = getExprType(op);
           node->node_id = tree.nodes.size();
           tree.nodes.push_back(*node);
   
           plansys2_msgs::msg::Node::SharedPtr left_child = left->getTree(tree, d, replace);
           tree.nodes[node->node_id].children.push_back(left_child->node_id);
   
           plansys2_msgs::msg::Node::SharedPtr right_child = right->getTree(tree, d, replace);
           tree.nodes[node->node_id].children.push_back(right_child->node_id);
   
           return node;
       }
   
       double compute( double x, double y ) {
           double res = 0;
   
           if ( op == "+" ) res = x + y;
           else if ( op == "-" ) res = x - y;
           else if ( op == "*" ) res = x * y;
           else if ( op == "/" ) res = ( y == 0 ? 0 : x / y );
   
           return res;
       }
   
       double evaluate() {
           return compute( left->evaluate(), right->evaluate() );
       }
   
       double evaluate( Instance & ins, const StringVec & par ) {
           return compute( left->evaluate( ins, par ), right->evaluate( ins, par ) );
       }
   
       IntSet params() {
           IntSet lpars = left->params();
           IntSet rpars = right->params();
           lpars.insert( rpars.begin(), rpars.end() );
           return lpars;
       }
   
       Condition * copy( Domain & d ) {
           Expression * cleft = dynamic_cast< Expression * >( left->copy( d ) );
           Expression * cright = dynamic_cast< Expression * >( right->copy( d ) );
           return new CompositeExpression( op, cleft, cright );
       }
   };
   
   class FunctionExpression : public Expression {
   
   public:
   
       ParamCond * fun;
    std::vector<Expression*> constants;
   
     FunctionExpression( ParamCond * c ) : fun( c ) {
       constants.clear();
       constants.resize(c->params.size());
       std::fill(constants.begin(), constants.end(), nullptr);
     }
     FunctionExpression( ParamCond * c, std::vector<Expression*> e) : fun( c ), constants(e) {}
   
       ~FunctionExpression() {
           delete fun;
       }
   
       std::string info() const {
           std::ostringstream os;
           os << "(" << fun->name << fun->params << ")";
           return os.str();
       }
   
       void PDDLPrint( std::ostream & s, unsigned indent, const TokenStruct< std::string > & ts, const Domain & d ) const override;
   
       plansys2_msgs::msg::Node::SharedPtr getTree( plansys2_msgs::msg::Tree & tree, const Domain & d, const std::vector<std::string> & replace = {} ) const override;
   
       double evaluate() { return 1; }
   
       double evaluate( Instance & ins, const StringVec & par );
   
       IntSet params() {
           return IntSet( fun->params.begin(), fun->params.end() );
       }
   
       Condition * copy( Domain & d ) {
           return new FunctionExpression( dynamic_cast< ParamCond * >( fun->copy( d ) ) );
       }
   };
   
   class ValueExpression : public Expression {
   
   public:
   
       double value;
   
       ValueExpression( double v ) : value( v ) {}
   
       std::string info() const {
           std::ostringstream os;
           os << value;
           return os.str();
       }
   
       void PDDLPrint( std::ostream & s, unsigned indent, const TokenStruct< std::string > & ts, const Domain & d ) const override {
           s << value;
       }
   
       plansys2_msgs::msg::Node::SharedPtr getTree( plansys2_msgs::msg::Tree & tree, const Domain & d, const std::vector<std::string> & replace = {} ) const override {
           plansys2_msgs::msg::Node::SharedPtr node = std::make_shared<plansys2_msgs::msg::Node>();
           node->node_type = plansys2_msgs::msg::Node::NUMBER;
           node->node_id = tree.nodes.size();
           node->value = value;
           tree.nodes.push_back(*node);
           return node;
       }
   
       double evaluate() { return value; }
   
       double evaluate( Instance & ins, const StringVec & par ) {
           return value;
       }
   
       IntSet params() {
           return IntSet();
       }
   
       Condition * copy( Domain & d ) {
           return new ValueExpression( value );
       }
   };
   
   class DurationExpression : public Expression {
   
       void PDDLPrint( std::ostream & s, unsigned indent, const TokenStruct< std::string > & ts, const Domain & d ) const override {
           s << "?duration";
       }
   
       plansys2_msgs::msg::Node::SharedPtr getTree( plansys2_msgs::msg::Tree & tree, const Domain & d, const std::vector<std::string> & replace = {} ) const override {
           throw UnsupportedConstruct("DurationExpression");
       }
   
       std::string info() const {
           return "?duration";
       }
   
       double evaluate() {
           return -1;
       }
   
       double evaluate( Instance & ins, const StringVec & par ) {
           return evaluate();
       }
   
       IntSet params() {
           return IntSet();
       }
   
       Condition * copy( Domain & d ) {
           return new DurationExpression();
       }
   };
   
   
   class ParamExpression : public Expression {
   
   public:
   
       int param;
   
       ParamExpression( int p ) : param( p ) {}
   
       std::string info() const {
           std::ostringstream os;
           os << param;
           return os.str();
       }
   
       void PDDLPrint( std::ostream & s, unsigned indent, const TokenStruct< std::string > & ts, const Domain & d ) const override {
           s << ts[param];
       }
   
       plansys2_msgs::msg::Node::SharedPtr getTree( plansys2_msgs::msg::Tree & tree, const Domain & d, const std::vector<std::string> & replace = {} ) const override {
           throw UnsupportedConstruct("ParamExpression");
       }
   
       double evaluate() { return -1; }
   
       double evaluate( Instance & ins, const StringVec & par ) {
     return evaluate();
       }
   
       IntSet params() {
           return IntSet();
       }
   
       Condition * copy( Domain & d ) {
           return new ParamExpression( param );
       }
   };
   
   class ConstExpression : public Expression {
   
   public:
   
       int constant;
    int tid;
     ConstExpression( int c, int t ) : constant( c ), tid (t) {}
   
       std::string info() const {
           std::ostringstream os;
           os << constant << " " << tid;
           return os.str();
       }
   
       void PDDLPrint( std::ostream & s, unsigned indent, const TokenStruct< std::string > & ts, const Domain & d ) const override;
   
       plansys2_msgs::msg::Node::SharedPtr getTree( plansys2_msgs::msg::Tree & tree, const Domain & d, const std::vector<std::string> & replace = {} ) const override {
           throw UnsupportedConstruct("ConstExpression");
       }
   
       double evaluate() { return -1; }
   
       double evaluate( Instance & ins, const StringVec & par ) {
     return evaluate();
       }
   
       IntSet params() {
           return IntSet();
       }
   
       Condition * copy( Domain & d ) {
     return new ConstExpression( constant, tid );
       }
   };
   
   } } // namespaces