b2bconfigurator.h

#ifndef B2BCONFIGURATOR_H
#define B2BCONFIGURATOR_H
#include "attentive.h"
struct FrontierCrashed{
    FrontierCrashed() = default;
 
    FrontierCrashed(TransitionSystem & ts, Direction d) : transitionSystem(ts), direction(d) {}
 
    bool operator()(const Frontier & f) const {
        if (f.connecting.empty()) return false;
        return transitionSystem[f.connecting[0]].direction==direction && transitionSystem[f.frontier].outcome==simResult::crashed;
    }
    private:
    TransitionSystem & transitionSystem;
    Direction direction=UNDEFINED;
};
 
class B2BConfigurator : public virtual AttentiveConfigurator {
public:
    B2BConfigurator() = default;
 
    B2BConfigurator(Task & task) {
        init(task);
    }
 
protected:
 
    bool closeVertex(std::set<vertexDescriptor> & closed, vertexDescriptor v) override;
 
    //std::vector<Direction> partiallyExplorativeOptions(std::pair<bool, edgeDescriptor> ve) override;
 
    // /**
    //  * @brief Doesn't split the task, just returns the vertex of the task at hand; if Task fails or 
    //  * it's currently executing, it returns the source vertex for the task aswell
    //  * 
    //  * @param v vertex of the task
    //  * @param d direction of the task that are allowed to split (not used)
    //  * @param src source of the task
    //  * @return std::vector <vertexDescriptor> 
    //  */
    // std::vector <vertexDescriptor> splitTask(vertexDescriptor v, Direction d, vertexDescriptor src=TransitionSystem::null_vertex()) override;
 
 
    virtual float customSimulationStep(vertexDescriptor v=TransitionSystem::null_vertex());
 
 
   virtual 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)override;
 
    bool attentionWindowOverlaps(const Disturbance & Di, const State & q, b2World & world, const Disturbance & focus );
 
    int visitedEdgeCount(const std::vector <edgeDescriptor>& es);
 
    int minimumEdgesForClearvoyance(Direction direction);
 
   // bool canGoToClearVoyance(const std::vector <edgeDescriptor> &oe, Direction direction);
    virtual Disturbance getDisturbance(TransitionSystem&g, vertexDescriptor v, b2World & world, const Direction & dir, const b2Transform& start) override;
 
    //virtual std::vector <vertexDescriptor> task_vertices(vertexDescriptor v, std::pair<bool, edgeDescriptor>* ep=NULL);
 
    template <typename P>
    std::vector <Direction> transitionInHindsight(vertexDescriptor v, P predicate){
        std::vector <Direction> result;
        ExecutionInfo info=package_info();
        std::vector <Frontier> frontiers=frontierVertices(v, transitionSystem, info);
        if (frontiers.size()<2){ //only  explored
           // result={DEFAULT, LEFT, RIGHT};
            //erase_from_vector(result, transitionSystem[ve.second.m_target].direction);
           // return result;
           result= predicate(v);
        }
        else if (frontiers.size()<4){ //left right explored
            auto fLeft= std::find_if(frontiers.begin(), frontiers.end(), FrontierCrashed(transitionSystem, LEFT));
            auto fRight= std::find_if(frontiers.begin(), frontiers.end(), FrontierCrashed(transitionSystem, RIGHT));
            if (fLeft!=frontiers.end()){
                result.push_back(DEFAULT);
            } 
            if (fRight!=frontiers.end()){
                result.push_back(DEFAULT);
            } 
        }
        return result;
    }
 
    //     /**
    // *Combines edges K and jump function: represents possible transitions out of a state
    // *@param v the vertex to which transitions are being assigned
    // *@param d state direction (redundant)
    // *@param src source vertex of state
    // */
    // virtual void transitionMatrix(vertexDescriptor v, Direction d, vertexDescriptor src)override; 
 
    // virtual void removeExploredTransitions(vertexDescriptor v);
 
virtual std::vector<vertexDescriptor> explorer(vertexDescriptor v, TransitionSystem&g, b2World &w)override; //evaluates only after DEFAULT, internal one step lookahead
 
virtual simResult simulate(Task t, b2World & world, vertexDescriptor v0); 
 
void applyTransitionMatrix(vertexDescriptor v0, Direction d, bool ended, vertexDescriptor src, std::vector<vertexDescriptor>& plan_prov);
 
 
// /**
//  * @brief Overload of makeRobot, uses a disturbance which may be the goal of the hindsight disturbance to make the sensor
//  * 
//  * @param t 
//  * @param world 
//  * @param focus disturbance focus of attention (used for making the sensor)
//  * @return Robot 
//  */
// virtual Robot makeRobot( b2World & world, const b2Transform& start, const Disturbance & focus);
class ClearVoyance{
    public:
    struct DisturbanceLookahead {
        std::vector<Disturbance> disturbances;
        vertexDescriptor source; //vertex from which additional DEFAULT Tasks will be explored 
 
        DisturbanceLookahead()=default;
 
        DisturbanceLookahead( vertexDescriptor v, const Disturbance & d) : source(v) {
            disturbances.push_back(d);
        }
 
    };
 
    virtual bool add(vertexDescriptor v, const Disturbance& d);
 
    virtual Disturbance query(vertexDescriptor v);
 
    void pop(vertexDescriptor v);
 
    void reset() {lookaheads.clear();}
 
    std::vector <DisturbanceLookahead> getLookaheads() const {
        return lookaheads;
    }
 
    void setRoot(vertexDescriptor v){
        root=v;
    }
 
    vertexDescriptor getRoot(){
        return root;
    }
    protected:
    vertexDescriptor root=TransitionSystem::null_vertex(); //root of modular expansion
    std::vector<DisturbanceLookahead> lookaheads;
}clearvoyance;
 
void addOptionsInHindsight(vertexDescriptor v, vertexDescriptor v0, vertexDescriptor v1);
 
 
};
 
#endif