Domain.hpp

Go to the documentation of this file.

#ifndef PDDL_PLANNER_REPRESENTATION_DOMAIN
#define PDDL_PLANNER_REPRESENTATION_DOMAIN

#include <string>
#include <map>
#include <vector>
#include <stdint.h>
#include <limits>
#include <stdexcept>
#include <cstdarg>
#include <stack>

namespace pddl_planner {
namespace representation {

typedef std::string Label;
typedef Label Operator;
typedef std::string Type;
typedef std::string Requirement;

typedef std::vector<Type> TypeList;
typedef std::vector<Requirement> RequirementList;

struct TypedItem
{
    Label label;
    Type type;

    TypedItem()
    {}

    TypedItem(const Label& label, const Type& type)
        : label(label)
        , type(type)
    {}

    bool undefined() const { return label.empty() || type.empty(); }

    bool operator!=(const TypedItem& other) const { return ! operator==(other); }
    bool operator==(const TypedItem& other) const { return label == other.label && type == other.type; }

};

typedef TypedItem Constant;

typedef std::vector<TypedItem> TypedItemList;
typedef TypedItemList ConstantList;
typedef TypedItemList ArgumentList;
typedef TypedItemList ParameterList;


class VariableManager
{
    std::vector<std::string> mKnownVariables;
    std::vector<Label> mOperatorStack;

public:
    VariableManager(const ArgumentList& arguments = ArgumentList());

    void push(const Label& label);
    Label pop();

    std::vector<Label> getOperatorStack() const { return mOperatorStack; }

    std::string getOperatorStackAsString() const;

    /*
     * Create a variable name, i.e. a string prefixed with ?
     * \return canonized string of given name
     */
    static std::string canonize(const std::string& name);

    /*
     * Test if the given name indicates a variable (currently indicated by starting with ?)
     * \return true if name is a variable, false otherwise
     */
    static bool isVariable(const std::string& name);

    void registerVariable(const std::string& name);

    bool isKnownVariable(const std::string& name) const;

    bool hasTypedVariable(const TypedItemList& list, const TypedItem& item) const;

    static void addTypedVariable(TypedItemList& list, const TypedItem& item);
};

struct Predicate
{
    Label label;
    ArgumentList arguments;

    Predicate(const Label& label, const ArgumentList& argumentList)
        : label(label)
        , arguments(argumentList)
    {}

    Predicate(const Label& label, const TypedItem& arg0 = TypedItem(), const TypedItem& arg1 = TypedItem(), const TypedItem& arg2 = TypedItem())
        : label(label)
    {
        if(!arg0.undefined())
        {
            VariableManager::addTypedVariable(arguments, arg0);
        }

        if(!arg1.undefined())
        {
            VariableManager::addTypedVariable(arguments, arg1);
        }

        if(!arg2.undefined())
        {
            VariableManager::addTypedVariable(arguments, arg2);
        }

    }
};
typedef std::vector<Predicate> PredicateList;

// Function has same structure as a predicate
typedef Predicate Function;
typedef std::vector<Function> FunctionList;

class Arity
{
    uint8_t mMin;
    uint8_t mMax;

public:
    Arity()
        : mMin( std::numeric_limits<uint8_t>::min() )
        , mMax( std::numeric_limits<uint8_t>::max() )
    {}

    Arity(uint8_t min, uint8_t max)
        : mMin(min)
        , mMax(max)
    {
        if(mMin > mMax)
        {
            throw std::invalid_argument("pddl_planner::representation::Arity: min arity greater than max");
        }
    }

    uint8_t getMin() const { return mMin; }

    uint8_t getMax() const { return mMax; }

    static Arity exact(uint8_t n) { return Arity(n,n); }

    static Arity min(uint8_t n) { return Arity(n,std::numeric_limits<uint8_t>::max()); }

    static Arity max(uint8_t n) { return Arity(std::numeric_limits<uint8_t>::min(),n); }
};

typedef std::map<Label, Arity> ArityMap;

class ArityValidator
{
    ArityMap mArityMap;

    void addDefaults();

public:
    ArityValidator(const PredicateList& predicates = PredicateList());

    bool isOperator(const Label& label) const;

    bool isQuantifier(const Label& label) const;

    void validate(const Label& label, uint8_t arity);
};


enum Quantor { UNKNOWN_QUANTOR, FORALL, EXISTS };
extern std::map<Quantor,std::string> QuantorTxt;

class Expression;
typedef std::vector<Expression*> ExpressionPtrList;
struct Expression
{
    Label label;
    ExpressionPtrList parameters;

    // For quantor expression
    TypedItem typedItem;

    Expression(const Label& label = "");
    Expression(const Expression& other);
    virtual ~Expression();

    Expression(const Label& label, const Expression& arg0, const Expression& arg1 = Expression(), const Expression& arg2 = Expression(), const Expression& arg3 = Expression(), const Expression& arg4 = Expression(), const Expression& arg5 = Expression(), const Expression& arg6 = Expression(), const Expression& arg7 = Expression(), const Expression& arg8 = Expression(), const Expression& arg9 = Expression(), const Expression& arg10 = Expression());

    Expression(const Label& label, const Label& arg0, const Label& arg1 = "", const Label& arg2 = "");

    Expression(Quantor quantor, const TypedItem& typedItem, const Expression& e);

    void addParameter(const Label& e);
    void addParameter(const Expression& e);

    bool isAtomic() const { return parameters.empty(); }

    bool isNull() const { return label.empty(); }

    static bool isQuantor(const Label& label);

    Expression& operator=(const Expression& other);

    bool operator==(const Expression& other) const;

    std::string toLISP() const;

    static Expression fromString(const std::string& expressionString);
};

typedef std::vector<Expression> ExpressionList;

struct Action
{
    Label label;
    ArgumentList arguments;
    ExpressionList preconditions;
    ExpressionList effects;

    Action(const Label& label, const ArgumentList& arguments)
        : label(label)
        , arguments(arguments)
    {}

    Action(const Label& label, const TypedItem& arg0 = TypedItem(), const TypedItem& arg1 = TypedItem(), const TypedItem& arg2 = TypedItem(), const TypedItem& arg3 = TypedItem())
        : label(label)
    {
        if(!arg0.undefined())
        {
            addArgument(arg0);
        }

        if(!arg1.undefined())
        {
            addArgument(arg1);
        }

        if(!arg2.undefined())
        {
            addArgument(arg2);
        }

        if(!arg3.undefined())
        {
            addArgument(arg3);
        }
    }

    void addPrecondition(const Expression& e)
    {
        preconditions.push_back(e);
    }

    void addEffect(const Expression& e)
    {
        effects.push_back(e);
    }

    void addArgument(const TypedItem& arg);

    bool isArgument(const Label& label);
};
typedef std::vector<Action> ActionList;

struct Domain
{
    // Domain name
    std::string name;
    // List of types of this domain
    TypeList types;
    // Map a type to a parent type if there is any
    std::map<Type,Type> type2parent;
    // List of constants in this domain
    ConstantList constants;
    // List of predicates in this domain
    PredicateList predicates;
    // List of requirements for using this domain description, e.g. 'strips' or 'typing'
    RequirementList requirements;
    // List of actions in this domain
    ActionList actions;
    // List of functions in this domain
    FunctionList functions;

    Domain(const std::string& name = "");

    void addType(const Type& type, const Type& parentType = "");

    void addConstant(const TypedItem& type, bool overwrite = false);
    void addPredicate(const Predicate& predicate, bool overwrite = false);
    void addRequirement(const Requirement& requirement);
    void addAction(const Action& action, bool overwrite = false);
    void addFunction(const Function& function, bool overwrite = false);

    void removeConstant(const Label& label);
    void removePredicate(const Label& label);
    void removeAction(const Label& label);
    void removeFunction(const Label& label);

    bool isType(const Type& type) const;
    bool isConstant(const Label& label) const;
    bool isPredicate(const Label& label) const;
    bool isRequirement(const Requirement& requirement) const;
    bool isAction(const Label& label) const;
    bool isFunction(const Label& label) const;

    Predicate getPredicate(const Label& label) const;
    Action getAction(const Label& label) const;

    std::string toLISP() const;

    bool hasName() const { return !name.empty(); }

    bool isNull() const { return !hasName(); }

    void validate(const Expression& e, const VariableManager& variableManager = VariableManager()) const;

    void validate() const;
};

} // end namespace representation
} // end namespace pddl_planner

#endif // PDDL_PLANNER_REPRESENTATION_DOMAIN