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

class Graph
{
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 next(NodeIt) const {}
  InEdgeIt next(InEdgeIt) const {}
  OutEdgeIt next(OutEdgeIt) const {}
  SymEdgeIt next(SymEdgeIt) const {}
  EachEdgeIt next(EachEdgeIt) const {}

  NodeIt &goNext(NodeIt &) const {}
  InEdgeIt &goNext(InEdgeIt &) const {}
  OutEdgeIt &goNext(OutEdgeIt &) const {}
  SymEdgeIt &goNext(SymEdgeIt &) const {}
  EachEdgeIt &goNext(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) {}
  };
};