//=======================================================================

// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.

// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek

//

// Distributed under the Boost Software License, Version 1.0. (See

// accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

//=======================================================================

#ifndef BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP

#define BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP

#include <boost/graph/properties.hpp>

namespace boost {

  struct distance_compare_t { };

  struct distance_combine_t { };

  struct distance_inf_t { };

  struct distance_zero_t { };

  struct buffer_param_t { };

  struct edge_copy_t { };

  struct vertex_copy_t { };

  struct vertex_isomorphism_t { };

  struct vertex_invariant_t { };

  struct vertex_invariant1_t { };

  struct vertex_invariant2_t { };

  struct edge_compare_t { };

  struct vertex_max_invariant_t { };

  struct orig_to_copy_t { };

  struct root_vertex_t { };

  struct attractive_force_t { };

  struct repulsive_force_t { };

  struct force_pairs_t { };

  struct cooling_t { };

  struct vertex_displacement_t { };

  struct iterations_t { };

  struct diameter_range_t { };

  struct learning_constant_range_t { };

  namespace detail {

    template <class T>

    struct wrap_ref {

      wrap_ref(T& r) : ref(r) {}

      T& ref;

    };

  }

  template <typename T, typename Tag, typename Base = no_property>

  struct bgl_named_params : public Base

  {

    typedef bgl_named_params self;

    typedef Base next_type;

    typedef Tag tag_type;

    typedef T value_type;

    bgl_named_params(T v) : m_value(v) { }

    bgl_named_params(T v, const Base& b) : Base(b), m_value(v) { }

    T m_value;

    template <typename WeightMap>

    bgl_named_params<WeightMap, edge_weight_t, self>

    weight_map(const WeightMap& pmap) const {

      typedef bgl_named_params<WeightMap, edge_weight_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename WeightMap>

    bgl_named_params<WeightMap, edge_weight2_t, self>

    weight_map2(const WeightMap& pmap) const {

      typedef bgl_named_params<WeightMap, edge_weight2_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename DistanceMap>

    bgl_named_params<DistanceMap, vertex_distance_t, self>

    distance_map(const DistanceMap& pmap) const {

      typedef bgl_named_params<DistanceMap, vertex_distance_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename PredecessorMap>

    bgl_named_params<PredecessorMap, vertex_predecessor_t, self>

    predecessor_map(const PredecessorMap& pmap) const {

      typedef bgl_named_params<PredecessorMap, vertex_predecessor_t, self> 

        Params;

      return Params(pmap, *this);

    }

    template <typename RankMap>

    bgl_named_params<RankMap, vertex_rank_t, self>

    rank_map(const RankMap& pmap) const {

      typedef bgl_named_params<RankMap, vertex_rank_t, self> 

        Params;

      return Params(pmap, *this);

    }

    template <typename RootMap>

    bgl_named_params<RootMap, vertex_root_t, self>

    root_map(const RootMap& pmap) const {

      typedef bgl_named_params<RootMap, vertex_root_t, self> 

        Params;

      return Params(pmap, *this);

    }

    template <typename Vertex>

    bgl_named_params<Vertex, root_vertex_t, self>

    root_vertex(const Vertex& r) const {

      typedef bgl_named_params<Vertex, root_vertex_t, self> Params;

      return Params(r, *this);

    }

    template <typename EdgeCentralityMap>

    bgl_named_params<EdgeCentralityMap, edge_centrality_t, self>

    edge_centrality_map(const EdgeCentralityMap& r) const {

      typedef bgl_named_params<EdgeCentralityMap, edge_centrality_t, self> Params;

      return Params(r, *this);

    }

    template <typename CentralityMap>

    bgl_named_params<CentralityMap, vertex_centrality_t, self>

    centrality_map(const CentralityMap& r) const {

      typedef bgl_named_params<CentralityMap, vertex_centrality_t, self> Params;

      return Params(r, *this);

    }

    template <typename ColorMap>

    bgl_named_params<ColorMap, vertex_color_t, self>

    color_map(const ColorMap& pmap) const {

      typedef bgl_named_params<ColorMap, vertex_color_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename ColorMap>

    bgl_named_params<ColorMap, vertex_color_t, self>

    vertex_color_map(const ColorMap& pmap) const {

      typedef bgl_named_params<ColorMap, vertex_color_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename ColorMap>

    bgl_named_params<ColorMap, edge_color_t, self>

    edge_color_map(const ColorMap& pmap) const {

      typedef bgl_named_params<ColorMap, edge_color_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename CapacityMap>

    bgl_named_params<CapacityMap, edge_capacity_t, self>

    capacity_map(CapacityMap pmap) {

      typedef bgl_named_params<CapacityMap, edge_capacity_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename Residual_CapacityMap>

    bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t, self>

    residual_capacity_map(Residual_CapacityMap pmap) {

      typedef bgl_named_params<Residual_CapacityMap, 

        edge_residual_capacity_t, self>

        Params;

      return Params(pmap, *this);

    }

    template <typename ReverseMap>

    bgl_named_params<ReverseMap, edge_reverse_t, self>

    reverse_edge_map(ReverseMap pmap) {

      typedef bgl_named_params<ReverseMap, 

        edge_reverse_t, self>

        Params;

      return Params(pmap, *this);

    }

    template <typename DiscoverTimeMap>

    bgl_named_params<DiscoverTimeMap, vertex_discover_time_t, self>

    discover_time_map(const DiscoverTimeMap& pmap) const {

      typedef bgl_named_params<DiscoverTimeMap, vertex_discover_time_t, self>

        Params;

      return Params(pmap, *this);

    }

    template <typename LowPointMap>

    bgl_named_params<LowPointMap, vertex_lowpoint_t, self>

    lowpoint_map(const LowPointMap& pmap) const {

      typedef bgl_named_params<LowPointMap, vertex_lowpoint_t, self>

        Params;

      return Params(pmap, *this);

    }

    template <typename IndexMap>

    bgl_named_params<IndexMap, vertex_index_t, self>

    vertex_index_map(const IndexMap& pmap) const {

      typedef bgl_named_params<IndexMap, vertex_index_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename IndexMap>

    bgl_named_params<IndexMap, vertex_index1_t, self>

    vertex_index1_map(const IndexMap& pmap) const {

      typedef bgl_named_params<IndexMap, vertex_index1_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename IndexMap>

    bgl_named_params<IndexMap, vertex_index2_t, self>

    vertex_index2_map(const IndexMap& pmap) const {

      typedef bgl_named_params<IndexMap, vertex_index2_t, self> Params;

      return Params(pmap, *this);

    }

    template <typename Visitor>

    bgl_named_params<Visitor, graph_visitor_t, self>

    visitor(const Visitor& vis) const {

      typedef bgl_named_params<Visitor, graph_visitor_t, self> Params;

      return Params(vis, *this);

    }

    template <typename Compare>

    bgl_named_params<Compare, distance_compare_t, self>

    distance_compare(Compare cmp) const {

      typedef bgl_named_params<Compare, distance_compare_t, self> Params;

      return Params(cmp, *this);

    }

    template <typename Combine>

    bgl_named_params<Combine, distance_combine_t, self>

    distance_combine(Combine cmb) const {

      typedef bgl_named_params<Combine, distance_combine_t, self> Params;

      return Params(cmb, *this);

    }

    template <typename Init>

    bgl_named_params<Init, distance_inf_t, self>

    distance_inf(Init init) const {

      typedef bgl_named_params<Init, distance_inf_t, self> Params;

      return Params(init, *this);

    }

    template <typename Init>

    bgl_named_params<Init, distance_zero_t, self>

    distance_zero(Init init) const {

      typedef bgl_named_params<Init, distance_zero_t, self> Params;

      return Params(init, *this);

    }

    template <typename Buffer>

    bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t, self>

    buffer(Buffer& b) const {

      typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t, self> 

        Params;

      return Params(detail::wrap_ref<Buffer>(b), *this);

    }

    template <typename Copier>

    bgl_named_params<Copier, edge_copy_t, self>

    edge_copy(const Copier& c) const {

      typedef bgl_named_params<Copier, edge_copy_t, self> Params;

      return Params(c, *this);

    }

    template <typename Copier>

    bgl_named_params<Copier, vertex_copy_t, self>

    vertex_copy(const Copier& c) const {

      typedef bgl_named_params<Copier, vertex_copy_t, self> Params;

      return Params(c, *this);

    }

    template <typename Orig2CopyMap>

    bgl_named_params<Orig2CopyMap, orig_to_copy_t, self>

    orig_to_copy(const Orig2CopyMap& c) const {

      typedef bgl_named_params<Orig2CopyMap, orig_to_copy_t, self> Params;

      return Params(c, *this);

    }

    template <typename IsoMap>

    bgl_named_params<IsoMap, vertex_isomorphism_t, self>

    isomorphism_map(const IsoMap& c) const {

      typedef bgl_named_params<IsoMap, vertex_isomorphism_t, self> Params;

      return Params(c, *this);

    }

    template <typename VertexInvar>

    bgl_named_params<VertexInvar, vertex_invariant_t, self>

    vertex_invariant(const VertexInvar& c) const {

      typedef bgl_named_params<VertexInvar, vertex_invariant_t, self> Params;

      return Params(c, *this);

    }

    template <typename VertexDisplacement>

    bgl_named_params<VertexDisplacement, vertex_displacement_t, self>

    displacement_map(const VertexDisplacement& c) const {

      typedef bgl_named_params<VertexDisplacement, vertex_displacement_t, self> Params;

      return Params(c, *this);

    }

    template <typename AttractiveForce>

    bgl_named_params<AttractiveForce, attractive_force_t, self>

    attractive_force(const AttractiveForce& c) {

      typedef bgl_named_params<AttractiveForce, attractive_force_t, self> Params;

      return Params(c, *this);

    }

    template <typename RepulsiveForce>

    bgl_named_params<RepulsiveForce, repulsive_force_t, self>

    repulsive_force(const RepulsiveForce& c) {

      typedef bgl_named_params<RepulsiveForce, repulsive_force_t, self> Params;

      return Params(c, *this);

    }

    template <typename ForcePairs>

    bgl_named_params<ForcePairs, force_pairs_t, self>

    force_pairs(const ForcePairs& c) {

      typedef bgl_named_params<ForcePairs, force_pairs_t, self> Params;

      return Params(c, *this);

    }

    template <typename Cooling>

    bgl_named_params<Cooling, cooling_t, self>

    cooling(const Cooling& c) {

      typedef bgl_named_params<Cooling, cooling_t, self> Params;

      return Params(c, *this);

    }

    template <typename TP>

    bgl_named_params<TP, iterations_t, self>

    iterations(const TP& c) {

      typedef bgl_named_params<TP, iterations_t, self> Params;

      return Params(c, *this);

    }    

    template<typename TP>

    bgl_named_params<std::pair<TP, TP>, diameter_range_t, self>

    diameter_range(const std::pair<TP, TP>& c) {

      typedef bgl_named_params<std::pair<TP, TP>, diameter_range_t, self> Params;

      return Params(c, *this);

    }

    template<typename TP>

    bgl_named_params<std::pair<TP, TP>, learning_constant_range_t, self>

    learning_constant_range(const std::pair<TP, TP>& c) {

      typedef bgl_named_params<std::pair<TP, TP>, learning_constant_range_t, self>

        Params;

      return Params(c, *this);

    }

  };

  template <typename WeightMap>

  bgl_named_params<WeightMap, edge_weight_t>

  weight_map(WeightMap pmap) {

    typedef bgl_named_params<WeightMap, edge_weight_t> Params;

    return Params(pmap);

  }

  template <typename WeightMap>

  bgl_named_params<WeightMap, edge_weight2_t>

  weight_map2(WeightMap pmap) {

    typedef bgl_named_params<WeightMap, edge_weight2_t> Params;

    return Params(pmap);

  }

  template <typename DistanceMap>

  bgl_named_params<DistanceMap, vertex_distance_t>

  distance_map(DistanceMap pmap) {

    typedef bgl_named_params<DistanceMap, vertex_distance_t> Params;

    return Params(pmap);

  }

  template <typename PredecessorMap>

  bgl_named_params<PredecessorMap, vertex_predecessor_t>

  predecessor_map(PredecessorMap pmap) {

    typedef bgl_named_params<PredecessorMap, vertex_predecessor_t> Params;

    return Params(pmap);

  }

  template <typename RankMap>

  bgl_named_params<RankMap, vertex_rank_t>

  rank_map(RankMap pmap) {

    typedef bgl_named_params<RankMap, vertex_rank_t> Params;

    return Params(pmap);

  }

  template <typename RootMap>

  bgl_named_params<RootMap, vertex_root_t>

  root_map(RootMap pmap) {

    typedef bgl_named_params<RootMap, vertex_root_t> Params;

    return Params(pmap);

  }

  template <typename Vertex>

  bgl_named_params<Vertex, root_vertex_t>

  root_vertex(const Vertex& r) {

    typedef bgl_named_params<Vertex, root_vertex_t> Params;

    return Params(r);

  }

  template <typename EdgeCentralityMap>

  bgl_named_params<EdgeCentralityMap, edge_centrality_t>

  edge_centrality_map(const EdgeCentralityMap& r) {

    typedef bgl_named_params<EdgeCentralityMap, edge_centrality_t> Params;

    return Params(r);

  }

  template <typename CentralityMap>

  bgl_named_params<CentralityMap, vertex_centrality_t>

  centrality_map(const CentralityMap& r) {

    typedef bgl_named_params<CentralityMap, vertex_centrality_t> Params;

    return Params(r);

  }

  template <typename ColorMap>

  bgl_named_params<ColorMap, vertex_color_t>

  color_map(ColorMap pmap) {

    typedef bgl_named_params<ColorMap, vertex_color_t> Params;

    return Params(pmap);

  }

  template <typename CapacityMap>

  bgl_named_params<CapacityMap, edge_capacity_t>

  capacity_map(CapacityMap pmap) {

    typedef bgl_named_params<CapacityMap, edge_capacity_t> Params;

    return Params(pmap);

  }

  template <typename Residual_CapacityMap>

  bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t>

  residual_capacity_map(Residual_CapacityMap pmap) {

    typedef bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t>

      Params;

    return Params(pmap);

  }

  template <typename ReverseMap>

  bgl_named_params<ReverseMap, edge_reverse_t>

  reverse_edge_map(ReverseMap pmap) {

    typedef bgl_named_params<ReverseMap, edge_reverse_t>

      Params;

    return Params(pmap);

  }

  template <typename DiscoverTimeMap>

  bgl_named_params<DiscoverTimeMap, vertex_discover_time_t>

  discover_time_map(DiscoverTimeMap pmap) {

    typedef bgl_named_params<DiscoverTimeMap, vertex_discover_time_t> Params;

    return Params(pmap);

  }

  template <typename LowPointMap>

  bgl_named_params<LowPointMap, vertex_lowpoint_t>

  lowpoint_map(LowPointMap pmap) {

    typedef bgl_named_params<LowPointMap, vertex_lowpoint_t> Params;

    return Params(pmap);

  }

  template <typename IndexMap>

  bgl_named_params<IndexMap, vertex_index_t>

  vertex_index_map(IndexMap pmap) {

    typedef bgl_named_params<IndexMap, vertex_index_t> Params;

    return Params(pmap);

  }

  template <typename IndexMap>

  bgl_named_params<IndexMap, vertex_index1_t>

  vertex_index1_map(const IndexMap& pmap) {

    typedef bgl_named_params<IndexMap, vertex_index1_t> Params;

    return Params(pmap);

  }

  template <typename IndexMap>

  bgl_named_params<IndexMap, vertex_index2_t>

  vertex_index2_map(const IndexMap& pmap) {

    typedef bgl_named_params<IndexMap, vertex_index2_t> Params;

    return Params(pmap);

  }

  template <typename Visitor>

  bgl_named_params<Visitor, graph_visitor_t>

  visitor(const Visitor& vis) {

    typedef bgl_named_params<Visitor, graph_visitor_t> Params;

    return Params(vis);

  }

  template <typename Compare>

  bgl_named_params<Compare, distance_compare_t>

  distance_compare(Compare cmp) {

    typedef bgl_named_params<Compare, distance_compare_t> Params;

    return Params(cmp);

  }

  template <typename Combine>

  bgl_named_params<Combine, distance_combine_t>

  distance_combine(Combine cmb) {

    typedef bgl_named_params<Combine, distance_combine_t> Params;

    return Params(cmb);

  }

  template <typename Init>

  bgl_named_params<Init, distance_inf_t>

  distance_inf(Init init) {

    typedef bgl_named_params<Init, distance_inf_t> Params;

    return Params(init);

  }

  template <typename Init>

  bgl_named_params<Init, distance_zero_t>

  distance_zero(Init init) {

    typedef bgl_named_params<Init, distance_zero_t> Params;

    return Params(init);

  }

  template <typename Buffer>

  bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t>

  buffer(Buffer& b) {

    typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t> Params;

    return Params(detail::wrap_ref<Buffer>(b));

  }

  template <typename Copier>

  bgl_named_params<Copier, edge_copy_t>

  edge_copy(const Copier& c) {

    typedef bgl_named_params<Copier, edge_copy_t> Params;

    return Params(c);

  }

  template <typename Copier>

  bgl_named_params<Copier, vertex_copy_t>

  vertex_copy(const Copier& c) {

    typedef bgl_named_params<Copier, vertex_copy_t> Params;

    return Params(c);

  }