attentive.h

#ifndef ATTENTIVE_H
#define ATTENTIVE_H
#include "focused.h"
 
class AttentiveConfigurator: public virtual FocusedConfigurator{
    protected:
 
    virtual bool preventTransition(vertexDescriptor v)override{
        return false;
    }
 
    bool recycle_plan(vertexDescriptor v, vertexDescriptor &v0, vertexDescriptor & task_start, StateMatcher::MATCH_TYPE &matchType, 
                    b2Transform & shift_start, b2Transform& sk_first_start, std::pair<edgeDescriptor, bool>&edge,
                    std::vector<vertexDescriptor> &plan_prov, Direction t_get_direction)override;
 
    virtual VertexMatch findMatch(State s, Direction dir=Direction::UNDEFINED, StateMatcher::MATCH_TYPE match_type=StateMatcher::_TRUE, StateDifference * _sd=NULL, vertexDescriptor src=TransitionSystem::null_vertex())override;
 
    std::pair<bool, vertexDescriptor> isPlannedTaskOK(vertexDescriptor src, State s);
 
 
};
 
class DiscreteConfigurator : public virtual FocusedConfigurator{
public:
Disturbance getDisturbance(TransitionSystem&g, vertexDescriptor v, b2World & world, const Direction & dir, const b2Transform& start)override;
 
Robot makeRobot(b2World & w, const Task & task)override;
 
float remainingSimulationTime(const Task *const t=NULL)override;
 
VertexMatch findMatch(State s, Direction dir=Direction::UNDEFINED, StateMatcher::MATCH_TYPE match_type=StateMatcher::_TRUE, StateDifference * _sd=NULL, vertexDescriptor src=TransitionSystem::null_vertex())override;
 
StateMatcher::MATCH_TYPE desiredMatch() override {
    return StateMatcher::MATCH_TYPE::_TRUE;
}
void transitionMatrix(vertexDescriptor v, Direction d, vertexDescriptor src) override;
 
bool closeVertex(std::set<vertexDescriptor> & closed, vertexDescriptor v)override;
 
 
void backtrack(std::vector <vertexDescriptor>& evaluation_q, std::vector <vertexDescriptor>&priority_q, std::set<vertexDescriptor>& closed, std::vector <vertexDescriptor>& plan_prov, vertexDescriptor module_src, vertexDescriptor startRecycle)override;
 
std::vector<Direction> partiallyExplorativeOptions(std::pair<bool, edgeDescriptor> ve)override;
 
bool shouldPartiallyExplore(const std::vector<edgeDescriptor>& oe, std::pair<bool, edgeDescriptor> ve)override;
 
bool canPropagate(vertexDescriptor v) override;
 
bool canReassignOutcome(vertexDescriptor v) override;
 
bool propagateD(vertexDescriptor v1, vertexDescriptor v0, std::set<vertexDescriptor>*closed=NULL, StateMatcher::MATCH_TYPE match=StateMatcher::_FALSE)override;
 
float customSimulationStep(vertexDescriptor v=TransitionSystem::null_vertex())override{
    return simulationStep;
}
 
};
 
// /**
//  * @brief Plans by simply looking ahead at the possible Tasks and choosing the best sequence.
//  * Does not process states, e.g. with split
//  */
// class SimplestConfigurator: public FocusedConfigurator{
//  int simulationStep=BOX2DRANGE;
 
//  Robot makeRobot(b2World & world, const b2Transform & start){
//      return Configurator::makeRobot(world, start);
//  }
 
//  Disturbance getDisturbance(TransitionSystem&g, vertexDescriptor v, b2World & world, const Direction & dir, const b2Transform& start){
//      return g[v].Dn;
//  }
 
//  void backtrack(std::vector <vertexDescriptor>& evaluation_q, std::vector <vertexDescriptor>&priority_q, std::set<vertexDescriptor>& closed, std::vector <vertexDescriptor>& plan_prov, vertexDescriptor module_src=MOVING_VERTEX, vertexDescriptor startRecycle=MOVING_VERTEX);
 
 
 
// };
#endif