RhodeCode

      tpath.first = tpath.last = 0;

    }

    /// \brief Splice a path to the front of the current path.

    ///

    /// It splices \c tpath before the current path and \c tpath

    /// becomes empty. The time complexity of this function

    /// is O(1).

    void spliceFront(ListPath& tpath) {

      if (first) {

        if (tpath.first) {

          first->prev = tpath.last;

          tpath.last->next = first;

          first = tpath.first;

        }

      } else {

        first = tpath.first;

        last = tpath.last;

      }

      tpath.first = tpath.last = 0;

    }

    /// \brief Splice a path into the current path.

    ///

    /// It splices the \c tpath into the current path before the

    /// position of \c it iterator and \c tpath becomes empty. The

    /// time complexity of this function is O(1). If the \c it is

    /// \c INVALID then it will splice behind the current path.

    void splice(ArcIt it, ListPath& tpath) {

      if (it.node) {

        if (tpath.first) {

          tpath.first->prev = it.node->prev;

          if (it.node->prev) {

            it.node->prev->next = tpath.first;

          } else {

            first = tpath.first;

          }

          it.node->prev = tpath.last;

          tpath.last->next = it.node;

        }

      } else {

        if (first) {

          if (tpath.first) {

            last->next = tpath.first;

            tpath.first->prev = last;

            last = tpath.last;

          }

        } else {

          first = tpath.first;

          last = tpath.last;

        }

      }

      tpath.first = tpath.last = 0;

    }

    /// \brief Split the current path.

    ///

    /// It splits the current path into two parts. The part before

    /// the iterator \c it will remain in the current path and the part

    /// starting with

    /// \c it will put into \c tpath. If \c tpath have arcs

    /// before the operation they are removed first.  The time

    /// complexity of this function is O(1) plus the the time of emtying

    /// \c tpath. If \c it is \c INVALID then it just clears \c tpath

    void split(ArcIt it, ListPath& tpath) {

      tpath.clear();

      if (it.node) {

        tpath.first = it.node;

        tpath.last = last;

        if (it.node->prev) {

          last = it.node->prev;

          last->next = 0;

        } else {

          first = last = 0;

        }

        it.node->prev = 0;

      }

    }

    typedef True BuildTag;

    template <typename CPath>

    void build(const CPath& path) {

      for (typename CPath::ArcIt it(path); it != INVALID; ++it) {

        addBack(it);

      }

    }

    template <typename CPath>

    void buildRev(const CPath& path) {

      for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {

        addFront(it);

      }

    }

  };

  /// \brief A structure for representing directed paths in a digraph.

  ///

  /// A structure for representing directed path in a digraph.

  /// \tparam _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 source node of

  /// a zero length path is undefined.

  ///

  /// This implementation is completly static, i.e. it can be copy constucted

  /// or copy assigned from another path, but otherwise it cannot be

  /// modified.

  ///

  /// Being the the most memory efficient path type in LEMON,

  /// it is intented to be

  /// used when you want to store a large number of paths.

  template <typename _Digraph>

  class StaticPath {

  public:

    typedef _Digraph Digraph;

    typedef typename Digraph::Arc Arc;

    /// \brief Default constructor

    ///

    /// Default constructor

    StaticPath() : len(0), arcs(0) {}

    /// \brief Template copy constructor

    ///

    /// This path can be initialized from any other path type.

    template <typename CPath>

    StaticPath(const CPath& cpath) : arcs(0) {

      copyPath(*this, cpath);

    }

    /// \brief Destructor of the path

    ///

    /// Destructor of the path

    ~StaticPath() {

      if (arcs) delete[] arcs;

    }

    /// \brief Template copy assignment

    ///

    /// This path can be made equal to any other path type. It simply

    /// makes a copy of the given path.

    template <typename CPath>

    StaticPath& operator=(const CPath& cpath) {

      copyPath(*this, cpath);

      return *this;

    }

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

    ///

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

    ///

    /// Of course it converts to Digraph::Arc

    class ArcIt {

      friend class StaticPath;

    public:

      /// Default constructor

      ArcIt() {}

      /// Invalid constructor

      ArcIt(Invalid) : path(0), idx(-1) {}

      /// Initializate the constructor to the first arc of path

      ArcIt(const StaticPath &_path)

        : path(&_path), idx(_path.empty() ? -1 : 0) {}

    private:

      /// Constructor with starting point

      ArcIt(const StaticPath &_path, int _idx)

        : idx(_idx), path(&_path) {}

    public:

      ///Conversion to Digraph::Arc

      operator const Arc&() const {

        return path->nth(idx);

      }

      /// Next arc

      ArcIt& operator++() {

        ++idx;

        if (idx >= path->length()) idx = -1;

        return *this;

      }

      /// Comparison operator

      bool operator==(const ArcIt& e) const { return idx==e.idx; }

      /// Comparison operator

      bool operator!=(const ArcIt& e) const { return idx!=e.idx; }

      /// Comparison operator

      bool operator<(const ArcIt& e) const { return idx<e.idx; }

    private:

      const StaticPath *path;

      int idx;

    };

    /// \brief The nth arc.

    ///

    /// \pre n is in the [0..length() - 1] range

    const Arc& nth(int n) const {

      return arcs[n];

    }

    /// \brief The arc iterator pointing to the nth arc.

    ArcIt nthIt(int n) const {

      return ArcIt(*this, n);

    }

    /// \brief The length of the path.

    int length() const { return len; }

    /// \brief Return true when the path is empty.

    int empty() const { return len == 0; }

    /// \brief Erase all arcs in the digraph.

    void clear() {

      len = 0;

      if (arcs) delete[] arcs;

      arcs = 0;

    }

    /// \brief The first arc of the path.

    const Arc& front() const {

      return arcs[0];

    }

    /// \brief The last arc of the path.

    const Arc& back() const {

      return arcs[len - 1];

    }

    typedef True BuildTag;

    template <typename CPath>

    void build(const CPath& path) {

      len = path.length();

      arcs = new Arc[len];

      int index = 0;

      for (typename CPath::ArcIt it(path); it != INVALID; ++it) {

        arcs[index] = it;

        ++index;

      }

    }

    template <typename CPath>

    void buildRev(const CPath& path) {

      len = path.length();

      arcs = new Arc[len];

      int index = len;

      for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {

        --index;

        arcs[index] = it;

      }

    }

  private:

    int len;

    Arc* arcs;

  };

  ///////////////////////////////////////////////////////////////////////

  // Additional utilities

  ///////////////////////////////////////////////////////////////////////

  namespace _path_bits {

    template <typename Path, typename Enable = void>

    struct RevPathTagIndicator {

      static const bool value = false;

    };

    template <typename Path>

    struct RevPathTagIndicator<

      Path,

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

      > {

      static const bool value = true;

    };

    template <typename Path, typename Enable = void>

    struct BuildTagIndicator {

      static const bool value = false;

    };

    template <typename Path>

    struct BuildTagIndicator<

      Path,

      typename enable_if<typename Path::BuildTag, void>::type

    > {

      static const bool value = true;

    };

    template <typename Target, typename Source,

              bool buildEnable = BuildTagIndicator<Target>::value>

    struct PathCopySelectorForward {

      static void copy(Target& target, const Source& source) {

        target.clear();

        for (typename Source::ArcIt it(source); it != INVALID; ++it) {

          target.addBack(it);

        }

      }

    };

    template <typename Target, typename Source>

    struct PathCopySelectorForward<Target, Source, true> {

      static void copy(Target& target, const Source& source) {

        target.clear();

        target.build(source);

      }

    };

    template <typename Target, typename Source,

              bool buildEnable = BuildTagIndicator<Target>::value>

    struct PathCopySelectorBackward {

      static void copy(Target& target, const Source& source) {

        target.clear();

        for (typename Source::RevArcIt it(source); it != INVALID; ++it) {

          target.addFront(it);

        }

      }

    };

    template <typename Target, typename Source>

    struct PathCopySelectorBackward<Target, Source, true> {

      static void copy(Target& target, const Source& source) {

        target.clear();

        target.buildRev(source);

      }

    };

    template <typename Target, typename Source,

              bool revEnable = RevPathTagIndicator<Source>::value>

    struct PathCopySelector {

      static void copy(Target& target, const Source& source) {

        PathCopySelectorForward<Target, Source>::copy(target, source);

      }      

    };

    template <typename Target, typename Source>

    struct PathCopySelector<Target, Source, true> {

      static void copy(Target& target, const Source& source) {

        PathCopySelectorBackward<Target, Source>::copy(target, source);

      }      

    };

  }

  /// \brief Make a copy of a path.

  ///

  ///  This function makes a copy of a path.

  template <typename Target, typename Source>

  void copyPath(Target& target, const Source& source) {

    checkConcept<concepts::PathDumper<typename Source::Digraph>, Source>();

    _path_bits::PathCopySelector<Target, Source>::copy(target, source);

  }

  /// \brief Check the consistency of a path.

  ///

  /// This function checks that the target of each arc is the same

  /// as the source of the next one.

  ///

  template <typename Digraph, typename Path>

  bool checkPath(const Digraph& digraph, const Path& path) {

    typename Path::ArcIt it(path);

    if (it == INVALID) return true;

    typename Digraph::Node node = digraph.target(it);

    ++it;

    while (it != INVALID) {

      if (digraph.source(it) != node) return false;

      node = digraph.target(it);

      ++it;

    }

    return true;

  }

  /// \brief The source of a path

  ///

  template <typename Digraph, typename Path>

  typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) {

  }

  /// \brief The target of a path

  ///

  template <typename Digraph, typename Path>

  typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) {

  }

  /// \brief Class which helps to iterate through the nodes of a path

  ///

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

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

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

  /// cannot have a source node.

  ///

  /// This class implements the node iterator of a path structure. To

  /// provide this feature, the underlying digraph should be passed to

  /// the constructor of the iterator.

  template <typename Path>

  class PathNodeIt {

  private:

    const typename Path::Digraph *_digraph;

    typename Path::ArcIt _it;

    typename Path::Digraph::Node _nd;

  public:

    typedef typename Path::Digraph Digraph;

    typedef typename Digraph::Node Node;

    /// Default constructor

    PathNodeIt() {}

    /// Invalid constructor

    PathNodeIt(Invalid)

      : _digraph(0), _it(INVALID), _nd(INVALID) {}

    /// Constructor

    PathNodeIt(const Digraph& digraph, const Path& path)

      : _digraph(&digraph), _it(path) {

      _nd = (_it != INVALID ? _digraph->source(_it) : INVALID);

    }

    /// Constructor

    PathNodeIt(const Digraph& digraph, const Path& path, const Node& src)

      : _digraph(&digraph), _it(path), _nd(src) {}

    ///Conversion to Digraph::Node

    operator Node() const {

      return _nd;

    }

    /// Next node

    PathNodeIt& operator++() {

      if (_it == INVALID) _nd = INVALID;

      else {

        _nd = _digraph->target(_it);

        ++_it;

      }

      return *this;

    }

    /// Comparison operator

    bool operator==(const PathNodeIt& n) const {

      return _it == n._it && _nd == n._nd;

    }

    /// Comparison operator

    bool operator!=(const PathNodeIt& n) const {

      return _it != n._it || _nd != n._nd;

    }

    /// Comparison operator

    bool operator<(const PathNodeIt& n) const {

      return (_it < n._it && _nd != INVALID);

    }

  };

  ///@}

} // namespace lemon

#endif // LEMON_PATH_H