/* -*- C++ -*-

 *

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

 *

 * Copyright (C) 2003-2007

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

 *

 */

#ifndef LEMON_BITS_PRED_MAP_PATH_H

#define LEMON_BITS_PRED_MAP_PATH_H

namespace lemon {

  template <typename _Graph, typename _PredMap>

  class PredMapPath {

  public:

    typedef True RevPathTag;

    typedef _Graph Graph;

    typedef typename Graph::Edge Edge;

    typedef _PredMap PredMap;

    PredMapPath(const Graph& _graph, const PredMap& _predMap,

                typename Graph::Node _target)

      : graph(_graph), predMap(_predMap), target(_target) {}

    int length() const {

      int len = 0;

      typename Graph::Node node = target;

      typename Graph::Edge edge;

      while ((edge = predMap[node]) != INVALID) {

        node = graph.source(edge);

        ++len;

      }

      return len;

    }

    bool empty() const {

      return predMap[target] != INVALID;

    }

    class RevEdgeIt {

    public:

      RevEdgeIt() {}

      RevEdgeIt(Invalid) : path(0), current(INVALID) {}

      RevEdgeIt(const PredMapPath& _path) 

        : path(&_path), current(_path.target) {

        if (path->predMap[current] == INVALID) current = INVALID;

      }

      operator const typename Graph::Edge() const {

        return path->predMap[current];

      }

      RevEdgeIt& operator++() {

        current = path->graph.source(path->predMap[current]);

        if (path->predMap[current] == INVALID) current = INVALID;

        return *this;

      }

      bool operator==(const RevEdgeIt& e) const { 

        return current == e.current; 

      }

      bool operator!=(const RevEdgeIt& e) const {

        return current != e.current; 

      }

      bool operator<(const RevEdgeIt& e) const { 

        return current < e.current; 

      }

    private:

      const PredMapPath* path;

      typename Graph::Node current;

    };

  private:

    const Graph& graph;

    const PredMap& predMap;

    typename Graph::Node target;

  };

  template <typename _Graph, typename _PredMatrixMap>

  class PredMatrixMapPath {

  public:

    typedef True RevPathTag;

    typedef _Graph Graph;

    typedef typename Graph::Edge Edge;

    typedef _PredMatrixMap PredMatrixMap;

    PredMatrixMapPath(const Graph& _graph, 

                      const PredMatrixMap& _predMatrixMap,

                      typename Graph::Node _source, 

                      typename Graph::Node _target)

      : graph(_graph), predMatrixMap(_predMatrixMap), 

        source(_source), target(_target) {}

    int length() const {

      int len = 0;

      typename Graph::Node node = target;

      typename Graph::Edge edge;

      while ((edge = predMatrixMap(source, node)) != INVALID) {

        node = graph.source(edge);

        ++len;

      }

      return len;

    }

    bool empty() const {

      return source != target;

    }

    class RevEdgeIt {

    public:

      RevEdgeIt() {}

      RevEdgeIt(Invalid) : path(0), current(INVALID) {}

      RevEdgeIt(const PredMatrixMapPath& _path) 

        : path(&_path), current(_path.target) {

        if (path->predMatrixMap(path->source, current) == INVALID) 

          current = INVALID;

      }

      operator const typename Graph::Edge() const {

        return path->predMatrixMap(path->source, current);

      }

      RevEdgeIt& operator++() {

        current = 

          path->graph.source(path->predMatrixMap(path->source, current));

        if (path->predMatrixMap(path->source, current) == INVALID) 

          current = INVALID;

        return *this;

      }

      bool operator==(const RevEdgeIt& e) const { 

        return current == e.current; 

      }

      bool operator!=(const RevEdgeIt& e) const {

        return current != e.current; 

      }

      bool operator<(const RevEdgeIt& e) const { 

        return current < e.current; 

      }

    private:

      const PredMatrixMapPath* path;

      typename Graph::Node current;

    };

  private:

    const Graph& graph;

    const PredMatrixMap& predMatrixMap;

    typename Graph::Node source;

    typename Graph::Node target;

  };

}

#endif