node.hpp

#ifndef NODE_HPP
#define NODE_HPP

#include <tr1/memory>

#include "API/ConfigSpace/configuration.hpp"

#ifndef _ROADMAP_H
struct node;
struct edge;
struct compco;
#endif
 
#include "BGL_Graph.hpp"

#ifndef EDGE_HPP
class Edge;
#endif

#ifndef COMPCO_HPP
class ConnectedComponent;
#endif

class Graph;

class NodeData 
{
  public :
  // Constructor & Destructor
  NodeData();
  virtual ~NodeData();
};

class Node
{       
public:
        
  //Constructor and destructor
        Node();
        Node(Graph* G, std::tr1::shared_ptr<Configuration> C, bool newCompco=true);
        
        Node(Graph* G, node* N);
        
        ~Node();
        
        void deleteNode();
        
        bool operator==(Node& N);
        
  //Accessors
        node* getNodeStruct();
        
        Graph* getGraph();
        
        Robot* getRobot();
        
        confPtr_t getConfiguration();
        
        void activ(bool b);
  
        bool isActiv();
        
        unsigned int getId() const;
        
        void setId(unsigned int id);
        
        Node*& parent() { return m_parent; }
  
        bool& isLeaf() { return m_is_leaf; }
        
        double cost();
        
        double& sumCost(bool recompute=false);
        
        double getTemp();
        
        void setTemp(double t);
        
        double getDist();
  
    double distMultisol(Node *node) const;

    double metric(Node* node);
        
        double dist(Node* N) const;
  
        double dist(confPtr_t q) const;
        
        bool equal(Node* N) const;
        
        bool inSameComponent(Node* N) const;

        bool isLinkable(Node* node, double* dist) const;
  
        bool isLinkableMultisol(Node* node, double* dist) const;
        
        void checkStopByWeight();
        
        unsigned int getNumberOfNodesInCompco() const;
        
        ConnectedComponent* getConnectedComponent() const {
                return m_Compco;
        }
        
        void setConnectedComponent(ConnectedComponent* compco);
        
        void deleteCompco();
        
        bool maximumNumberNodes();
        
        bool connectNodeToCompco(Node* N, double step);
        
        void merge(Node* compco);
        
        bool equalCompco(Node* compco) const;
        
        Node* randomNodeFromComp() const;

        unsigned getNumberOfEdges() { return edges.size(); }

        std::list<Edge *> & getEdges() { return edges; }

        void addEdge(Edge * edge) { edges.push_back(edge); }

        void removeEdge(Edge * edge) { edges.remove(edge); }

        std::vector<Edge *> computeEdges();

        unsigned getNumberOfNeighbors() { return neighbors.size(); }

        std::list<Node *> & getNeighbors() { return neighbors; }

        void addNeighbor(Node * node) { neighbors.push_back(node); }

        void removeNeighbor(Node * node) { neighbors.remove(node); }

        std::vector<Node *> computeNeighbors();

        void setSelectCost(double Cost) { _SelectCost = Cost; }
        double getSelectCost() {        return _SelectCost; }
        void setExpandFailed() {        _nbExpan++; }
        int getNbExpandFailed() { return _nbExpan; }
        std::vector<Node*>& getSortedNodes() { return _SortedNodes; }
        void setSortedNodes(std::vector<Node*>& nodes) {        _SortedNodes = nodes; }

        void print() const;

        //--------------------------------------
        // BGL
        BGL_Vertex getDescriptor();
        void setDescriptor(const BGL_Vertex& V);
        void unSetDescriptor();
        int useful;

    // Used for directed graphs
    bool isForwardConnectedToGoal();
    bool isBackwardConnectedToSource();
    void forwardConnectToGoal();
    void backwardConnectToSource();
    void resetConnections();
    bool isFlaged();
    void flag();
    void unflag();
    void unflagForward();
    void unflagBackward();
    void addForwardNeighbor(Node *N);
    void addBackwardNeighbor(Node *N);
    std::vector<Node*> getBackwardNeighbors();
    std::vector<Node*> getForwardNeighbors();
    void updateForward();
    void updateBackward();
    unsigned int getSccId();
    void setSccId(unsigned int i);

private:
        
        // Old Node structure
        node* m_Node;
        NodeData* _specificNodeData;

        bool m_is_BGL_Descriptor_Valid;
        BGL_Vertex m_BGL_Descriptor;

        Graph* m_Graph;
        Robot* m_Robot;
        ConnectedComponent* m_Compco;

        std::list<Edge *> edges;

        std::list<Node *> neighbors;

        // In tree graphs
        Node* m_parent;
        bool m_is_leaf;

        std::tr1::shared_ptr<Configuration> m_Configuration;
        bool _activ;

        double _SelectCost;
        int _nbExpan;
        std::vector<Node*> _SortedNodes;

        // Used for debug
        bool m_specificNode;

    // Used for directed graphs
    bool _isForwardConnectedToGoal;
    bool _isBackwardConnectedToSource;
    bool _flaged;
    std::vector<Node*> _ForwardNeighbors;
    std::vector<Node*> _BackwardNeighbors;
    // Id of the stongly connected component of the node
    unsigned int _SccId;

};

#endif