/* -*- 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 paths
///\file
///\brief Classes for representing paths in graphs.
///

#ifndef LEMON_PATH_UTILS_H
#define LEMON_PATH_UTILS_H

#include <lemon/concepts/path.h>

namespace lemon {

  namespace _path_bits {

    template <typename Path, typename Enable = void>
    struct RevTagIndicator {
      static const bool value = false;
    };

    template <typename Graph>
    struct RevTagIndicator<
      Graph, 
      typename enable_if<typename Graph::RevTag, void>::type
    > {
      static const bool value = true;
    };

    template <typename Target, typename Source,
              typename BuildEnable = void, typename RevEnable = void>
    struct PathCopySelector {
      static void copy(Target& target, const Source& source) {
        target.clear();
        for (typename Source::EdgeIt it(source); it != INVALID; ++it) {
          target.addBack(it);
        }
      }
    };

    template <typename Target, typename Source, typename BuildEnable>
    struct PathCopySelector<
      Target, Source, BuildEnable, 
      typename enable_if<typename Source::RevPathTag, void>::type> {
      static void copy(Target& target, const Source& source) {
        target.clear();
        for (typename Source::RevEdgeIt it(source); it != INVALID; ++it) {
          target.addFront(it);
        }
      }
    };

    template <typename Target, typename Source, typename RevEnable>
    struct PathCopySelector<
      Target, Source, 
      typename enable_if<typename Target::BuildTag, void>::type, RevEnable> {
      static void copy(Target& target, const Source& source) {
        target.clear();
        target.build(source);
      }
    };

    template <typename Target, typename Source>
    struct PathCopySelector<
      Target, Source, 
      typename enable_if<typename Target::BuildTag, void>::type,
      typename enable_if<typename Source::RevPathTag, void>::type> {
      static void copy(Target& target, const Source& source) {
        target.clear();
        target.buildRev(source);
      }
    };

  }


  /// \brief Make of copy of a path.
  ///
  ///  Make of copy of a path.
  template <typename Target, typename Source>
  void copyPath(Target& target, const Source& source) {
    checkConcept<concepts::PathDumper<typename Source::Graph>, Source>();
    _path_bits::PathCopySelector<Target, Source>::copy(target, source);
  }

  /// \brief Checks the path's consistency.
  ///
  /// Checks that each edge's target is the next's source. 
  /// 
  template <typename Graph, typename Path>
  bool checkPath(const Graph& graph, const Path& path) {
    typename Path::EdgeIt it(path);
    if (it == INVALID) return true;
    typename Graph::Node node = graph.target(it);
    ++it;
    while (it != INVALID) {
      if (graph.source(it) != node) return false;
      node = graph.target(it);
      ++it;
    }
    return true;
  }

  /// \brief Gives back the source of the path
  ///
  /// Gives back the source of the path.
  template <typename Graph, typename Path>
  typename Graph::Node pathSource(const Graph& graph, const Path& path) {
    return graph.source(path.front());
  }

  /// \brief Gives back the target of the path
  ///
  /// Gives back the target of the path.
  template <typename Graph, typename Path>
  typename Graph::Node pathTarget(const Graph& graph, const Path& path) {
    return graph.target(path.back());
  }
}

#endif