/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2006

 * 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 graphs.

///

///\todo Iterators have obsolete style

#ifndef LEMON_CONCEPT_PATH_H

#define LEMON_CONCEPT_PATH_H

#include <lemon/bits/invalid.h>

#include <lemon/concept_check.h>

namespace lemon {

  namespace concept {

    /// \addtogroup concept

    /// @{

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

    //!

    //! A skeleton structure for representing directed paths in a 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

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

    template<typename _Graph>

    class Path {

    public:

      /// Type of the underlying graph.

      typedef _Graph Graph;

      /// Edge type of the underlying graph.

      typedef typename Graph::Edge Edge;

      /// Node type of the underlying graph.

      typedef typename Graph::Node Node;

      class NodeIt;

      class EdgeIt;

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

      ///

      Path(const Graph &_g) {

	ignore_unused_variable_warning(_g);

      }

      /// 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;}

      /// Resets the path to an empty path.

      void clear() {}

      /// \brief Starting point of the path.

      ///

      /// Starting point of the path.

      /// 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

      class EdgeIt {

      public:

	/// Default constructor

	EdgeIt() {}

	/// Invalid constructor

	EdgeIt(Invalid) {}

	/// Constructor with starting point

	EdgeIt(const Path &) {}

	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;}

      };

      friend class Builder;

      /// \brief Class to build paths

      ///

      /// This class is used to fill a path with edges.

      ///

      /// You can push new edges to the front and to the back of the path in

      /// arbitrary order then you should commit these changes to the graph.

      ///

      /// While the builder is active (after the first modifying

      /// operation and until the call of \ref commit()) the

      /// underlining Path is in a "transitional" state (operations on

      /// it have undefined result).

      class Builder {

      public:

        /// Constructor

        /// Constructor

	/// \param _path the path you want to fill in.

	///

	Builder(Path &_path) { ignore_unused_variable_warning(_path); }

	/// Sets the starting node of the path.

	/// Sets the starting node of the path. Edge added to the path

	/// afterwards have to be incident to this node.

	/// You \em must start building an empty path with these functions.

	/// (And you \em must \em not use it later).

	/// \sa pushFront()

	/// \sa pushBack()

	void setStartNode(const Node &) {}

	///Push a new edge to the front of the path

	///Push a new edge to the front of the path.

	///If the path is empty, you \em must call \ref setStartNode() before

	///the first use of \ref pushFront().

	void pushFront(const Edge&) {}

	///Push a new edge to the back of the path

	///Push a new edge to the back of the path.

	///If the path is empty, you \em must call \ref setStartNode() before

	///the first use of \ref pushBack().

	void pushBack(const Edge&) {}

	///Commit the changes to the path.

	///Commit the changes to the path.

        ///

	void commit() {}

	///Reserve (front) storage for the builder in advance.

	///If you know a reasonable upper bound on the number of the edges

	///to add to the front of the path,

	///using this function you may speed up the building.

	void reserveFront(size_t) {}

	///Reserve (back) storage for the builder in advance.

	///If you know a reasonable upper bound on the number of the edges

	///to add to the back of the path,

	///using this function you may speed up the building.

	void reserveBack(size_t) {}

      };

      template <typename _Path>

      struct Constraints {

	void constraints() {

          typedef typename _Path::Node Node;

          typedef typename _Path::NodeIt NodeIt;

          typedef typename Graph::Node GraphNode;

          typedef typename _Path::Edge Edge;

          typedef typename _Path::EdgeIt EdgeIt;

          typedef typename Graph::Edge GraphEdge;

          typedef typename _Path::Builder Builder;

          path = _Path(graph);

          bool b = cpath.empty();

          int l = cpath.length();

          Node gn;

          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(l);

          ignore_unused_variable_warning(b);

	}

        const Graph& graph;

        const _Path& cpath;

        _Path& path;

      };

    };

  ///@}

  }

} // namespace lemon

#endif // LEMON_CONCEPT_PATH_H