///\brief Declaration of GraphSkeleturo.

 ///\brief Declaration of GraphConcept.

 #include <invalid.h>

 #include <hugo/invalid.h>

 /// The namespace of HugoLib

   /// @defgroup empty_graph The GraphSkeleturo class

   /// @defgroup empty_graph The GraphConcept class

   class GraphSkeleturo

   class GraphConcept

     GraphSkeleturo() {}

     GraphConcept() { }

     ///Copy consructor.

     /// \brief Copy consructor.

     ///\todo It is not clear, what we expect from a copy constructor.

     /// 

     ///E.g. How to assign the nodes/edges to each other? What about maps?

     /// \todo It is not clear, what we expect from a copy constructor.

     GraphSkeleturo(const GraphSkeleturo &G) {}

     /// E.g. How to assign the nodes/edges to each other? What about maps?

     GraphConcept(const GraphConcept&) { }

     /// The base type of the node iterators.

     /// \brief The base type of the node iterators.

     ///

       Node() {}   //FIXME

       Node() { }   //FIXME

       /// Invalid constructor \& conversion.

       // /// Copy constructor.

       // Node(const Node&) { }

       /// \brief Invalid constructor \& conversion.

       /// 

       Node(const Invalid&) { }

       Node(Invalid) {}

       //Node(const Node &) {}

       Edge() {}   //FIXME

       Edge() { }   //FIXME

       // /// Copy constructor.

       // Edge(const Edge&) { }

       Edge(Invalid) {}

       Edge(const Invalid&) { }

     /// This iterator goes through each edge.

     /// This iterator goes through each edge of a graph.

     /// Its usage is quite simple, for example you can count the number

     /// of edges in a graph \c G of type \c Graph as follows:

     /// \code

     ///int count=0;

     ///for(Graph::EdgeIt e(G);G.valid(e);G.next(e)) count++;

     /// \endcode

     class EdgeIt : public Edge {

     public:

       /// @warning The default constructor sets the iterator

       /// to an undefined value.

       EdgeIt() {}

       /// Initialize the iterator to be invalid

       EdgeIt(Invalid) {}

       EdgeIt(const GraphSkeleturo &) {}

     };

     /// First node of the graph.

     /// \post \c i and the return value will be the first node.

     ///

     NodeIt &first(NodeIt &i) const { return i;}

     /// The first incoming edge.

     InEdgeIt &first(InEdgeIt &i, Node n) const { return i;}

     /// The first outgoing edge.

     OutEdgeIt &first(OutEdgeIt &i, Node n) const { return i;}

     /// Go to the next edge.

     EdgeIt &next(EdgeIt &i) const { return i;}

     /// Gives back the head node of an edge.

     ///Gives back the head node of an edge.

     Node head(const Edge&) const { return INVALID; }

     Node head(Edge) const { return INVALID; }

     /// Gives back the tail node of an edge.

     ///Gives back the tail node of an edge.

     Node tail(const Edge&) const { return INVALID; }

     Node tail(Edge) const { return INVALID; }

     /// Checks if a node iterator is valid

     /// \brief Checks if a node iterator is valid

     /// 

     ///\todo Maybe, it would be better if iterator converted to

     /// \todo Maybe, it would be better if iterator converted to

     ///bool directly, as Jacint prefers.

     /// bool directly, as Jacint prefers.

     bool valid(const Node&) const { return true;}

     bool valid(const Node&) const { return true; }

     /// Checks if an edge iterator is valid

     /// \brief Checks if an edge iterator is valid

     /// 

     ///\todo Maybe, it would be better if iterator converted to

     /// \todo Maybe, it would be better if iterator converted to

     ///bool directly, as Jacint prefers.

     /// bool directly, as Jacint prefers.

     bool valid(const Edge&) const { return true;}

     bool valid(const Edge&) const { return true; }

     ///Gives back the \e id of a node.

     /// \brief Gives back the \e id of a node.

     /// 

     ///\warning Not all graph structures provide this feature.

     /// \warning Not all graph structures provide this feature.

     ///

     ///

     int id(const Node&) const { return 0;}

     int id(const Node&) const { return 0; }

     ///Gives back the \e id of an edge.

     /// \brief Gives back the \e id of an edge.

     ///

     ///\warning Not all graph structures provide this feature.

     /// \warning Not all graph structures provide this feature.

     ///

     ///

     int id(const Edge&) const { return 0;}

     int id(const Edge&) const { return 0; }

     ///Add a new node to the graph.

     /// \brief Add a new node to the graph.

     ///

     ///

     Node addNode() { return INVALID; }

     Node addNode() { return INVALID;}

     /// \brief Add a new edge to the graph.

     ///Add a new edge to the graph.

     ///

     /// Add a new edge to the graph with tail node \c tail

     ///Add a new edge to the graph with tail node \c tail

     /// and head node \c head.

     ///and head node \c head.

     /// \return the new edge.

     ///\return the new edge.

     Edge addEdge(const Node& tail, const Node& head) { return INVALID; }

     Edge addEdge(Node tail, Node head) { return INVALID;}

     /// Resets the graph.

     /// \brief Resets the graph.

     /// 

     void clear() {}

     /// \todo What happens with the maps?

     void clear() { }

     ///Read/write/reference map of the nodes to type \c T.

     /// Read/write/reference map of the nodes to type \c T.

     ///Read/write/reference map of the nodes to type \c T.

     /// \sa MemoryMapSkeleturo

     /// Read/write/reference map of the nodes to type \c T.

     /// \sa MemoryMapConcept

       NodeMap(const GraphSkeleturo &G) {}

       NodeMap(const GraphConcept& g) { }

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

       NodeMap(const GraphConcept& g, T t) { }

       template<typename TT> NodeMap(const NodeMap<TT> &m) {}

       template<typename TT> NodeMap(const NodeMap<TT>& m) { }

       void update() {}

       void update() { }

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

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

     ///Read/write/reference map of the edges to type \c T.

     /// Read/write/reference map of the edges to type \c T.

     ///It behaves exactly in the same way as \ref NodeMap.

     /// It behaves exactly in the same way as \ref NodeMap.

     /// \sa MemoryMapSkeleturo

     /// \sa MemoryMapConcept

       EdgeMap(const GraphSkeleturo &G) {}

       EdgeMap(const GraphConcept& g) {}

       EdgeMap(const GraphSkeleturo &G, T t) {}

       EdgeMap(const GraphConcept& g, T t) {}

       void update() {}

       void update() { }

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

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

     };

     };

   };

   };

   /// An empty eraseable graph class.

   /// \brief Node-iterable graph concept.

   /// This class provides all the common features of an \e eraseable graph

   ///

   /// structure,

   /// A graph class which provides functions to 

   /// however completely without implementations and real data structures

   /// iterate on its nodes.

   /// behind the interface.

   class NodeIterableGraphConcept : virtual public GraphConcept

   /// All graph algorithms should compile with this class, but it will not

   {

   /// run properly, of course.

   public:

   ///

   /// \todo This blabla could be replaced by a sepatate description about

     /// \brief This iterator goes trough the nodes of the graph.

   /// Skeleturos.

     ///

   ///

     /// This iterator goes trough the \e nodes of the graph.

   /// It can be used for checking the interface compatibility,

     /// Its usage is quite simple, for example you can count the number

   /// or it can serve as a skeleton of a new graph structure.

     /// of nodes in graph \c g of type \c Graph as follows.

   /// 

     /// \code

   /// Also, you will find here the full documentation of a certain graph

     /// int count=0;

   /// feature, the documentation of a real graph imlementation

     /// for(Graph::NodeIt n(g); g.valid(n); g.next(n)) ++count;

   /// like @ref ListGraph or

     /// \endcode

   /// @ref SmartGraph will just refer to this structure.

     class NodeIt : public Node {

   class EraseableGraphSkeleturo : public GraphSkeleturo

     public:

   {

       /// @warning The default constructor sets the iterator.

   public:

       /// to an undefined value.

     /// Deletes a node.

       NodeIt() { }

     void erase(Node n) {}

       // /// Copy constructor

     /// Deletes an edge.

       //NodeIt(const NodeIt& n) { }

     void erase(Edge e) {}

       /// Initialize the iterator to be invalid.

       NodeIt(const Invalid&) { }

     /// Defalult constructor.

       /// \brief This constructor sets the iterator to first node.

     GraphSkeleturo() {}

       ///

     ///Copy consructor.

       /// This constructor set the iterator to the first 

     GraphSkeleturo(const GraphSkeleturo &G) {}

       /// node of the graph \c g.

   };

       ///

       ///@param g the graph

   /// An empty out-edge-iterable graph class.

       NodeIt(const GraphConcept& g) { }

     };

   /// An empty graph class which provides a function to 

     /// The first node.

     NodeIt &first(NodeIt &i) const { return i; }

     /// Go to the next node.

     NodeIt &next(NodeIt &i) const { return i; }

   };

   /// \brief Edge-iterable graph concept.

   ///

   /// A graph class which provides functions to 

   /// iterate on its edges.

   class EdgeIterableGraphConcept : virtual public GraphConcept

   {

   public:

     /// \brief This iterator goes trough the edges of the graph.

     ///

     /// This iterator goes trough the \e edges of the graph.

     /// Its usage is quite simple, for example you can count the number

     /// of edges in graph \c g of type \c Graph as follows.

     /// \code

     /// int count=0;

     /// for(Graph::EdgeIt e(g); g.valid(e); g.next(e)) ++count;

     /// \endcode

     class EdgeIt : public Edge {

     public:

       /// @warning The default constructor sets the iterator.

       /// to an undefined value.

       EdgeIt() { }

       // /// Copy constructor

       // EdgeIt(const EdgeIt&) { }

       /// Initialize the iterator to be invalid.

       EdgeIt(const Invalid&) { }

       /// \brief This constructor sets the iterator to first edge.

       ///

       /// This constructor set the iterator to the first 

       /// edge of the graph \c g.

       ///

       ///@param g the graph

       EdgeIt(const GraphConcept& g) { }

     };

     /// The first edge.

     EdgeIt &first(EdgeIt &i) const { return i; }

     /// Go to the next edge.

     EdgeIt &next(EdgeIt &i) const { return i; }

   };

   /// \brief Out-edge-iterable graph concept.

   ///

   /// A graph class which provides functions to 

   class OutEdgeIterableGraphSkeleturo : public GraphSkeleturo

   class OutEdgeIterableGraphConcept : virtual public GraphConcept

   {

   {

   public:

   public:

     /// This iterator goes trough the outgoing edges of a node.

     /// \brief This iterator goes trough the outgoing edges of a node.

     ///

     /// in graph \c G of type \c Graph as follows.

     /// in graph \c g of type \c Graph as follows.

     ///int count=0;

     /// int count=0;

     ///for(Graph::OutEdgeIt e(G,n); G.valid(e); G.next(e)) ++count;

     /// for(Graph::OutEdgeIt e(g, n); g.valid(e); g.next(e)) ++count;

       /// @warning The default constructor sets the iterator

       /// @warning The default constructor sets the iterator.

       /// to an undefined value.

       /// to an undefined value.

       OutEdgeIt() {}

       OutEdgeIt() { }

       /// Initialize the iterator to be invalid

       /// Initialize the iterator to be invalid.

       OutEdgeIt(Invalid) {}

       OutEdgeIt(const Invalid&) { }

       /// This constructor sets the iterator to first outgoing edge.

       /// \brief This constructor sets the iterator to first outgoing edge.

       ///

       ///@param G the graph

       ///@param g the graph

       OutEdgeIt(const GraphSkeleturo & G, Node n) {}

       OutEdgeIt(const GraphConcept& g, const Node& n) { }

     };

     };

   };

     /// The first outgoing edge.

   /// An empty in-edge-iterable graph class.

     OutEdgeIt &first(OutEdgeIt &i, const Node& n) const { return i; }

   /// An empty graph class which provides a function to 

     /// Go to the next outgoing edge.

     OutEdgeIt &next(OutEdgeIt &i) const { return i; }

     Node aNode(const OutEdgeIt&) const { return Node(); }

     Node bNode(const OutEdgeIt&) const { return Node(); }

   };

   /// \brief In-edge-iterable graph concept.

   ///

   /// A Graph class which provides a function to 

   class InEdgeIterableGraphSkeleturo : public GraphSkeleturo

   class InEdgeIterableGraphConcept : virtual public GraphConcept

   {

   {

   public:

   public:

     /// This iterator goes trough the incoming edges of a node.

     /// \brief This iterator goes trough the incoming edges of a node.

     /// 

     /// in graph \c G of type \c Graph as follows.

     /// in graph \c g of type \c Graph as follows.

     ///int count=0;

     /// int count=0;

     ///for(Graph::InEdgeIt e(G,n); G.valid(e); G.next(e)) ++count;

     /// for(Graph::InEdgeIt e(g, n); g.valid(e); g.next(e)) ++count;

       InEdgeIt() {}

       InEdgeIt() { }

       InEdgeIt(Invalid) {}

       InEdgeIt(const Invalid&) { }

       /// This constructor sets the iterator to first incomig edge.

       /// \brief This constructor sets the iterator to first incomig edge.

       /// 

       ///@param G the graph

       ///@param g the graph

       InEdgeIt(const GraphSkeleturo & G, Node n) {}

       InEdgeIt(const GraphConcept& g, const Node& n) { }

     };

     };

   };

     /// The first incoming edge.

     InEdgeIt &first(InEdgeIt &i, const Node& n) const { return i; }

   /// An empty node-eraseable graph class.

     /// Go to the next incoming edge.

   /// An empty graph class which provides a function to 

     InEdgeIt &next(InEdgeIt &i) const { return i; }

     Node aNode(const InEdgeIt&) const { return Node(); }

     Node bNode(const InEdgeIt&) const { return Node(); }

   };

   /// \brief Node-eraseable graph concept.

   ///

   /// A graph class which provides a function to 

   class NodeEraseableGraphSkeleturo : public GraphSkeleturo

   class NodeEraseableGraphConcept : virtual public GraphConcept

     void erase(Node n) {}

     void erase(const Node& n) { }

   };

   };

   /// An empty edge-eraseable graph class.

   /// \brief Edge-eraseable graph concept.

   /// An empty graph class which provides a function to delete any 

   /// 

   /// A graph class which provides a function to delete any 

   class EdgeEraseableGraphSkeleturo : public GraphSkeleturo

   class EdgeEraseableGraphConcept : virtual public GraphConcept

     void erase(Edge n) {}

     void erase(const Edge& n) { }

   };

   };

   /// An empty graph class which provides a function to get the number of its nodes.

   /// \brief An empty graph class which provides a function to 

   /// get the number of its nodes.

   /// 

   class NodeCountingGraphSkeleturo : public GraphSkeleturo

   class NodeCountingGraphConcept : virtual public GraphConcept

     int nodeNum() const { return 0;}

     int nodeNum() const { return 0; }

   };

   };

   /// An empty graph class which provides a function to get the number of its edges.

   /// \brief An empty graph class which provides a function to 

   /// get the number of its edges.

   /// 

   class EdgeCountingGraphSkeleturo : public GraphSkeleturo

   class EdgeCountingGraphConcept : virtual public GraphConcept

     int edgeNum() const { return 0;}

     int edgeNum() const { return 0; }

   };

   class FullFeatureGraphConcept : public NodeIterableGraphConcept,

 				  public EdgeIterableGraphConcept, 

 				  public OutEdgeIterableGraphConcept, 

 				  public InEdgeIterableGraphConcept {

   public:

     FullFeatureGraphConcept() { }

 // class EmptyBipGraph : public Graph Skeleturo

 // class EmptyBipGraph : public Graph Concept