edge.hpp

#ifndef EDGE_HPP
#define EDGE_HPP

#include "API/Roadmap/node.hpp"
#include "API/ConfigSpace/localpath.hpp"

class Graph;

#ifndef _ROADMAP_H
struct edge;
#endif

class Edge
{
public:
  //contructor and destructor
        Edge(Graph* G, unsigned int i, unsigned j);
        
        Edge(Graph* G, edge* E);
        
        
        //    Edge(cpp_Graph* G, p3d_edge* E);
        
        Edge(Graph* G, Node* N1, Node* N2, bool compute_length, double& length, bool compute_cost, double& cost );
        
        Edge(Node * source, Node * target, localPathPtr_t path);
        
        ~Edge();
        
  //Accessors
        edge* getEdgeStruct();
        
        Graph* getGraph();
        
        Robot* getRobot();
        
        double longueur();
        
        Node* getSource();
        
        Node* getTarget();
        
        Edge * getOppositeEdge() const { return oppositeEdge; }

        void setOppositeEdge(Edge * edge) { oppositeEdge = edge; }

        double cost();

        void setCost(double cost);

        std::tr1::shared_ptr<LocalPath> getLocalPath();
  
  
        void setLocalPath(std::tr1::shared_ptr<LocalPath> pathPtr);

        //--------------------------------------
        // BGL
        BGL_Edge getDescriptor();

        void setDescriptor(const BGL_Edge& E) {
                m_is_BGL_Descriptor_Valid = true;
                m_BGL_Descriptor = E;
        }

        void unSetDescriptor() {
                m_is_BGL_Descriptor_Valid = false;
        }

private:
        edge* m_Edge;

        bool m_is_cost_computed;

        Node* m_Source;
        Node* m_Target;

        Edge * oppositeEdge;

        Graph* m_Graph;
        Robot* m_Robot;

        double m_Long;


    BGL_Edge m_BGL_Descriptor;
    bool m_is_BGL_Descriptor_Valid;

    std::tr1::shared_ptr<LocalPath> m_path;
    bool m_is_LocalPath_Computed;



};

#endif