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

class EmptyGraph
{
public:

  class EdgeIt {};
  
  class InEdgeIt : public EdgeIt {};
  class OutEdgeIt : public EdgeIt {};
  class SymEdgeIt : public EdgeIt {};
  class EachEdgeIt : public EdgeIt {};

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

  NodeIt getNext(NodeIt) const {}
  InEdgeIt getNext(InEdgeIt) const {}
  OutEdgeIt getNext(OutEdgeIt) const {}
  SymEdgeIt getNext(SymEdgeIt) const {}
  EachEdgeIt getNext(EachEdgeIt) const {}

  NodeIt &next(NodeIt &) const {}
  InEdgeIt &next(InEdgeIt &) const {}
  OutEdgeIt &next(OutEdgeIt &) const {}
  SymEdgeIt &next(SymEdgeIt &) const {}
  EachEdgeIt &next(EachEdgeIt &) const {}

  NodeIt head(EdgeIt) const {}
  NodeIt tail(EdgeIt) const {}
  
  NodeIt aNode(InEdgeIt) const {}
  NodeIt aNode(OutEdgeIt) const {}
  NodeIt aNode(SymEdgeIt) const {}

  NodeIt bNode(InEdgeIt) const {}
  NodeIt bNode(OutEdgeIt) const {}
  NodeIt bNode(SymEdgeIt) const {}

  //bool valid(const NodeIt) const {};
  //bool valid(const EdgeIt) const {};

  //void setInvalid(NodeIt &) const {};
  //void setInvalid(EdgeIt &) const {};
  
  NodeIt addNode() {}
  EdgeIt addEdge(NodeIt tail, NodeIt head) {}
    
  void erase(NodeIt n) {}
  void erase(EdgeIt e) {}

  void clear() {}

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

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

class EmptyBipGraph : public EmptyGraph
{
  class ANodeIt {};
  class BNodeIt {};

  ANodeIt &next(ANodeIt &) {}
  BNodeIt &next(BNodeIt &) {}

  ANodeIt &getFirst(ANodeIt &) const {}
  BNodeIt &getFirst(BNodeIt &) const {}

  enum NodeClass { A = 0, B = 1 };
  NodeClass getClass(NodeIt n) {}

}