Node n0;

 	UndirEdge ue;

     /// Class describing the concept of Undirected Graphs.

     /// This class describes the common interface of all Undirected

     /// Graphs.

     ///

     /// As all concept describing classes it provides only interface

     /// without any sensible implementation. So any algorithm for

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

     /// run properly, of couse.

     ///

     /// In LEMON undirected graphs also fulfill the concept of directed

     /// graphs (\ref lemon::concept::Graph "Graph Concept"). For

     /// explanation of this and more see also the page \ref undir_graphs,

     /// a tutorial about undirected graphs.

       /// Type describing a node in the graph

       typedef GraphNode Node;

       /// Type describing an undirected edge

       typedef GraphItem<'u'> UndirEdge;

       /// Type describing an UndirEdge with direction

 #ifndef DOXYGEN

       typedef UndirGraphEdge<UndirEdge> Edge;

 #else

       typedef UndirGraphEdge Edge;

 #endif

       /// Iterator type which iterates over all nodes

 #ifndef DOXYGEN

       typedef GraphIterator<UndirGraph, Node> NodeIt;

 #else

       typedef GraphIterator NodeIt;

 #endif

       /// Iterator type which iterates over all undirected edges

 #ifndef DOXYGEN

       typedef GraphIterator<UndirGraph, UndirEdge> UndirEdgeIt;

 #else

       typedef GraphIterator UndirEdgeIt;

 #endif

       /// Iterator type which iterates over all directed edges.

       /// Iterator type which iterates over all edges (each undirected

       /// edge occurs twice with both directions.

 #ifndef DOXYGEN

       typedef GraphIterator<UndirGraph, Edge> EdgeIt;

 #else

       typedef GraphIterator EdgeIt;

 #endif

       /// Iterator of undirected edges incident to a node

 #ifndef DOXYGEN

       typedef GraphIncIterator<UndirGraph, UndirEdge, 'u'> IncEdgeIt;

 #else

       typedef GraphIncIterator IncEdgeIt;

 #endif

       /// Iterator of edges incoming to a node

 #ifndef DOXYGEN

       typedef GraphIncIterator<UndirGraph, Edge, 'i'> InEdgeIt;

 #else

       typedef GraphIncIterator InEdgeIt;

 #endif

       /// Iterator of edges outgoing from a node

 #ifndef DOXYGEN

       typedef GraphIncIterator<UndirGraph, Edge, 'o'> OutEdgeIt;

 #else

       typedef GraphIncIterator OutEdgeIt;

 #endif

       /// NodeMap template

 #ifdef DOXYGEN

       typedef GraphMap NodeMap<T>;

 #endif

       /// UndirEdgeMap template

 #ifdef DOXYGEN

       typedef GraphMap UndirEdgeMap<T>;

 #endif

       /// EdgeMap template

 #ifdef DOXYGEN

       typedef GraphMap EdgeMap<T>;

 #endif

       template <typename T>

       class NodeMap : public GraphMap<UndirGraph, Node, T> {

 	typedef GraphMap<UndirGraph, Node, T> Parent;

       public:

 	explicit NodeMap(const UndirGraph &g) : Parent(g) {}

 	NodeMap(const UndirGraph &g, T t) : Parent(g, t) {}

       };

       template <typename T>

       class UndirEdgeMap : public GraphMap<UndirGraph, UndirEdge, T> {

 	typedef GraphMap<UndirGraph, UndirEdge, T> Parent;

       public:

 	explicit UndirEdgeMap(const UndirGraph &g) : Parent(g) {}

 	UndirEdgeMap(const UndirGraph &g, T t) : Parent(g, t) {}

       };

       template <typename T>

       class EdgeMap : public GraphMap<UndirGraph, Edge, T> {

 	typedef GraphMap<UndirGraph, Edge, T> Parent;

       public:

 	explicit EdgeMap(const UndirGraph &g) : Parent(g) {}

 	EdgeMap(const UndirGraph &g, T t) : Parent(g, t) {}

       };

       /// Is the Edge oriented "forward"?

       /// Returns whether the given directed edge is same orientation as

       /// the corresponding undirected edge.

       ///

       /// \todo "What does the direction of an undirected edge mean?"

       bool forward(Edge) const { return true; }

       /// Opposite node on an edge

       /// \return the opposite of the given Node on the given Edge

       ///

       /// \todo What should we do if given Node and Edge are not incident?

       Node oppositeNode(Node, UndirEdge) const { return INVALID; }

       /// First node of the undirected edge.

       /// \return the first node of the given UndirEdge.

       ///

       /// Naturally undirectected edges don't have direction and thus

       /// don't have source and target node. But we use these two methods

       /// to query the two endnodes of the edge. The direction of the edge

       /// which arises this way is called the inherent direction of the

       /// undirected edge, and is used to define the "forward" direction

       /// of the directed versions of the edges.

       /// \sa forward

       Node source(UndirEdge) const { return INVALID; }

       /// Second node of the undirected edge.

       Node target(UndirEdge) const { return INVALID; }

       /// Source node of the directed edge.

       Node source(Edge) const { return INVALID; }

       /// Target node of the directed edge.

       Node target(Edge) const { return INVALID; }

       /// First node of the graph

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void first(Node&) const {}

       /// Next node of the graph

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void next(Node&) const {}

       /// First undirected edge of the graph

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void first(UndirEdge&) const {}

       /// Next undirected edge of the graph

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void next(UndirEdge&) const {}

       /// First directed edge of the graph

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void first(Edge&) const {}

       /// Next directed edge of the graph

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void next(Edge&) const {}

       /// First outgoing edge from a given node

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void firstOut(Edge&, Node) const {}

       /// Next outgoing edge to a node

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void nextOut(Edge&) const {}

       /// First incoming edge to a given node

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void firstIn(Edge&, Node) const {}

       /// Next incoming edge to a node

       /// \note This method is part of so called \ref

       /// developpers_interface "Developpers' interface", so it shouldn't

       /// be used in an end-user program.

       void nextIn(Edge&) const {}

     /// @}