/// \brief A skeleton structure for representing directed paths in

     //! \brief A skeleton structure for representing directed paths in a graph.

     /// a graph.

     //!

     ///

     //! A skeleton structure for representing directed paths in a graph.

     /// A skeleton structure for representing directed paths in a

     //! \param _Graph The graph type in which the path is.

     /// graph.  

     //!

     /// \param _Graph The graph type in which the path is.

     //! In a sense, the path can be treated as a graph, for it has \c NodeIt

     ///

     //! and \c EdgeIt with the same usage. These types converts to the \c Node

     /// In a sense, the path can be treated as a list of edges. The

     //! and \c Edge of the original graph.

     /// lemon path type stores just this list. As a consequence it

     template<typename _Graph>

     /// cannot enumerate the nodes in the path and the zero length

     /// paths cannot store the source.

     ///

     template <typename _Graph>

       /// Node type of the underlying graph.

       typedef typename Graph::Node Node;

       class NodeIt;

       /// \param _g The graph in which the path is.

       /// \brief Default constructor

       ///

       Path() {}

       Path(const Graph &_g) {

 	ignore_unused_variable_warning(_g);

       /// \brief Template constructor

       }

       template <typename CPath>

       Path(const CPath& cpath) {}

       /// \brief Template assigment

       template <typename CPath>

       Path& operator=(const CPath& cpath) {}

       int length() const {return 0;}

       int length() const { return 0;}

       /// \brief Starting point of the path.

       /// \brief Lemon style iterator for path edges

       /// Starting point of the path.

       /// This class is used to iterate on the edges of the paths.

       /// Returns INVALID if the path is empty.

       Node target() const {return INVALID;}

       /// \brief End point of the path.

       ///

       /// End point of the path.

       /// Returns INVALID if the path is empty.

       Node source() const {return INVALID;}

       /// \brief The target of an edge.

       ///

       /// Returns node iterator pointing to the target node of the

       /// given edge iterator.

       NodeIt target(const EdgeIt&) const {return INVALID;}

       /// \brief The source of an edge.

       ///

       /// Returns node iterator pointing to the source node of the

       /// given edge iterator.

       NodeIt source(const EdgeIt&) const {return INVALID;}

       /// \brief Iterator class to iterate on the nodes of the paths

       ///

       /// This class is used to iterate on the nodes of the paths

       ///

       /// Of course it converts to Graph::Node.

       class NodeIt {

       public:

 	/// Default constructor

 	NodeIt() {}

 	/// Invalid constructor

 	NodeIt(Invalid) {}

 	/// Constructor with starting point

 	NodeIt(const Path &) {}

 	///Conversion to Graph::Node

 	operator Node() const { return INVALID; }

 	/// Next node

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

 	/// Comparison operator

 	bool operator==(const NodeIt&) const {return true;}

 	/// Comparison operator

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

  	/// Comparison operator

  	bool operator<(const NodeIt&) const {return false;}

       };

       /// \brief Iterator class to iterate on the edges of the paths

       ///

       /// This class is used to iterate on the edges of the paths

       ///

       /// Of course it converts to Graph::Edge

 	/// Constructor with starting point

 	/// Constructor for first edge

 	void constraints() {

         void constraints() {

           typedef typename _Path::Node Node;

           Path<Graph> pc;

           typedef typename _Path::NodeIt NodeIt;

           _Path p, pp(pc);

           typedef typename Graph::Node GraphNode;

           int l = p.length();

           int e = p.empty();

           typedef typename _Path::Edge Edge;

           p.clear();

           typedef typename _Path::EdgeIt EdgeIt;

           typedef typename Graph::Edge GraphEdge;

           p = pc;

           typedef typename _Path::Builder Builder;

           typename _Path::EdgeIt id, ii(INVALID), i(p);

           path = _Path(graph);

           ++i;

           typename Graph::Edge ed = i;

           bool b = cpath.empty();

           int l = cpath.length();

           e = (i == ii);

           e = (i != ii);

           Node gn;

           e = (i < ii);

           Edge ge;

           gn = cpath.source();

           gn = cpath.target();

           NodeIt nit;

           EdgeIt eit(INVALID);

           nit = path.source(eit);

           nit = path.target(eit);

           nit = NodeIt();

           nit = NodeIt(cpath);

           nit = INVALID;

           gn = nit;

           ++nit;

           b = nit == nit;

           b = nit != nit;

           b = nit < nit;

           eit = EdgeIt();

           eit = EdgeIt(cpath);

           eit = INVALID;

           ge = eit;

           ++eit;

           b = eit == eit;

           b = eit != eit;

           b = eit < eit;

           size_t st = 0;

           Builder builder(path); 

           builder.setStartNode(gn);

           builder.pushFront(ge);

           builder.pushBack(ge);

           builder.commit();

           builder.reserveFront(st);

           builder.reserveBack(st);

           ignore_unused_variable_warning(b);

           ignore_unused_variable_warning(pp);

 	}

           ignore_unused_variable_warning(e);

           ignore_unused_variable_warning(id);

         const Graph& graph;

           ignore_unused_variable_warning(ii);

         const _Path& cpath;

           ignore_unused_variable_warning(ed);

         _Path& path;

         }

   ///@}

     namespace _path_bits {

       template <typename _Graph, typename _Path, typename RevPathTag = void>

       struct PathDumperConstraints {

         void constraints() {

           int l = p.length();

           int e = p.empty();

           typename _Path::EdgeIt id, ii(INVALID), i(p);

           ++i;

           typename _Graph::Edge ed = i;

           e = (i == ii);

           e = (i != ii);

           e = (i < ii);

           ignore_unused_variable_warning(l);

           ignore_unused_variable_warning(e);

           ignore_unused_variable_warning(id);

           ignore_unused_variable_warning(ii);

           ignore_unused_variable_warning(ed);

         }

         _Path& p;

       };

       template <typename _Graph, typename _Path>

       struct PathDumperConstraints<

         _Graph, _Path, 

         typename enable_if<typename _Path::RevPathTag, void>::type

       > {

         void constraints() {

           int l = p.length();

           int e = p.empty();

           typename _Path::RevIt id, ii(INVALID), i(p);

           ++i;

           typename _Graph::Edge ed = i;

           e = (i == ii);

           e = (i != ii);

           e = (i < ii);

           ignore_unused_variable_warning(l);

           ignore_unused_variable_warning(e);

           ignore_unused_variable_warning(id);

           ignore_unused_variable_warning(ii);

           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 edges 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 edges 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 _Graph  The graph 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 _Graph>

     class PathDumper {

     public:

       /// Type of the underlying graph.

       typedef _Graph Graph;

       /// Edge type of the underlying graph.

       typedef typename Graph::Edge Edge;

       /// Length of the path ie. the number of edges 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 proxy. In this case instead of the

       /// EdgeIt the RevIt iterator should be implemented in the

       /// proxy.

       typedef False RevPathTag;

       /// \brief Lemon style iterator for path edges

       ///

       /// This class is used to iterate on the edges of the paths.

       class EdgeIt {

       public:

 	/// Default constructor

 	EdgeIt() {}

 	/// Invalid constructor

 	EdgeIt(Invalid) {}

 	/// Constructor for first edge

 	EdgeIt(const PathDumper&) {}

         /// Conversion to Edge

 	operator Edge() const { return INVALID; }

 	/// Next edge

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

 	/// Comparison operator

 	bool operator==(const EdgeIt&) const {return true;}

 	/// Comparison operator

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

  	/// Comparison operator

  	bool operator<(const EdgeIt&) const {return false;}

       };

       /// \brief Lemon style iterator for path edges

       ///

       /// This class is used to iterate on the edges of the paths in

       /// reverse direction.

       class RevIt {

       public:

 	/// Default constructor

 	RevIt() {}

 	/// Invalid constructor

 	RevIt(Invalid) {}

 	/// Constructor for first edge

 	RevIt(const PathDumper &) {}

         /// Conversion to Edge

 	operator Edge() const { return INVALID; }

 	/// Next edge

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

 	/// Comparison operator

 	bool operator==(const RevIt&) const {return true;}

 	/// Comparison operator

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

  	/// Comparison operator

  	bool operator<(const RevIt&) const {return false;}

       };

       template <typename _Path>

       struct Constraints {

         void constraints() {

           function_requires<_path_bits::

             PathDumperConstraints<Graph, _Path> >();

         }

       };

     };

     ///@}