source: lemon-0.x/src/work/alpar/emptygraph.h @ 52:a4fc9c5dcee5

// -*-mode: c++; -*-

template <class N, class E>
class Graph
{
public:
  typedef E EdgeType;
  typedef N NodeType;
  
  class EdgeIt {};
  
  class InEdgeIt : public EdgeIt
  class OutEdgeIt : public EdgeIt {};
  class SymEdgeIt : public EdgeIt {};
  class EachEdgeIt : public EdgeIt {};

  class NodeIt {};
    
  NodeIt &getFirst(NodeIt &);
  InEdgeIt &getFirst(InEdgeIt &,const NodeIt &);
  OutEdgeIt &getFirst(OutEdgeIt &,const NodeIt &);
  SymEdgeIt &getFirst(SymEdgeIt &,const NodeIt &);
  EachEdgeIt &getFirst(EachEdgeIt &);

  NodeIt next(const NodeIt &);
  InEdgeIt next(const InEdgeIt &);
  OutEdgeIt next(const OutEdgeIt &);
  SymEdgeIt next(const SymEdgeIt &);
  EachEdgeIt next(const EachEdgeIt &);

  NodeIt &goNext(const NodeIt &);
  InEdgeIt &goNext(const InEdgeIt &);
  OutEdgeIt &goNext(const OutEdgeIt &);
  SymEdgeIt &goNext(const SymEdgeIt &);
  EachEdgeIt &goNext(const EachEdgeIt &);

  bool valid(const NodeIt &n);
  bool valid(const EdgeIt &n);

  void setInvalid(const NodeIt &n);
  void setInvalid(const EdgeIt &n);
  
  NodeIt addNode();
  EdgeIt addEdge(const NodeIt from,const NodeIt to);
    
  void delete(NodeIt n);
  void delete(EdgeIt e);

  void clean();

  template<class T> class NodeMap
  {
  public:
    typedef T value_type;
    void set(const NodeIt i, const T &t);
    T get(const NodeIt i) const;
    T operator[](const NodeIt i);
      
    NodeMap(const Graph &G);
  };

  template<class T> class EdgeMap
  {
  public:
    typedef T value_type;
    void set(const EdgeIt i, const T &t);
    T get(const EdgeIt i) const;
    T operator[](const EdgeIt i);
      
    EdgeMap(const Graph &G);
  };
};