---

/home/pauldt/projects/IDEA/IDEA-ALL/IDEA-DEV/Core/GoalLoader/Includes/PlanReader.hh

Go to the documentation of this file.

// -*- Mode: C++ -*-
//      CVS: $Id: PlanReader.hh,v 1.9 2005/08/23 20:26:22 rijsman Exp $
//      Tag: $name$
//     Info: $CVSROOT/Copyright.txt

#ifndef PLAN_READER_HH
#define PLAN_READER_HH 

#include <map>
#include <vector>
#include <string>
#include <iostream>
#include "TimeBasics.hh"
namespace IDEA 
{
  struct BranchPoint
  {
    BranchPoint(int key, int from, int to): 
      tokenKey(key), 
      contextFrom(from), 
      contextTo(to) {}

    int tokenKey;
    int contextFrom;
    int contextTo;
  };

  struct TimeBranch:
    public BranchPoint
  {
    TimeBranch(int key, int from, int to, long time) : 
      BranchPoint(key, from, to),
      deadLine(time) {}
    long deadLine;
  };

  struct EnergyBranch:
    public BranchPoint
  {
    EnergyBranch(): 
      BranchPoint(0,0,0) {}
    double energyLeft;
  };

  struct TrackingBranch: 
    public BranchPoint
  {
    TrackingBranch(int key, int from, int to, bool flag, std::string target): 
      BranchPoint(key, from, to), 
      isTracking(flag), 
      targetName(target) {}

    bool isTracking;
    std::string targetName;
  };

  std::ostream& IDEA::operator << (std::ostream& os, 
                                   IDEA::BranchPoint const * branch);

  std::ostream& IDEA::operator << (std::ostream& os, 
                                   IDEA::TimeBranch const * branch);

  std::ostream& IDEA::operator << (std::ostream& os, 
                                   IDEA::TrackingBranch const * branch);

  class PlanReader
  {
  public:
    class IValue
    {
    public:
      virtual ~IValue() {}
    };
    template <class Type>
    class Value : public IValue
    {
    public:
      Value(Type value) {m_val = value;}
      const Type & get() const {return m_val;}
    private:
      Type m_val;
    };
    typedef std::map<std::string, IValue*> ArgumentToValue;

    struct TokenData
    {
      int key;
      Time earlyStart;
      Time earlyEnd;
      Time lateStart;
      Time lateEnd;
      std::string predicateName;
      ArgumentToValue arguments;
    };

    typedef std::vector<TokenData> TokenToArgValues;

    typedef std::map<std::string, TokenToArgValues> TimelineToTokens;

    struct ObjectData
    {
      std::string objectName;
      std::string className;
      TimelineToTokens timelines;
    };

    typedef std::map<std::string, ObjectData> ObjectToTimelines;

    struct EndsBeforeStartConstraint
    {
      int predecessor;
      int successor;
      long min;
      long max;
    };

    typedef std::vector<EndsBeforeStartConstraint> EndStartConstraints;

    struct Plan
    {
      ObjectToTimelines planObjects;
      EndStartConstraints constraints;
    };

    typedef std::map<int, Plan> ContextToPlanBranch;

    typedef std::map<int, IDEA::BranchPoint*> BranchPoints;
    virtual bool getBranchPoint(int tokenKey, BranchPoint *& branchPoint) = 0;

    virtual int readPlan( const std::string& fileName) = 0;
    virtual ObjectToTimelines const & getPlanObjects(int context = 0) = 0;
    virtual EndStartConstraints const & getPlanConstraints(int context = 0) = 0;
    virtual int getInfinity() {return INT_MAX;};
    virtual int getNegativeInfinity() { return -INT_MAX;}
  };

  std::ostream& operator << (std::ostream& os, 
                             PlanReader::TokenData const & token);
  std::ostream& 
  operator << (std::ostream& os, 
               PlanReader::EndsBeforeStartConstraint const & constraint);
  /*
  std::ostream& operator << (std::ostream& os, 
                             PlanReader::Value const & value);
  */
  std::ostream& operator << (std::ostream& os, 
                             PlanReader::ObjectToTimelines const & planBranch);
} //namespace IDEA 

#endif //PLAN_READER_HH 

---

Contact information © IDEA