PursuitGNode.hpp

Go to the documentation of this file.

#ifndef LGL_PURSUIT_GRAPH_NODE_HPP
#define LGL_PURSUIT_GRAPH_NODE_HPP

#include <lgl/CellID.hpp>

#include <set>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>



namespace jafar {
  namespace lgl {
    
    // TODO change the name (more specific) => pursuit-toto
    // cf old conflict with "OK" in genom
    typedef enum {  SEEN,             // Nothing special, situation is under control
            RISK,             // The target is unseen, but still managed
            DANGER_HIDDEN,          // The target is hiding from the robot (enter not visible enough area)
            DANGER_LOST,          // Too much potential position for the target : it overwhelms the robot capacities ;
                                  // or the robot cannot re-catch the target in a finite time (inaccessible area, etc.)
            DANGER_UNSEEN,          // The risk term reached its maximal value (the target has been unseen for too much time)
            DANGER_DISAPPEARED        // The target "disappeared" (it's probable that the target model does not fit the real target)
      } RISK_LEVEL;
    class PursuitGNode {
    
      private :
        std::vector< boost::weak_ptr<PursuitGNode> > children;

      public : 
        Cell_ID robotPos;

        RISK_LEVEL risk;
        
        std::set<Cell_ID> targetPos;

        unsigned int time;
    
        unsigned int riskTerm;
    
        PursuitGNode() :
          robotPos (0),
          risk (SEEN),
          time(0),
          riskTerm(0)
        { }
      
        PursuitGNode( Cell_ID _robotPos, RISK_LEVEL _risk, unsigned long int _time=0, unsigned long int _riskTerm=0 ) :
          robotPos(_robotPos),
          risk(_risk),
          time(_time),
          riskTerm(_riskTerm)
        { }

        PursuitGNode(Cell_ID _robotPos, RISK_LEVEL _risk, std::set<Cell_ID> _targetPos, unsigned long int _time=0, unsigned long int _riskTerm=0 ) :
          robotPos(_robotPos),
          risk(_risk),
          targetPos(_targetPos),
          time(_time),
          riskTerm(_riskTerm)
        { }
        
        ~PursuitGNode() { }

        void setChildren ( const std::vector< boost::shared_ptr<PursuitGNode> > &newChildren ) ;

        void noMoreChildren() ;

        void addChild ( const boost::shared_ptr<PursuitGNode> & newChild ) ;

        void addChild ( const boost::weak_ptr<PursuitGNode> & newChild ) ;

        const std::vector< boost::weak_ptr<PursuitGNode> > & getChildren () const ; 
        
        bool operator== (const PursuitGNode &rhs) const ; 

        bool equal (const PursuitGNode &rhs) const ; 

    };

    /* comparator using temporal order */ 
    bool before( const boost::weak_ptr<PursuitGNode> &lhs, const boost::weak_ptr<PursuitGNode> &rhs) ; 
  
    /* output stream for PursuitGNode */
    std::ostream& operator<<(std::ostream& out, PursuitGNode const &rhs);

  }
}

#endif /* LGL_PURSUIT_GRAPH_NODE_HPP */