// -*-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 &);

   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 &);

   NodeIt head(const EdgeIt &);

   NodeIt tail(const EdgeIt &);

   NodeIt aNode(const InEdgeIt &);

   NodeIt aNode(const OutEdgeIt &);

   NodeIt aNode(const SymEdgeIt &);

   NodeIt bNode(const InEdgeIt &);

   NodeIt bNode(const OutEdgeIt &);

   NodeIt bNode(const SymEdgeIt &);

   bool valid(const NodeIt &);

   bool valid(const EdgeIt &);

   void setInvalid(const NodeIt &);

   void setInvalid(const EdgeIt &);

   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);

   };

 };