symbolicState.h

Go to the documentation of this file.

#ifndef SYMBOLIC_STATE_H
#define SYMBOLIC_STATE_H

#include <boost/foreach.hpp>
#ifdef __CDT_PARSER__
#define forEach(a, b) for(a : b)
#else
#define forEach BOOST_FOREACH
#endif
#include <math.h>

#include <stdarg.h>
#include <string>
#include <deque>
#include <vector>
#include <map>
#include <utility>
using std::string;
using std::deque;
using std::vector;
using std::map;
using std::multimap;
using std::pair;
using std::make_pair;
#include <ostream>

inline bool double_equals(double d1, double d2)
{
    return fabs(d1 - d2) < 0.0001;
}


class Predicate
{
    public:
        string name;
        vector<string> parameters;

        bool operator<(const Predicate & p) const;
};
std::ostream & operator<<(std::ostream & os, const Predicate & p);


class SymbolicState
{
    public:
        friend std::ostream & operator<<(std::ostream & os, const SymbolicState & ss);
        class OStreamMode {
            public:
                static bool forceNewlines;
        };

        SymbolicState();
        virtual ~SymbolicState();

        typedef multimap<string,string>::iterator TypedObjectIterator;
        typedef multimap<string,string>::const_iterator TypedObjectConstIterator;

        void clear() {
            _typedObjects.clear();
            _booleanPredicates.clear();
            _numericalFluents.clear();
            _objectFluents.clear();
        }

        // Setter/Getter


        void addObject(string obj, string type);

        void addSuperType(string type, string supertype);

        void printSuperTypes() const;


        void removeObject(string obj, bool removePredicates = true);

        const multimap<string, string> & getTypedObjects() const { return _typedObjects; }


        void setBooleanPredicate(string name, vector<string> parameters, bool value);

        void setBooleanPredicate(string name, string parameters, bool value);
        void setAllBooleanPredicates(string name, bool value);

        void setNumericalFluent(string name, vector<string> parameters, double value);
        void setNumericalFluent(string name, string parameters, double value);
        void setAllNumericalFluents(string name, double value);

        void setObjectFluent(string name, vector<string> parameters, string value);
        void setObjectFluent(string name, string parameters, string value);
        void setAllObjectFluents(string name, string value);

        void setForEachGoalStatement(string objectType, string predicateName, bool value);


        bool hasBooleanPredicate(const Predicate & p, bool* value) const;
        bool hasNumericalFluent(const Predicate & p, double* value) const;
        bool hasObjectFluent(const Predicate & p, string* value) const;

        // state matching


        bool isFulfilledBy(const SymbolicState & other) const;

        bool booleanEquals(const SymbolicState & other) const;
        bool numericalEquals(const SymbolicState & other) const;
        bool objectFluentsEquals(const SymbolicState & other) const;
        bool equals(const SymbolicState & other) const;

        // conversion/writing

        virtual void toPDDLProblem(std::ostream & ss) const;
        virtual void toPDDLGoal(std::ostream & ss) const;

    protected:
        vector<string> buildParameterList(string params) const;


        bool isMostSpecificType(string obj, string type) const;

    protected:

        multimap<string, string> _typedObjects;

        multimap<string, string> _superTypes;      

        // The only possible parameters for the following predicates should be those in the _typedObjects list.
        // matched strings in _objectFluents should also only be from _typedObjects and of the correct type
        map<Predicate, bool> _booleanPredicates;
        map<Predicate, double> _numericalFluents;
        map<Predicate, string> _objectFluents;
        // foreach statements
        typedef multimap<string, pair<string, bool> > ForEachGoalStatements;
        ForEachGoalStatements _forEachGoalStatements;

        typedef map<Predicate, bool>::value_type BooleanPredicateEntry;
        typedef map<Predicate, double>::value_type NumericalFluentEntry;
        typedef map<Predicate, string>::value_type ObjectFluentEntry;
};

std::ostream & operator<<(std::ostream & os, const SymbolicState & ss);

#endif