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

// }