monitoring.h

Go to the documentation of this file.

#ifndef MONITORING_H
#define MONITORING_H

#include <deque>
#include <vector>
#include <string>
#include <iostream>

#include "search_engine.h"
#include "globals.h"
#include "state.h"
#include "operator.h"

class FullPlanTrace
{
   public:
      explicit FullPlanTrace(const TimeStampedState & s);

      class FullPlanStep
      {
         public:
            FullPlanStep(const TimeStampedState & p, const Operator* o, const TimeStampedState & s)
               : predecessor(p), op(o), state(s) {}

            TimeStampedState predecessor;
            const Operator* op;
            TimeStampedState state;
      };

      bool isApplicable(const Operator* op) const;


      FullPlanTrace applyOperator(const Operator* op) const;

      bool canLetTimePass() const;


      FullPlanTrace letTimePass() const;

      bool satisfiesGoal() const;

      double lastTimestamp() const;

      void outputPlan(ostream & os) const;

      void dumpLastState() const;

      double getLastTimestamp() const;

   protected:
      std::deque<FullPlanStep> plan;

};

class MonitorEngine
{
    protected:
        MonitorEngine();
        static MonitorEngine* instance;

        static void readPlanFromFile(const string & filename, vector<string> & plan);

    public:
        ~MonitorEngine();

        static MonitorEngine* getInstance();

        static bool validatePlan(const string & filename);

        bool validatePlan(std::vector<std::string> & plan);

        bool validatePlan(const std::vector< std::vector<PlanStep> > & plan);
        bool validatePlanOld(const std::vector< std::vector<PlanStep> > & plan) __attribute__((deprecated));
};

class PlanStepCompareStartTime
{
   public:
      bool operator()(const std::vector<PlanStep> & s1, const std::vector<PlanStep> & s2) const {
          if(s1.empty())
              return false;
          if(s2.empty())
              return true;
         return s1.front().start_time < s2.front().start_time;
      }
};

#endif