Graph.hpp

Go to the documentation of this file.

#ifndef Graph_H
#define Graph_H

#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/Utils/BaseGraph.hpp>

namespace OA {

//--------------------------------------------------------------------
//--------------------------------------------------------------------
class Graph : public BaseGraph {
public:
  class Edge;
  //------------------------------------------------------------------
  class Node : public BaseGraph::Node {
  public:
    Node () 
        { incident_edges = new std::list<OA_ptr<Edge> >; }
    virtual ~Node () { incident_edges->clear(); }
  private:
    OA_ptr<std::list<OA_ptr<Edge> > >  incident_edges;
    friend class Graph;
    friend class Graph::Edge;
  };
  //------------------------------------------------------------------
  class Edge : public BaseGraph::Edge {
  public:
    Edge (OA_ptr<Node> n1, OA_ptr<Node> n2) : BaseGraph::Edge(n1, n2) {}
    virtual ~Edge () {}
    OA_ptr<Node> node1 () { 
      OA_ptr<BaseGraph::Node> n = n1; // Stupid Sun CC 5.4
      return n.convert<Node>(); 
    }
    OA_ptr<Node> node2 () { 
      OA_ptr<BaseGraph::Node> n = n2; // Stupid Sun CC 5.4
      return n.convert<Node>(); 
    }
    friend class Graph;

    // just doing comparison on ptr val
    bool operator == (BaseGraph::Edge& other) { return this==&other; }
  };
  //------------------------------------------------------------------
  class NodesIterator : public BaseGraph::NodesIterator {
  public:
    NodesIterator (Graph& g) : BaseGraph::NodesIterator(g) {}
    virtual ~NodesIterator () {}
    OA_ptr<Node> current() { OA_ptr<BaseGraph::Node> bnode = (*mIter);
                             return bnode.convert<Node>(); }

  };
  //------------------------------------------------------------------
  class EdgesIterator : public BaseGraph::EdgesIterator {
  public:
    EdgesIterator (Graph& g) : BaseGraph::EdgesIterator(g) {}
    virtual ~EdgesIterator () {}
    OA_ptr<Edge> current() { OA_ptr<BaseGraph::Edge> bedge = (*mIter);
                             return bedge.convert<Edge>(); }

  };

  //------------------------------------------------------------------

  Graph() : BaseGraph() {}
  Graph(OA_ptr<Node> root) : BaseGraph(root) {}
  virtual ~Graph() {}

  virtual void addEdge(OA_ptr<Graph::Edge> e);
  virtual void addNode(OA_ptr<Graph::Node> n);
  virtual void removeEdge(OA_ptr<Graph::Edge> e);
  virtual void removeNode(OA_ptr<Graph::Node> n);

private:
  OA_ptr<BaseGraph::Node> create_DFS_links (OA_ptr<BaseGraph::Node> start_node);
  OA_ptr<BaseGraph::Node> create_BFS_links (OA_ptr<BaseGraph::Node> start_node);
};
//--------------------------------------------------------------------

} // end of OA namespace

#endif