.. _program_listing_file__tmp_ws_src_ros2_planning_system_plansys2_pddl_parser_include_plansys2_pddl_parser_FunctionModifier.h:

Program Listing for File FunctionModifier.h
===========================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_ros2_planning_system_plansys2_pddl_parser_include_plansys2_pddl_parser_FunctionModifier.h>` (``/tmp/ws/src/ros2_planning_system/plansys2_pddl_parser/include/plansys2_pddl_parser/FunctionModifier.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/Ground.h"
   #include "plansys2_pddl_parser/Condition.h"
   #include "plansys2_pddl_parser/Function.h"
   #include "plansys2_pddl_parser/Expression.h"
   
   
   namespace parser { namespace pddl {
   
   class FunctionModifier : public Condition {
   
   public:
   
       std::string name;
   
       Ground * modifiedGround;  // if null -> total-cost
       Expression * modifierExpr;  // the expression by which we increment/decrement
   
       FunctionModifier( const std::string& name, int val = 1 );
   
       FunctionModifier( const std::string& name, Function * f, const IntVec & p = IntVec() );
   
       FunctionModifier( const std::string& name, const FunctionModifier * i, Domain & d );
   
       ~FunctionModifier() {
           if ( modifiedGround ) delete modifiedGround;
           if ( modifierExpr ) delete modifierExpr;
       }
   
       void print( std::ostream & s ) const {
           s << name << " ";
           if ( modifiedGround ) modifiedGround->print( s );
           if ( modifierExpr ) modifierExpr->print( s );
           s << "\n";
       }
   
       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;
   
       void parse( Stringreader & f, TokenStruct< std::string > & ts, Domain & d );
   
       void addParams( int m, unsigned n ) {}
   };
   
   class Assign : public FunctionModifier {
   
   public:
   
       Assign( int val = 1 ) : FunctionModifier( "assign", val ) { }
   
       Assign( Function * f, const IntVec & p = IntVec() ) : FunctionModifier( "assign", f, p ) { }
   
       Assign( const FunctionModifier * i, Domain & d ) : FunctionModifier( "assign", i, d ) { }
   
       Condition * copy( Domain & d ) {
           return new Assign( this, d );
       }
   };
   
   class Decrease : public FunctionModifier {
   
   public:
   
       Decrease( int val = 1 ) : FunctionModifier( "decrease", val ) { }
   
       Decrease( Function * f, const IntVec & p = IntVec() ) : FunctionModifier( "decrease", f, p ) { }
   
       Decrease( const FunctionModifier * i, Domain & d ) : FunctionModifier( "decrease", i, d ) { }
   
       Condition * copy( Domain & d ) {
           return new Decrease( this, d );
       }
   };
   
   class Increase : public FunctionModifier {
   
   public:
   
       Increase( int val = 1 ) : FunctionModifier( "increase", val ) { }
   
       Increase( Function * f, const IntVec & p = IntVec() ) : FunctionModifier( "increase", f, p ) { }
   
       Increase( const FunctionModifier * i, Domain & d ) : FunctionModifier( "increase", i, d ) { }
   
       Condition * copy( Domain & d ) {
           return new Increase( this, d );
       }
   };
   
   } } // namespaces