Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 61)
+++ lemon/concepts/digraph.h	(revision 57)
@@ -349,26 +349,4 @@
       Node source(Arc) const { return INVALID; }
 
-      /// \brief Returns the ID of the node.
-      int id(Node) const { return -1; } 
-
-      /// \brief Returns the ID of the arc.
-      int id(Arc) const { return -1; } 
-
-      /// \brief Returns the node with the given ID.
-      ///
-      /// \pre The argument should be a valid node ID in the graph.
-      Node nodeFromId(int) const { return INVALID; } 
-
-      /// \brief Returns the arc with the given ID.
-      ///
-      /// \pre The argument should be a valid arc ID in the graph.
-      Arc arcFromId(int) const { return INVALID; } 
-
-      /// \brief Returns an upper bound on the node IDs.
-      int maxNodeId() const { return -1; } 
-
-      /// \brief Returns an upper bound on the arc IDs.
-      int maxArcId() const { return -1; } 
-
       void first(Node&) const {}
       void next(Node&) const {}
@@ -383,14 +361,4 @@
       void firstOut(Arc&, const Node&) const {}
       void nextOut(Arc&) const {}
-
-      // The second parameter is dummy.
-      Node fromId(int, Node) const { return INVALID; }
-      // The second parameter is dummy.
-      Arc fromId(int, Arc) const { return INVALID; }
-
-      // Dummy parameter.
-      int maxId(Node) const { return -1; } 
-      // Dummy parameter.
-      int maxId(Arc) const { return -1; } 
 
       /// \brief The base node of the iterator.
@@ -472,5 +440,4 @@
         void constraints() {
           checkConcept<IterableDigraphComponent<>, Digraph>();
-	  checkConcept<IDableDigraphComponent<>, Digraph>();
           checkConcept<MappableDigraphComponent<>, Digraph>();
         }
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 78)
+++ lemon/concepts/graph.h	(revision 57)
@@ -64,5 +64,5 @@
     /// the EdgeMap to map values for the edges. The InArcIt and
     /// OutArcIt iterates on the same edges but with opposite
-    /// direction. The IncEdgeIt iterates also on the same edges
+    /// direction. The IncArcIt iterates also on the same edges
     /// as the OutArcIt and InArcIt but it is not convertible to Arc just
     /// to Edge.  
@@ -271,39 +271,39 @@
       ///\code
       /// int count=0;
-      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
+      /// for(Graph::IncArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
-      class IncEdgeIt : public Edge {
-      public:
-        /// Default constructor
-
-        /// @warning The default constructor sets the iterator
-        /// to an undefined value.
-        IncEdgeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
-        /// Initialize the iterator to be invalid.
-
-        /// Initialize the iterator to be invalid.
-        ///
-        IncEdgeIt(Invalid) { }
+      class IncArcIt : public Edge {
+      public:
+        /// Default constructor
+
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
+        IncArcIt() { }
+        /// Copy constructor.
+
+        /// Copy constructor.
+        ///
+        IncArcIt(const IncArcIt& e) : Edge(e) { }
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
+        IncArcIt(Invalid) { }
         /// This constructor sets the iterator to first incident arc.
     
         /// This constructor set the iterator to the first incident arc of
         /// the node.
-        IncEdgeIt(const Graph&, const Node&) { }
-        /// Edge -> IncEdgeIt conversion
+        IncArcIt(const Graph&, const Node&) { }
+        /// Edge -> IncArcIt conversion
 
         /// Sets the iterator to the value of the trivial iterator \c e.
         /// This feature necessitates that each time we 
         /// iterate the arc-set, the iteration order is the same.
-        IncEdgeIt(const Graph&, const Edge&) { }
+        IncArcIt(const Graph&, const Edge&) { }
         /// Next incident arc
 
         /// Assign the iterator to the next incident arc
 	/// of the corresponding node.
-        IncEdgeIt& operator++() { return *this; }
+        IncArcIt& operator++() { return *this; }
       };
 
@@ -625,37 +625,4 @@
       Node target(Arc) const { return INVALID; }
 
-      /// \brief Returns the id of the node.
-      int id(Node) const { return -1; } 
-
-      /// \brief Returns the id of the edge.
-      int id(Edge) const { return -1; } 
-
-      /// \brief Returns the id of the arc.
-      int id(Arc) const { return -1; } 
-
-      /// \brief Returns the node with the given id.
-      ///
-      /// \pre The argument should be a valid node id in the graph.
-      Node nodeFromId(int) const { return INVALID; } 
-
-      /// \brief Returns the edge with the given id.
-      ///
-      /// \pre The argument should be a valid edge id in the graph.
-      Edge edgeFromId(int) const { return INVALID; } 
-
-      /// \brief Returns the arc with the given id.
-      ///
-      /// \pre The argument should be a valid arc id in the graph.
-      Arc arcFromId(int) const { return INVALID; } 
-
-      /// \brief Returns an upper bound on the node IDs.
-      int maxNodeId() const { return -1; } 
-
-      /// \brief Returns an upper bound on the edge IDs.
-      int maxEdgeId() const { return -1; } 
-
-      /// \brief Returns an upper bound on the arc IDs.
-      int maxArcId() const { return -1; } 
-
       void first(Node&) const {}
       void next(Node&) const {}
@@ -673,20 +640,7 @@
       void nextIn(Arc&) const {}
 
+
       void firstInc(Edge &, bool &, const Node &) const {}
       void nextInc(Edge &, bool &) const {}
-
-      // The second parameter is dummy.
-      Node fromId(int, Node) const { return INVALID; }
-      // The second parameter is dummy.
-      Edge fromId(int, Edge) const { return INVALID; }
-      // The second parameter is dummy.
-      Arc fromId(int, Arc) const { return INVALID; }
-
-      // Dummy parameter.
-      int maxId(Node) const { return -1; } 
-      // Dummy parameter.
-      int maxId(Edge) const { return -1; } 
-      // Dummy parameter.
-      int maxId(Arc) const { return -1; } 
 
       /// \brief Base node of the iterator
@@ -721,5 +675,5 @@
       ///
       /// Returns the base node of the iterator
-      Node baseNode(IncEdgeIt) const {
+      Node baseNode(IncArcIt) const {
 	return INVALID;
       }
@@ -728,5 +682,5 @@
       ///
       /// Returns the running node of the iterator
-      Node runningNode(IncEdgeIt) const {
+      Node runningNode(IncArcIt) const {
 	return INVALID;
       }
@@ -736,5 +690,4 @@
 	void constraints() {
 	  checkConcept<IterableGraphComponent<>, Graph>();
-	  checkConcept<IDableGraphComponent<>, Graph>();
 	  checkConcept<MappableGraphComponent<>, Graph>();
 	}
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 78)
+++ lemon/concepts/graph_components.h	(revision 57)
@@ -829,14 +829,14 @@
       /// This iterator goes trough the incident arcs of a certain
       /// node of a graph.
-      typedef GraphIncIt<Graph, Edge, Node, 'u'> IncEdgeIt;
+      typedef GraphIncIt<Graph, Edge, Node, 'u'> IncArcIt;
       /// \brief The base node of the iterator.
       ///
       /// Gives back the base node of the iterator.
-      Node baseNode(const IncEdgeIt&) const { return INVALID; }
+      Node baseNode(const IncArcIt&) const { return INVALID; }
 
       /// \brief The running node of the iterator.
       ///
       /// Gives back the running node of the iterator.
-      Node runningNode(const IncEdgeIt&) const { return INVALID; }
+      Node runningNode(const IncArcIt&) const { return INVALID; }
 
       /// @}
@@ -866,8 +866,8 @@
               typename _Graph::EdgeIt >();
             checkConcept<GraphIncIt<_Graph, typename _Graph::Edge, 
-              typename _Graph::Node, 'u'>, typename _Graph::IncEdgeIt>();
+              typename _Graph::Node, 'u'>, typename _Graph::IncArcIt>();
             
             typename _Graph::Node n;
-            typename _Graph::IncEdgeIt ueit(INVALID);
+            typename _Graph::IncArcIt ueit(INVALID);
             n = graph.baseNode(ueit);
             n = graph.runningNode(ueit);
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 94)
+++ lemon/concepts/maps.h	(revision 51)
@@ -30,5 +30,5 @@
 
   namespace concepts {
-
+  
     /// \addtogroup concept
     /// @{
@@ -43,21 +43,61 @@
     public:
       /// The key type of the map.
-      typedef K Key;
-      /// The value type of the map. (The type of objects associated with the keys).
-      typedef T Value;
-
-      /// Returns the value associated with the given key.
-      Value operator[](const Key &) const { 
-        return *static_cast<Value *>(0);
-      }
+      typedef K Key;    
+      /// The value type of the map. (The type of objects associated with the keys).
+      typedef T Value;
+
+      /// Returns the value associated with a key.
+
+      /// Returns the value associated with a key.
+      /// \bug Value shouldn't need to be default constructible.
+      ///
+      Value operator[](const Key &) const {return Value();}
 
       template<typename _ReadMap>
       struct Constraints {
+
 	void constraints() {
 	  Value val = m[key];
 	  val = m[key];
-	  typename _ReadMap::Value own_val = m[own_key];
-	  own_val = m[own_key];
-
+	  typename _ReadMap::Value own_val = m[own_key]; 
+	  own_val = m[own_key]; 
+
+	  ignore_unused_variable_warning(val);
+	  ignore_unused_variable_warning(own_val);
+	  ignore_unused_variable_warning(key);
+	}
+	Key& key;
+	typename _ReadMap::Key& own_key;
+	_ReadMap& m;
+      };
+      
+    };
+
+
+    /// Writable map concept
+    
+    /// Writable map concept.
+    ///
+    template<typename K, typename T>
+    class WriteMap
+    {
+    public:
+      /// The key type of the map.
+      typedef K Key;    
+      /// The value type of the map. (The type of objects associated with the keys).
+      typedef T Value;
+
+      /// Sets the value associated with a key.
+      void set(const Key &,const Value &) {}
+
+      ///Default constructor
+      WriteMap() {}
+
+      template <typename _WriteMap>
+      struct Constraints {
+	void constraints() {
+	  // No constraints for constructor.
+	  m.set(key, val);
+	  m.set(own_key, own_val);
 	  ignore_unused_variable_warning(key);
 	  ignore_unused_variable_warning(val);
@@ -65,52 +105,16 @@
 	  ignore_unused_variable_warning(own_val);
 	}
-	const Key& key;
-	const typename _ReadMap::Key& own_key;
-	const _ReadMap& m;
-      };
-
-    };
-
-
-    /// Writable map concept
-
-    /// Writable map concept.
-    ///
-    template<typename K, typename T>
-    class WriteMap
-    {
-    public:
-      /// The key type of the map.
-      typedef K Key;
-      /// The value type of the map. (The type of objects associated with the keys).
-      typedef T Value;
-
-      /// Sets the value associated with the given key.
-      void set(const Key &, const Value &) {}
-
-      /// Default constructor.
-      WriteMap() {}
-
-      template <typename _WriteMap>
-      struct Constraints {
-	void constraints() {
-	  m.set(key, val);
-	  m.set(own_key, own_val);
-
-	  ignore_unused_variable_warning(key);
-	  ignore_unused_variable_warning(val);
-	  ignore_unused_variable_warning(own_key);
-	  ignore_unused_variable_warning(own_val);
-	}
-	const Key& key;
-	const Value& val;
-	const typename _WriteMap::Key& own_key;
-	const typename _WriteMap::Value own_val;
+
+	Value& val;
+	typename _WriteMap::Value own_val;
+	Key& key;
+	typename _WriteMap::Key& own_key;
 	_WriteMap& m;
+
       };
     };
 
     /// Read/writable map concept
-
+    
     /// Read/writable map concept.
     ///
@@ -121,15 +125,12 @@
     public:
       /// The key type of the map.
-      typedef K Key;
-      /// The value type of the map. (The type of objects associated with the keys).
-      typedef T Value;
-
-      /// Returns the value associated with the given key.
-      Value operator[](const Key &) const { 
-        return *static_cast<Value *>(0);
-      }
-
-      /// Sets the value associated with the given key.
-      void set(const Key &, const Value &) {}
+      typedef K Key;    
+      /// The value type of the map. (The type of objects associated with the keys).
+      typedef T Value;
+
+      /// Returns the value associated with a key.
+      Value operator[](const Key &) const {return Value();}
+      /// Sets the value associated with a key.
+      void set(const Key & ,const Value &) {}
 
       template<typename _ReadWriteMap>
@@ -141,10 +142,11 @@
       };
     };
-
-
+  
+  
     /// Dereferable map concept
-
+    
     /// Dereferable map concept.
     ///
+    /// \todo Rethink this concept.
     template<typename K, typename T, typename R, typename CR>
     class ReferenceMap : public ReadWriteMap<K,T>
@@ -154,5 +156,5 @@
       typedef True ReferenceMapTag;
       /// The key type of the map.
-      typedef K Key;
+      typedef K Key;    
       /// The value type of the map. (The type of objects associated with the keys).
       typedef T Value;
@@ -162,42 +164,36 @@
       typedef CR ConstReference;
 
-    public:
-
-      /// Returns a reference to the value associated with the given key.
-      Reference operator[](const Key &) { 
-        return *static_cast<Value *>(0);
-      }
-
-      /// Returns a const reference to the value associated with the given key.
-      ConstReference operator[](const Key &) const {
-        return *static_cast<Value *>(0);
-      }
-
-      /// Sets the value associated with the given key.
+    protected:
+      Value tmp;
+    public:
+
+      ///Returns a reference to the value associated with a key.
+      Reference operator[](const Key &) { return tmp; }
+      ///Returns a const reference to the value associated with a key.
+      ConstReference operator[](const Key &) const { return tmp; }
+      /// Sets the value associated with a key.
       void set(const Key &k,const Value &t) { operator[](k)=t; }
 
       template<typename _ReferenceMap>
-      struct Constraints {
-	void constraints() {
-	  checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
+      struct ReferenceMapConcept {
+
+	void constraints() {
+	  checkConcept<ReadWriteMap, _ReferenceMap >();
+	  m[key] = val;
+	  val  = m[key];
+	  m[key] = ref;
 	  ref = m[key];
-	  m[key] = val;
-	  m[key] = ref;
-	  m[key] = cref;
-	  own_ref = m[own_key];
 	  m[own_key] = own_val;
+	  own_val  = m[own_key];
 	  m[own_key] = own_ref;
-	  m[own_key] = own_cref;
-	  m[key] = m[own_key];
-	  m[own_key] = m[key];
-	}
-	const Key& key;
+	  own_ref = m[own_key];	  	  
+	}
+
+	typename _ReferenceMap::Key& own_key;
+	typename _ReferenceMap::Value& own_val;
+	typename _ReferenceMap::Reference& own_ref;
+	Key& key;
 	Value& val;
-	Reference ref;
-	ConstReference cref;
-	const typename _ReferenceMap::Key& own_key;
-	typename _ReferenceMap::Value& own_val;
-	typename _ReferenceMap::Reference own_ref;
-	typename _ReferenceMap::ConstReference own_cref;
+	Reference& ref;
 	_ReferenceMap& m;
       };
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 96)
+++ lemon/concepts/path.h	(revision 96)
@@ -0,0 +1,307 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+///\ingroup concept
+///\file
+///\brief Classes for representing paths in digraphs.
+///
+///\todo Iterators have obsolete style
+
+#ifndef LEMON_CONCEPT_PATH_H
+#define LEMON_CONCEPT_PATH_H
+
+#include <lemon/bits/invalid.h>
+#include <lemon/bits/utility.h>
+#include <lemon/concept_check.h>
+
+namespace lemon {
+  namespace concepts {
+
+    /// \addtogroup concept
+    /// @{
+
+    /// \brief A skeleton structure for representing directed paths in
+    /// a digraph.
+    ///
+    /// A skeleton structure for representing directed paths in a
+    /// digraph.  
+    /// \param _Digraph The digraph type in which the path is.
+    ///
+    /// In a sense, the path can be treated as a list of arcs. The
+    /// lemon path type stores just this list. As a consequence it
+    /// cannot enumerate the nodes in the path and the zero length
+    /// paths cannot store the source.
+    ///
+    template <typename _Digraph>
+    class Path {
+    public:
+
+      /// Type of the underlying digraph.
+      typedef _Digraph Digraph;
+      /// Arc type of the underlying digraph.
+      typedef typename Digraph::Arc Arc;
+
+      class ArcIt;
+
+      /// \brief Default constructor
+      Path() {}
+
+      /// \brief Template constructor
+      template <typename CPath>
+      Path(const CPath& cpath) {}
+
+      /// \brief Template assigment
+      template <typename CPath>
+      Path& operator=(const CPath& cpath) {}
+
+      /// Length of the path ie. the number of arcs in the path.
+      int length() const { return 0;}
+
+      /// Returns whether the path is empty.
+      bool empty() const { return true;}
+
+      /// Resets the path to an empty path.
+      void clear() {}
+
+      /// \brief Lemon style iterator for path arcs
+      ///
+      /// This class is used to iterate on the arcs of the paths.
+      class ArcIt {
+      public:
+	/// Default constructor
+	ArcIt() {}
+	/// Invalid constructor
+	ArcIt(Invalid) {}
+	/// Constructor for first arc
+	ArcIt(const Path &) {}
+
+        /// Conversion to Arc
+	operator Arc() const { return INVALID; }
+
+	/// Next arc
+	ArcIt& operator++() {return *this;}
+
+	/// Comparison operator
+	bool operator==(const ArcIt&) const {return true;}
+	/// Comparison operator
+	bool operator!=(const ArcIt&) const {return true;}
+ 	/// Comparison operator
+ 	bool operator<(const ArcIt&) const {return false;}
+
+      };
+
+      template <typename _Path>
+      struct Constraints {
+        void constraints() {
+          Path<Digraph> pc;
+          _Path p, pp(pc);
+          int l = p.length();
+          int e = p.empty();
+          p.clear();
+
+          p = pc;
+
+          typename _Path::ArcIt id, ii(INVALID), i(p);
+
+          ++i;
+          typename Digraph::Arc ed = i;
+
+          e = (i == ii);
+          e = (i != ii);
+          e = (i < ii);
+
+          ignore_unused_variable_warning(l);
+          ignore_unused_variable_warning(pp);
+          ignore_unused_variable_warning(e);
+          ignore_unused_variable_warning(id);
+          ignore_unused_variable_warning(ii);
+          ignore_unused_variable_warning(ed);
+        }
+      };
+
+    };
+
+    namespace _path_bits {
+      
+      template <typename _Digraph, typename _Path, typename RevPathTag = void>
+      struct PathDumperConstraints {
+        void constraints() {
+          int l = p.length();
+          int e = p.empty();
+
+          typename _Path::ArcIt id, i(p);
+
+          ++i;
+          typename _Digraph::Arc ed = i;
+
+          e = (i == INVALID);
+          e = (i != INVALID);
+
+          ignore_unused_variable_warning(l);
+          ignore_unused_variable_warning(e);
+          ignore_unused_variable_warning(id);
+          ignore_unused_variable_warning(ed);
+        }
+        _Path& p;
+      };
+
+      template <typename _Digraph, typename _Path>
+      struct PathDumperConstraints<
+        _Digraph, _Path, 
+        typename enable_if<typename _Path::RevPathTag, void>::type
+      > {
+        void constraints() {
+          int l = p.length();
+          int e = p.empty();
+
+          typename _Path::RevArcIt id, i(p);
+
+          ++i;
+          typename _Digraph::Arc ed = i;
+
+          e = (i == INVALID);
+          e = (i != INVALID);
+
+          ignore_unused_variable_warning(l);
+          ignore_unused_variable_warning(e);
+          ignore_unused_variable_warning(id);
+          ignore_unused_variable_warning(ed);
+        }
+        _Path& p;
+      };
+    
+    }
+
+
+    /// \brief A skeleton structure for path dumpers.
+    ///
+    /// A skeleton structure for path dumpers. The path dumpers are
+    /// the generalization of the paths. The path dumpers can
+    /// enumerate the arcs of the path wheter in forward or in
+    /// backward order.  In most time these classes are not used
+    /// directly rather it used to assign a dumped class to a real
+    /// path type.
+    ///
+    /// The main purpose of this concept is that the shortest path
+    /// algorithms can enumerate easily the arcs in reverse order.
+    /// If we would like to give back a real path from these
+    /// algorithms then we should create a temporarly path object. In
+    /// Lemon such algorithms gives back a path dumper what can
+    /// assigned to a real path and the dumpers can be implemented as
+    /// an adaptor class to the predecessor map.
+
+    /// \param _Digraph  The digraph type in which the path is.
+    ///
+    /// The paths can be constructed from any path type by a
+    /// template constructor or a template assignment operator.
+    /// 
+    template <typename _Digraph>
+    class PathDumper {
+    public:
+
+      /// Type of the underlying digraph.
+      typedef _Digraph Digraph;
+      /// Arc type of the underlying digraph.
+      typedef typename Digraph::Arc Arc;
+
+      /// Length of the path ie. the number of arcs in the path.
+      int length() const { return 0;}
+
+      /// Returns whether the path is empty.
+      bool empty() const { return true;}
+
+      /// \brief Forward or reverse dumping
+      ///
+      /// If the RevPathTag is defined and true then reverse dumping
+      /// is provided in the path dumper. In this case instead of the
+      /// ArcIt the RevArcIt iterator should be implemented in the
+      /// dumper.
+      typedef False RevPathTag;
+
+      /// \brief Lemon style iterator for path arcs
+      ///
+      /// This class is used to iterate on the arcs of the paths.
+      class ArcIt {
+      public:
+	/// Default constructor
+	ArcIt() {}
+	/// Invalid constructor
+	ArcIt(Invalid) {}
+	/// Constructor for first arc
+	ArcIt(const PathDumper&) {}
+
+        /// Conversion to Arc
+	operator Arc() const { return INVALID; }
+
+	/// Next arc
+	ArcIt& operator++() {return *this;}
+
+	/// Comparison operator
+	bool operator==(const ArcIt&) const {return true;}
+	/// Comparison operator
+	bool operator!=(const ArcIt&) const {return true;}
+ 	/// Comparison operator
+ 	bool operator<(const ArcIt&) const {return false;}
+
+      };
+
+      /// \brief Lemon style iterator for path arcs
+      ///
+      /// This class is used to iterate on the arcs of the paths in
+      /// reverse direction.
+      class RevArcIt {
+      public:
+	/// Default constructor
+	RevArcIt() {}
+	/// Invalid constructor
+	RevArcIt(Invalid) {}
+	/// Constructor for first arc
+	RevArcIt(const PathDumper &) {}
+
+        /// Conversion to Arc
+	operator Arc() const { return INVALID; }
+
+	/// Next arc
+	RevArcIt& operator++() {return *this;}
+
+	/// Comparison operator
+	bool operator==(const RevArcIt&) const {return true;}
+	/// Comparison operator
+	bool operator!=(const RevArcIt&) const {return true;}
+ 	/// Comparison operator
+ 	bool operator<(const RevArcIt&) const {return false;}
+
+      };
+
+      template <typename _Path>
+      struct Constraints {
+        void constraints() {
+          function_requires<_path_bits::
+            PathDumperConstraints<Digraph, _Path> >();
+        }
+      };
+
+    };
+
+
+    ///@}
+  }
+
+} // namespace lemon
+
+#endif // LEMON_CONCEPT_PATH_H
