pddlModuleTypes.h

Go to the documentation of this file.

#ifndef _PDDL_MODULE_TYPES_H_
#define _PDDL_MODULE_TYPES_H_

#define PDDL_MODULE_VERSION_MAJOR 0
#define PDDL_MODULE_VERSION_MINOR 3
#define PDDL_MODULE_VERSION_STRING "0.3"

#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <algorithm>
#include <utility>
#include <tr1/unordered_map>
using std::string;
using std::vector;
using std::map;

// callback interface typedefs
typedef std::pair<int, int> VarVal;
typedef std::tr1::unordered_map<string, VarVal> PredicateMapping;
typedef std::tr1::unordered_map<string, int> FunctionMapping;
//typedef std::vector<std::pair<std::string, std::string> > ObjectStringList;
typedef std::map<std::string, std::string> ObjectTypeMap;

namespace modules
{

const double INFINITE_COST = HUGE_VAL;

static string toLower(const string & s)
{
   string ret;
#ifdef _WIN32
   std::transform(s.begin(), s.end(), back_inserter(ret), (int(*)(int)) tolower);
#else
   std::transform(s.begin(), s.end(), back_inserter(ret), (int(*)(int)) std::tolower);
#endif
   return ret;
}

class Parameter {
   public:
      Parameter(string n, string t, string v = "") {
         if(n.find("?") == 0) // strip leading '?'
            n = n.substr(1);
         name = toLower(n);
         type = toLower(t);
         value = toLower(v);
      }

      string name;    
      string type;    
      string value;   
};

typedef vector<Parameter> ParameterList;

class Predicate {
   public:
      Predicate(string n, ParameterList pl, bool v = true) : parameters(pl), value(v) { 
         name = toLower(n);
      }

      string name;
      ParameterList parameters;
      bool value;
};

typedef vector<Predicate> PredicateList;

class NumericalFluent {
   public:
      NumericalFluent(string n, ParameterList pl, double v = 0.0) : parameters(pl), value(v) { 
         name = toLower(n);
      }

      string name;
      ParameterList parameters;
      double value;
};

typedef vector<NumericalFluent> NumericalFluentList;

typedef bool (*predicateCallbackType)(PredicateList* & predicateList);

typedef bool (*numericalFluentCallbackType)(NumericalFluentList* & numericalFluentList);

/**** Begin Actual Module Calls ****/

typedef void (*moduleInitType)(int argc, char** argv);
 

typedef double (*conditionCheckerType)(const ParameterList & parameterList,
        predicateCallbackType predicateCallback, numericalFluentCallbackType numericalFluentCallback, int relaxed);


typedef int (*applyEffectType)(const ParameterList & parameterList,
        predicateCallbackType predicateCallback, numericalFluentCallbackType numericalFluentCallback,
        vector<double> & writtenVars);

/**** Interface addition for extracting the plan from a module - irrelevant for the actual planning process  ****/

typedef void* subplanType;


typedef subplanType (*subplanGeneratorType)(const string & operatorName, const ParameterList & parameterList,
        predicateCallbackType predicateCallback, numericalFluentCallbackType numericalFluentCallback, int heuristic);
//FIXME: do we need heuristic here?

typedef string (*outputSubplanType)(subplanType subplan);

typedef vector<subplanType> modulePlanType;


typedef void (*executeModulePlanType)(modulePlanType modulePlan);

std::ostream & operator<<(std::ostream & os, const Parameter & p);
std::ostream & operator<<(std::ostream & os, const ParameterList & pl);
std::ostream & operator<<(std::ostream & os, const Predicate & p);
std::ostream & operator<<(std::ostream & os, const PredicateList & pl);
std::ostream & operator<<(std::ostream & os, const NumericalFluent & n);
std::ostream & operator<<(std::ostream & os, const NumericalFluentList & nl);

} // namespace modules

#define VERIFY_CONDITIONCHECKER_DEF(name) conditionCheckerType name##_def_check = name
#define VERIFY_APPLYEFFECT_DEF(name) applyEffectType name##_def_check = name
#define VERIFY_SUBPLANGENERATOR_DEF(name) subplanGeneratorType name##_def_check = name

#endif