checkConcept<UndirGraphEdge<Graph>, Edge>();

 	  //checkConcept<UndirGraphEdge<Graph>, Edge>();

     class UndirGraph {

     class UndirGraph : public StaticGraph {

       /// Type describing a node in the graph

       /// The base type of the undirected edge iterators.

       typedef GraphNode Node;

       /// The base type of the undirected edge iterators.

       /// Type describing an undirected edge

       ///

       typedef GraphItem<'u'> UndirEdge;

       class UndirEdge {

       /// Type describing an UndirEdge with direction

 #ifndef DOXYGEN

       typedef UndirGraphEdge<UndirGraph> 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;

         /// Default constructor

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

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

         /// @warning The default constructor sets the iterator

       };

         /// to an undefined value.

         UndirEdge() { }

       template <typename T>

         /// Copy constructor.

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

 	typedef GraphMap<UndirGraph, UndirEdge, T> Parent;

         /// Copy constructor.

         ///

         UndirEdge(const UndirEdge&) { }

         /// Edge -> UndirEdge conversion

         /// Edge -> UndirEdge conversion

         ///

         UndirEdge(const Edge&) { }

         /// Initialize the iterator to be invalid.

         /// Initialize the iterator to be invalid.

         ///

         UndirEdge(Invalid) { }

         /// Equality operator

         /// Two iterators are equal if and only if they point to the

         /// same object or both are invalid.

         bool operator==(UndirEdge) const { return true; }

         /// Inequality operator

         /// \sa operator==(UndirEdge n)

         ///

         bool operator!=(UndirEdge) const { return true; }

 	///\e

 	///\todo Do we need this?

 	///

 	bool operator<(const UndirEdge &that) const { return true; }

       };

       /// This iterator goes through each undirected edge.

       /// This iterator goes through each undirected 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::UndirEdgeIt e(g); e!=INVALID; ++e) ++count;

       /// \endcode

       class UndirEdgeIt : public UndirEdge {

         /// Default constructor

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

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

         /// @warning The default constructor sets the iterator

       };

         /// to an undefined value.

         UndirEdgeIt() { }

       template <typename T>

         /// Copy constructor.

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

 	typedef GraphMap<UndirGraph, Edge, T> Parent;

         /// Copy constructor.

         ///

         UndirEdgeIt(const UndirEdgeIt& e) : UndirEdge(e) { }

         /// Initialize the iterator to be invalid.

         /// Initialize the iterator to be invalid.

         ///

         UndirEdgeIt(Invalid) { }

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

         /// This constructor sets the iterator to the first edge of \c g.

         ///@param g the graph

         UndirEdgeIt(const UndirGraph&) { }

         /// UndirEdge -> UndirEdgeIt conversion

         /// Sets the iterator to the value of the trivial iterator \c e.

         /// This feature necessitates that each time we 

         /// iterate the edge-set, the iteration order is the same.

         UndirEdgeIt(const UndirGraph&, const UndirEdge&) { } 

         ///Next edge

         /// Assign the iterator to the next edge.

         UndirEdgeIt& operator++() { return *this; }

       };

       /// This iterator goes trough the incident undirected edges of a node.

       /// This iterator goes trough the incident undirected edges

       /// of a certain node

       /// of a graph.

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

       /// degree (i.e. count the number

       /// of incident edges of a node \c n

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

       /// \code

       /// int count=0;

       /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;

       /// \endcode

       class IncEdgeIt : public UndirEdge {

         /// Default constructor

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

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

         /// @warning The default constructor sets the iterator

         /// to an undefined value.

         IncEdgeIt() { }

         /// Copy constructor.

         /// Copy constructor.

         ///

         IncEdgeIt(const IncEdgeIt& e) : UndirEdge(e) { }

         /// Initialize the iterator to be invalid.

         /// Initialize the iterator to be invalid.

         ///

         IncEdgeIt(Invalid) { }

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

         /// This constructor set the iterator to the first incident edge of

         /// the node.

         ///@param n the node

         ///@param g the graph

         IncEdgeIt(const UndirGraph&, const Node&) { }

         /// UndirEdge -> IncEdgeIt conversion

         /// Sets the iterator to the value of the trivial iterator \c e.

         /// This feature necessitates that each time we 

         /// iterate the edge-set, the iteration order is the same.

         IncEdgeIt(const UndirGraph&, const UndirEdge&) { }

         /// Next incident edge

         /// Assign the iterator to the next incident edge

 	/// of the corresponding node.

         IncEdgeIt& operator++() { return *this; }

       };

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

       /// Reference map of the edges to type \c T.

       /// \sa Reference

       /// \warning Making maps that can handle bool type (UndirEdgeMap<bool>)

       /// needs some extra attention!

       template<class T> 

       class UndirEdgeMap : public ReadWriteMap<UndirEdge,T>

       {

       public:

         ///\e

         UndirEdgeMap(const UndirGraph&) { }

         ///\e

         UndirEdgeMap(const UndirGraph&, T) { }

         ///Copy constructor

         UndirEdgeMap(const UndirEdgeMap& em) : ReadWriteMap<UndirEdge,T>(em) { }

         ///Assignment operator

         UndirEdgeMap &operator=(const UndirEdgeMap&) { return *this; }

         // \todo fix this concept