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

class EmptyGraph
{
public:

  class NodeIt {
  public:
    NodeIt() {}   //FIXME
    //NodeIt(const NodeIt &) {} 
    bool operator==(NodeIt n) const {} //FIXME
    bool operator!=(NodeIt n) const {} //FIXME
  };
    
  class EachNodeIt : public NodeIt {
  public:
    EachNodeIt() {} //FIXME
    EachNodeIt(const EmptyGraph &) const {}
    EachNodeIt(const EachNodeIt &) const {} //FIXME
  };
    
  class EdgeIt {
    EdgeIt() {}   //FIXME
    //EdgeIt(const EdgeIt &) {} 
    bool operator==(EdgeIt n) const {} //FIXME
    bool operator!=(EdgeIt n) const {} //FIXME    
  };
  
  class OutEdgeIt : public EdgeIt {
    OutEdgeIt() {}
    OutEdgeIt(const EmptyGraph &, NodeIt) {}
  };

  class InEdgeIt : public EdgeIt {
    InEdgeIt() {}
    InEdgeIt(const EmptyGraph &, NodeIt) {}    
  };
  //  class SymEdgeIt : public EdgeIt {};
  class EachEdgeIt : public EdgeIt {
    EachEdgeIt() {}
    EachEdgeIt(const EmptyGraph &, NodeIt) {}
  };

  EachNodeIt &getFirst(EachNodeIt &) 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 {};

  int id(const NodeIt) const {};
  int id(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() {}

  int nodeNum() {}
  int edgeNum() {}

  template<class T> class NodeMap
  {
  public:
    typedef T ValueType;
    typedef NodeIt KeyType;

    NodeMap(const Graph &G) {}
    NodeMap(const Graph &G, T t) {}

    void set(NodeIt i, T t) {}
    T get(NodeIt i) const {}  //FIXME: Is it necessary
    T &operator[](NodeIt i) {}
    const T &operator[](NodeIt i) const {}

    update() {}
    update(T a) {}   //FIXME: Is it necessary
  };

  template<class T> class EdgeMap
  {
  public:
    typedef T ValueType;
    typedef EdgeIt KeyType;

    EdgeMap(const Graph &G) {}
    EdgeMap(const Graph &G, T t) {}
    
    void set(EdgeIt i, T t) {}
    T get(EdgeIt i) const {}
    T &operator[](EdgeIt i) {}
    
    update() {}
    update(T a) {}   //FIXME: Is it necessary
  };
};


// 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) {}

// }