epoc32/include/stdapis/boost/graph/named_function_params.hpp
branchSymbian2
changeset 2 2fe1408b6811
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/epoc32/include/stdapis/boost/graph/named_function_params.hpp	Tue Mar 16 16:12:26 2010 +0000
     1.3 @@ -0,0 +1,753 @@
     1.4 +//=======================================================================
     1.5 +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
     1.6 +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
     1.7 +//
     1.8 +// Distributed under the Boost Software License, Version 1.0. (See
     1.9 +// accompanying file LICENSE_1_0.txt or copy at
    1.10 +// http://www.boost.org/LICENSE_1_0.txt)
    1.11 +//=======================================================================
    1.12 +
    1.13 +#ifndef BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP
    1.14 +#define BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP
    1.15 +
    1.16 +#include <boost/graph/properties.hpp>
    1.17 +
    1.18 +namespace boost {
    1.19 +
    1.20 +  struct distance_compare_t { };
    1.21 +  struct distance_combine_t { };
    1.22 +  struct distance_inf_t { };
    1.23 +  struct distance_zero_t { };
    1.24 +  struct buffer_param_t { };
    1.25 +  struct edge_copy_t { };
    1.26 +  struct vertex_copy_t { };
    1.27 +  struct vertex_isomorphism_t { };
    1.28 +  struct vertex_invariant_t { };
    1.29 +  struct vertex_invariant1_t { };
    1.30 +  struct vertex_invariant2_t { };
    1.31 +  struct edge_compare_t { };
    1.32 +  struct vertex_max_invariant_t { };
    1.33 +  struct orig_to_copy_t { };
    1.34 +  struct root_vertex_t { };
    1.35 +  struct attractive_force_t { };
    1.36 +  struct repulsive_force_t { };
    1.37 +  struct force_pairs_t { };
    1.38 +  struct cooling_t { };
    1.39 +  struct vertex_displacement_t { };
    1.40 +  struct iterations_t { };
    1.41 +  struct diameter_range_t { };
    1.42 +  struct learning_constant_range_t { };
    1.43 +
    1.44 +  namespace detail {
    1.45 +    template <class T>
    1.46 +    struct wrap_ref {
    1.47 +      wrap_ref(T& r) : ref(r) {}
    1.48 +      T& ref;
    1.49 +    };
    1.50 +  }
    1.51 +
    1.52 +  template <typename T, typename Tag, typename Base = no_property>
    1.53 +  struct bgl_named_params : public Base
    1.54 +  {
    1.55 +    typedef bgl_named_params self;
    1.56 +    typedef Base next_type;
    1.57 +    typedef Tag tag_type;
    1.58 +    typedef T value_type;
    1.59 +    bgl_named_params(T v) : m_value(v) { }
    1.60 +    bgl_named_params(T v, const Base& b) : Base(b), m_value(v) { }
    1.61 +    T m_value;
    1.62 +
    1.63 +    template <typename WeightMap>
    1.64 +    bgl_named_params<WeightMap, edge_weight_t, self>
    1.65 +    weight_map(const WeightMap& pmap) const {
    1.66 +      typedef bgl_named_params<WeightMap, edge_weight_t, self> Params;
    1.67 +      return Params(pmap, *this);
    1.68 +    }
    1.69 +
    1.70 +    template <typename WeightMap>
    1.71 +    bgl_named_params<WeightMap, edge_weight2_t, self>
    1.72 +    weight_map2(const WeightMap& pmap) const {
    1.73 +      typedef bgl_named_params<WeightMap, edge_weight2_t, self> Params;
    1.74 +      return Params(pmap, *this);
    1.75 +    }
    1.76 +
    1.77 +    template <typename DistanceMap>
    1.78 +    bgl_named_params<DistanceMap, vertex_distance_t, self>
    1.79 +    distance_map(const DistanceMap& pmap) const {
    1.80 +      typedef bgl_named_params<DistanceMap, vertex_distance_t, self> Params;
    1.81 +      return Params(pmap, *this);
    1.82 +    }
    1.83 +
    1.84 +    template <typename PredecessorMap>
    1.85 +    bgl_named_params<PredecessorMap, vertex_predecessor_t, self>
    1.86 +    predecessor_map(const PredecessorMap& pmap) const {
    1.87 +      typedef bgl_named_params<PredecessorMap, vertex_predecessor_t, self> 
    1.88 +        Params;
    1.89 +      return Params(pmap, *this);
    1.90 +    }
    1.91 +
    1.92 +    template <typename RankMap>
    1.93 +    bgl_named_params<RankMap, vertex_rank_t, self>
    1.94 +    rank_map(const RankMap& pmap) const {
    1.95 +      typedef bgl_named_params<RankMap, vertex_rank_t, self> 
    1.96 +        Params;
    1.97 +      return Params(pmap, *this);
    1.98 +    }
    1.99 +
   1.100 +    template <typename RootMap>
   1.101 +    bgl_named_params<RootMap, vertex_root_t, self>
   1.102 +    root_map(const RootMap& pmap) const {
   1.103 +      typedef bgl_named_params<RootMap, vertex_root_t, self> 
   1.104 +        Params;
   1.105 +      return Params(pmap, *this);
   1.106 +    }
   1.107 +
   1.108 +    template <typename Vertex>
   1.109 +    bgl_named_params<Vertex, root_vertex_t, self>
   1.110 +    root_vertex(const Vertex& r) const {
   1.111 +      typedef bgl_named_params<Vertex, root_vertex_t, self> Params;
   1.112 +      return Params(r, *this);
   1.113 +    }
   1.114 +
   1.115 +    template <typename EdgeCentralityMap>
   1.116 +    bgl_named_params<EdgeCentralityMap, edge_centrality_t, self>
   1.117 +    edge_centrality_map(const EdgeCentralityMap& r) const {
   1.118 +      typedef bgl_named_params<EdgeCentralityMap, edge_centrality_t, self> Params;
   1.119 +      return Params(r, *this);
   1.120 +    }
   1.121 +
   1.122 +    template <typename CentralityMap>
   1.123 +    bgl_named_params<CentralityMap, vertex_centrality_t, self>
   1.124 +    centrality_map(const CentralityMap& r) const {
   1.125 +      typedef bgl_named_params<CentralityMap, vertex_centrality_t, self> Params;
   1.126 +      return Params(r, *this);
   1.127 +    }
   1.128 +
   1.129 +    template <typename ColorMap>
   1.130 +    bgl_named_params<ColorMap, vertex_color_t, self>
   1.131 +    color_map(const ColorMap& pmap) const {
   1.132 +      typedef bgl_named_params<ColorMap, vertex_color_t, self> Params;
   1.133 +      return Params(pmap, *this);
   1.134 +    }
   1.135 +
   1.136 +    template <typename ColorMap>
   1.137 +    bgl_named_params<ColorMap, vertex_color_t, self>
   1.138 +    vertex_color_map(const ColorMap& pmap) const {
   1.139 +      typedef bgl_named_params<ColorMap, vertex_color_t, self> Params;
   1.140 +      return Params(pmap, *this);
   1.141 +    }
   1.142 +
   1.143 +    template <typename ColorMap>
   1.144 +    bgl_named_params<ColorMap, edge_color_t, self>
   1.145 +    edge_color_map(const ColorMap& pmap) const {
   1.146 +      typedef bgl_named_params<ColorMap, edge_color_t, self> Params;
   1.147 +      return Params(pmap, *this);
   1.148 +    }
   1.149 +
   1.150 +    template <typename CapacityMap>
   1.151 +    bgl_named_params<CapacityMap, edge_capacity_t, self>
   1.152 +    capacity_map(CapacityMap pmap) {
   1.153 +      typedef bgl_named_params<CapacityMap, edge_capacity_t, self> Params;
   1.154 +      return Params(pmap, *this);
   1.155 +    }
   1.156 +
   1.157 +    template <typename Residual_CapacityMap>
   1.158 +    bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t, self>
   1.159 +    residual_capacity_map(Residual_CapacityMap pmap) {
   1.160 +      typedef bgl_named_params<Residual_CapacityMap, 
   1.161 +        edge_residual_capacity_t, self>
   1.162 +        Params;
   1.163 +      return Params(pmap, *this);
   1.164 +    }
   1.165 +
   1.166 +    template <typename ReverseMap>
   1.167 +    bgl_named_params<ReverseMap, edge_reverse_t, self>
   1.168 +    reverse_edge_map(ReverseMap pmap) {
   1.169 +      typedef bgl_named_params<ReverseMap, 
   1.170 +        edge_reverse_t, self>
   1.171 +        Params;
   1.172 +      return Params(pmap, *this);
   1.173 +    }
   1.174 +
   1.175 +    template <typename DiscoverTimeMap>
   1.176 +    bgl_named_params<DiscoverTimeMap, vertex_discover_time_t, self>
   1.177 +    discover_time_map(const DiscoverTimeMap& pmap) const {
   1.178 +      typedef bgl_named_params<DiscoverTimeMap, vertex_discover_time_t, self>
   1.179 +        Params;
   1.180 +      return Params(pmap, *this);
   1.181 +    }
   1.182 +
   1.183 +    template <typename LowPointMap>
   1.184 +    bgl_named_params<LowPointMap, vertex_lowpoint_t, self>
   1.185 +    lowpoint_map(const LowPointMap& pmap) const {
   1.186 +      typedef bgl_named_params<LowPointMap, vertex_lowpoint_t, self>
   1.187 +        Params;
   1.188 +      return Params(pmap, *this);
   1.189 +    }
   1.190 +
   1.191 +    template <typename IndexMap>
   1.192 +    bgl_named_params<IndexMap, vertex_index_t, self>
   1.193 +    vertex_index_map(const IndexMap& pmap) const {
   1.194 +      typedef bgl_named_params<IndexMap, vertex_index_t, self> Params;
   1.195 +      return Params(pmap, *this);
   1.196 +    }
   1.197 +
   1.198 +    template <typename IndexMap>
   1.199 +    bgl_named_params<IndexMap, vertex_index1_t, self>
   1.200 +    vertex_index1_map(const IndexMap& pmap) const {
   1.201 +      typedef bgl_named_params<IndexMap, vertex_index1_t, self> Params;
   1.202 +      return Params(pmap, *this);
   1.203 +    }
   1.204 +
   1.205 +    template <typename IndexMap>
   1.206 +    bgl_named_params<IndexMap, vertex_index2_t, self>
   1.207 +    vertex_index2_map(const IndexMap& pmap) const {
   1.208 +      typedef bgl_named_params<IndexMap, vertex_index2_t, self> Params;
   1.209 +      return Params(pmap, *this);
   1.210 +    }
   1.211 +
   1.212 +    template <typename Visitor>
   1.213 +    bgl_named_params<Visitor, graph_visitor_t, self>
   1.214 +    visitor(const Visitor& vis) const {
   1.215 +      typedef bgl_named_params<Visitor, graph_visitor_t, self> Params;
   1.216 +      return Params(vis, *this);
   1.217 +    }
   1.218 +
   1.219 +    template <typename Compare>
   1.220 +    bgl_named_params<Compare, distance_compare_t, self>
   1.221 +    distance_compare(Compare cmp) const {
   1.222 +      typedef bgl_named_params<Compare, distance_compare_t, self> Params;
   1.223 +      return Params(cmp, *this);
   1.224 +    }
   1.225 +
   1.226 +    template <typename Combine>
   1.227 +    bgl_named_params<Combine, distance_combine_t, self>
   1.228 +    distance_combine(Combine cmb) const {
   1.229 +      typedef bgl_named_params<Combine, distance_combine_t, self> Params;
   1.230 +      return Params(cmb, *this);
   1.231 +    }
   1.232 +
   1.233 +    template <typename Init>
   1.234 +    bgl_named_params<Init, distance_inf_t, self>
   1.235 +    distance_inf(Init init) const {
   1.236 +      typedef bgl_named_params<Init, distance_inf_t, self> Params;
   1.237 +      return Params(init, *this);
   1.238 +    }
   1.239 +
   1.240 +    template <typename Init>
   1.241 +    bgl_named_params<Init, distance_zero_t, self>
   1.242 +    distance_zero(Init init) const {
   1.243 +      typedef bgl_named_params<Init, distance_zero_t, self> Params;
   1.244 +      return Params(init, *this);
   1.245 +    }
   1.246 +
   1.247 +    template <typename Buffer>
   1.248 +    bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t, self>
   1.249 +    buffer(Buffer& b) const {
   1.250 +      typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t, self> 
   1.251 +        Params;
   1.252 +      return Params(detail::wrap_ref<Buffer>(b), *this);
   1.253 +    }
   1.254 +
   1.255 +    template <typename Copier>
   1.256 +    bgl_named_params<Copier, edge_copy_t, self>
   1.257 +    edge_copy(const Copier& c) const {
   1.258 +      typedef bgl_named_params<Copier, edge_copy_t, self> Params;
   1.259 +      return Params(c, *this);
   1.260 +    }
   1.261 +
   1.262 +    template <typename Copier>
   1.263 +    bgl_named_params<Copier, vertex_copy_t, self>
   1.264 +    vertex_copy(const Copier& c) const {
   1.265 +      typedef bgl_named_params<Copier, vertex_copy_t, self> Params;
   1.266 +      return Params(c, *this);
   1.267 +    }
   1.268 +
   1.269 +    template <typename Orig2CopyMap>
   1.270 +    bgl_named_params<Orig2CopyMap, orig_to_copy_t, self>
   1.271 +    orig_to_copy(const Orig2CopyMap& c) const {
   1.272 +      typedef bgl_named_params<Orig2CopyMap, orig_to_copy_t, self> Params;
   1.273 +      return Params(c, *this);
   1.274 +    }
   1.275 +
   1.276 +    template <typename IsoMap>
   1.277 +    bgl_named_params<IsoMap, vertex_isomorphism_t, self>
   1.278 +    isomorphism_map(const IsoMap& c) const {
   1.279 +      typedef bgl_named_params<IsoMap, vertex_isomorphism_t, self> Params;
   1.280 +      return Params(c, *this);
   1.281 +    }
   1.282 +
   1.283 +    template <typename VertexInvar>
   1.284 +    bgl_named_params<VertexInvar, vertex_invariant_t, self>
   1.285 +    vertex_invariant(const VertexInvar& c) const {
   1.286 +      typedef bgl_named_params<VertexInvar, vertex_invariant_t, self> Params;
   1.287 +      return Params(c, *this);
   1.288 +    }
   1.289 +
   1.290 +    template <typename VertexDisplacement>
   1.291 +    bgl_named_params<VertexDisplacement, vertex_displacement_t, self>
   1.292 +    displacement_map(const VertexDisplacement& c) const {
   1.293 +      typedef bgl_named_params<VertexDisplacement, vertex_displacement_t, self> Params;
   1.294 +      return Params(c, *this);
   1.295 +    }
   1.296 +
   1.297 +    template <typename AttractiveForce>
   1.298 +    bgl_named_params<AttractiveForce, attractive_force_t, self>
   1.299 +    attractive_force(const AttractiveForce& c) {
   1.300 +      typedef bgl_named_params<AttractiveForce, attractive_force_t, self> Params;
   1.301 +      return Params(c, *this);
   1.302 +    }
   1.303 +    
   1.304 +    template <typename RepulsiveForce>
   1.305 +    bgl_named_params<RepulsiveForce, repulsive_force_t, self>
   1.306 +    repulsive_force(const RepulsiveForce& c) {
   1.307 +      typedef bgl_named_params<RepulsiveForce, repulsive_force_t, self> Params;
   1.308 +      return Params(c, *this);
   1.309 +    }
   1.310 +    
   1.311 +    template <typename ForcePairs>
   1.312 +    bgl_named_params<ForcePairs, force_pairs_t, self>
   1.313 +    force_pairs(const ForcePairs& c) {
   1.314 +      typedef bgl_named_params<ForcePairs, force_pairs_t, self> Params;
   1.315 +      return Params(c, *this);
   1.316 +    }
   1.317 +
   1.318 +    template <typename Cooling>
   1.319 +    bgl_named_params<Cooling, cooling_t, self>
   1.320 +    cooling(const Cooling& c) {
   1.321 +      typedef bgl_named_params<Cooling, cooling_t, self> Params;
   1.322 +      return Params(c, *this);
   1.323 +    }
   1.324 +
   1.325 +    template <typename TP>
   1.326 +    bgl_named_params<TP, iterations_t, self>
   1.327 +    iterations(const TP& c) {
   1.328 +      typedef bgl_named_params<TP, iterations_t, self> Params;
   1.329 +      return Params(c, *this);
   1.330 +    }    
   1.331 +
   1.332 +    template<typename TP>
   1.333 +    bgl_named_params<std::pair<TP, TP>, diameter_range_t, self>
   1.334 +    diameter_range(const std::pair<TP, TP>& c) {
   1.335 +      typedef bgl_named_params<std::pair<TP, TP>, diameter_range_t, self> Params;
   1.336 +      return Params(c, *this);
   1.337 +    }
   1.338 +
   1.339 +    template<typename TP>
   1.340 +    bgl_named_params<std::pair<TP, TP>, learning_constant_range_t, self>
   1.341 +    learning_constant_range(const std::pair<TP, TP>& c) {
   1.342 +      typedef bgl_named_params<std::pair<TP, TP>, learning_constant_range_t, self>
   1.343 +        Params;
   1.344 +      return Params(c, *this);
   1.345 +    }
   1.346 +  };
   1.347 +
   1.348 +  template <typename WeightMap>
   1.349 +  bgl_named_params<WeightMap, edge_weight_t>
   1.350 +  weight_map(WeightMap pmap) {
   1.351 +    typedef bgl_named_params<WeightMap, edge_weight_t> Params;
   1.352 +    return Params(pmap);
   1.353 +  }
   1.354 +
   1.355 +  template <typename WeightMap>
   1.356 +  bgl_named_params<WeightMap, edge_weight2_t>
   1.357 +  weight_map2(WeightMap pmap) {
   1.358 +    typedef bgl_named_params<WeightMap, edge_weight2_t> Params;
   1.359 +    return Params(pmap);
   1.360 +  }
   1.361 +
   1.362 +  template <typename DistanceMap>
   1.363 +  bgl_named_params<DistanceMap, vertex_distance_t>
   1.364 +  distance_map(DistanceMap pmap) {
   1.365 +    typedef bgl_named_params<DistanceMap, vertex_distance_t> Params;
   1.366 +    return Params(pmap);
   1.367 +  }
   1.368 +
   1.369 +  template <typename PredecessorMap>
   1.370 +  bgl_named_params<PredecessorMap, vertex_predecessor_t>
   1.371 +  predecessor_map(PredecessorMap pmap) {
   1.372 +    typedef bgl_named_params<PredecessorMap, vertex_predecessor_t> Params;
   1.373 +    return Params(pmap);
   1.374 +  }
   1.375 +
   1.376 +  template <typename RankMap>
   1.377 +  bgl_named_params<RankMap, vertex_rank_t>
   1.378 +  rank_map(RankMap pmap) {
   1.379 +    typedef bgl_named_params<RankMap, vertex_rank_t> Params;
   1.380 +    return Params(pmap);
   1.381 +  }
   1.382 +
   1.383 +  template <typename RootMap>
   1.384 +  bgl_named_params<RootMap, vertex_root_t>
   1.385 +  root_map(RootMap pmap) {
   1.386 +    typedef bgl_named_params<RootMap, vertex_root_t> Params;
   1.387 +    return Params(pmap);
   1.388 +  }
   1.389 +
   1.390 +  template <typename Vertex>
   1.391 +  bgl_named_params<Vertex, root_vertex_t>
   1.392 +  root_vertex(const Vertex& r) {
   1.393 +    typedef bgl_named_params<Vertex, root_vertex_t> Params;
   1.394 +    return Params(r);
   1.395 +  }
   1.396 +
   1.397 +  template <typename EdgeCentralityMap>
   1.398 +  bgl_named_params<EdgeCentralityMap, edge_centrality_t>
   1.399 +  edge_centrality_map(const EdgeCentralityMap& r) {
   1.400 +    typedef bgl_named_params<EdgeCentralityMap, edge_centrality_t> Params;
   1.401 +    return Params(r);
   1.402 +  }
   1.403 +
   1.404 +  template <typename CentralityMap>
   1.405 +  bgl_named_params<CentralityMap, vertex_centrality_t>
   1.406 +  centrality_map(const CentralityMap& r) {
   1.407 +    typedef bgl_named_params<CentralityMap, vertex_centrality_t> Params;
   1.408 +    return Params(r);
   1.409 +  }
   1.410 +
   1.411 +  template <typename ColorMap>
   1.412 +  bgl_named_params<ColorMap, vertex_color_t>
   1.413 +  color_map(ColorMap pmap) {
   1.414 +    typedef bgl_named_params<ColorMap, vertex_color_t> Params;
   1.415 +    return Params(pmap);
   1.416 +  }
   1.417 +
   1.418 +  template <typename CapacityMap>
   1.419 +  bgl_named_params<CapacityMap, edge_capacity_t>
   1.420 +  capacity_map(CapacityMap pmap) {
   1.421 +    typedef bgl_named_params<CapacityMap, edge_capacity_t> Params;
   1.422 +    return Params(pmap);
   1.423 +  }
   1.424 +
   1.425 +  template <typename Residual_CapacityMap>
   1.426 +  bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t>
   1.427 +  residual_capacity_map(Residual_CapacityMap pmap) {
   1.428 +    typedef bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t>
   1.429 +      Params;
   1.430 +    return Params(pmap);
   1.431 +  }
   1.432 +
   1.433 +  template <typename ReverseMap>
   1.434 +  bgl_named_params<ReverseMap, edge_reverse_t>
   1.435 +  reverse_edge_map(ReverseMap pmap) {
   1.436 +    typedef bgl_named_params<ReverseMap, edge_reverse_t>
   1.437 +      Params;
   1.438 +    return Params(pmap);
   1.439 +  }
   1.440 +
   1.441 +  template <typename DiscoverTimeMap>
   1.442 +  bgl_named_params<DiscoverTimeMap, vertex_discover_time_t>
   1.443 +  discover_time_map(DiscoverTimeMap pmap) {
   1.444 +    typedef bgl_named_params<DiscoverTimeMap, vertex_discover_time_t> Params;
   1.445 +    return Params(pmap);
   1.446 +  }
   1.447 +
   1.448 +  template <typename LowPointMap>
   1.449 +  bgl_named_params<LowPointMap, vertex_lowpoint_t>
   1.450 +  lowpoint_map(LowPointMap pmap) {
   1.451 +    typedef bgl_named_params<LowPointMap, vertex_lowpoint_t> Params;
   1.452 +    return Params(pmap);
   1.453 +  }
   1.454 +
   1.455 +  template <typename IndexMap>
   1.456 +  bgl_named_params<IndexMap, vertex_index_t>
   1.457 +  vertex_index_map(IndexMap pmap) {
   1.458 +    typedef bgl_named_params<IndexMap, vertex_index_t> Params;
   1.459 +    return Params(pmap);
   1.460 +  }
   1.461 +
   1.462 +  template <typename IndexMap>
   1.463 +  bgl_named_params<IndexMap, vertex_index1_t>
   1.464 +  vertex_index1_map(const IndexMap& pmap) {
   1.465 +    typedef bgl_named_params<IndexMap, vertex_index1_t> Params;
   1.466 +    return Params(pmap);
   1.467 +  }
   1.468 +
   1.469 +  template <typename IndexMap>
   1.470 +  bgl_named_params<IndexMap, vertex_index2_t>
   1.471 +  vertex_index2_map(const IndexMap& pmap) {
   1.472 +    typedef bgl_named_params<IndexMap, vertex_index2_t> Params;
   1.473 +    return Params(pmap);
   1.474 +  }
   1.475 +
   1.476 +  template <typename Visitor>
   1.477 +  bgl_named_params<Visitor, graph_visitor_t>
   1.478 +  visitor(const Visitor& vis) {
   1.479 +    typedef bgl_named_params<Visitor, graph_visitor_t> Params;
   1.480 +    return Params(vis);
   1.481 +  }
   1.482 +
   1.483 +  template <typename Compare>
   1.484 +  bgl_named_params<Compare, distance_compare_t>
   1.485 +  distance_compare(Compare cmp) {
   1.486 +    typedef bgl_named_params<Compare, distance_compare_t> Params;
   1.487 +    return Params(cmp);
   1.488 +  }
   1.489 +
   1.490 +  template <typename Combine>
   1.491 +  bgl_named_params<Combine, distance_combine_t>
   1.492 +  distance_combine(Combine cmb) {
   1.493 +    typedef bgl_named_params<Combine, distance_combine_t> Params;
   1.494 +    return Params(cmb);
   1.495 +  }
   1.496 +
   1.497 +  template <typename Init>
   1.498 +  bgl_named_params<Init, distance_inf_t>
   1.499 +  distance_inf(Init init) {
   1.500 +    typedef bgl_named_params<Init, distance_inf_t> Params;
   1.501 +    return Params(init);
   1.502 +  }
   1.503 +
   1.504 +  template <typename Init>
   1.505 +  bgl_named_params<Init, distance_zero_t>
   1.506 +  distance_zero(Init init) {
   1.507 +    typedef bgl_named_params<Init, distance_zero_t> Params;
   1.508 +    return Params(init);
   1.509 +  }
   1.510 +
   1.511 +  template <typename Buffer>
   1.512 +  bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t>
   1.513 +  buffer(Buffer& b) {
   1.514 +    typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t> Params;
   1.515 +    return Params(detail::wrap_ref<Buffer>(b));
   1.516 +  }
   1.517 +
   1.518 +  template <typename Copier>
   1.519 +  bgl_named_params<Copier, edge_copy_t>
   1.520 +  edge_copy(const Copier& c) {
   1.521 +    typedef bgl_named_params<Copier, edge_copy_t> Params;
   1.522 +    return Params(c);
   1.523 +  }
   1.524 +
   1.525 +  template <typename Copier>
   1.526 +  bgl_named_params<Copier, vertex_copy_t>
   1.527 +  vertex_copy(const Copier& c) {
   1.528 +    typedef bgl_named_params<Copier, vertex_copy_t> Params;
   1.529 +    return Params(c);
   1.530 +  }
   1.531 +
   1.532 +  template <typename Orig2CopyMap>
   1.533 +  bgl_named_params<Orig2CopyMap, orig_to_copy_t>
   1.534 +  orig_to_copy(const Orig2CopyMap& c) {
   1.535 +    typedef bgl_named_params<Orig2CopyMap, orig_to_copy_t> Params;
   1.536 +    return Params(c);
   1.537 +  }
   1.538 +
   1.539 +  template <typename IsoMap>
   1.540 +  bgl_named_params<IsoMap, vertex_isomorphism_t>
   1.541 +  isomorphism_map(const IsoMap& c) {
   1.542 +    typedef bgl_named_params<IsoMap, vertex_isomorphism_t> Params;
   1.543 +    return Params(c);
   1.544 +  }
   1.545 +
   1.546 +  template <typename VertexInvar>
   1.547 +  bgl_named_params<VertexInvar, vertex_invariant_t>
   1.548 +  vertex_invariant(const VertexInvar& c) {
   1.549 +    typedef bgl_named_params<VertexInvar, vertex_invariant_t> Params;
   1.550 +    return Params(c);
   1.551 +  }
   1.552 +
   1.553 +  template <typename VertexDisplacement>
   1.554 +  bgl_named_params<VertexDisplacement, vertex_displacement_t>
   1.555 +  displacement_map(const VertexDisplacement& c) {
   1.556 +    typedef bgl_named_params<VertexDisplacement, vertex_displacement_t> Params;
   1.557 +    return Params(c);
   1.558 +  }
   1.559 +
   1.560 +  template <typename AttractiveForce>
   1.561 +  bgl_named_params<AttractiveForce, attractive_force_t>
   1.562 +  attractive_force(const AttractiveForce& c) {
   1.563 +    typedef bgl_named_params<AttractiveForce, attractive_force_t> Params;
   1.564 +    return Params(c);
   1.565 +  }
   1.566 +
   1.567 +  template <typename RepulsiveForce>
   1.568 +  bgl_named_params<RepulsiveForce, repulsive_force_t>
   1.569 +  repulsive_force(const RepulsiveForce& c) {
   1.570 +    typedef bgl_named_params<RepulsiveForce, repulsive_force_t> Params;
   1.571 +    return Params(c);
   1.572 +  }
   1.573 +
   1.574 +  template <typename ForcePairs>
   1.575 +  bgl_named_params<ForcePairs, force_pairs_t>
   1.576 +  force_pairs(const ForcePairs& c) {
   1.577 +    typedef bgl_named_params<ForcePairs, force_pairs_t> Params;
   1.578 +    return Params(c);
   1.579 +  }
   1.580 +
   1.581 +  template <typename Cooling>
   1.582 +  bgl_named_params<Cooling, cooling_t>
   1.583 +  cooling(const Cooling& c) {
   1.584 +    typedef bgl_named_params<Cooling, cooling_t> Params;
   1.585 +    return Params(c);
   1.586 +  }
   1.587 +
   1.588 +  template <typename T>
   1.589 +  bgl_named_params<T, iterations_t>
   1.590 +  iterations(const T& c) {
   1.591 +    typedef bgl_named_params<T, iterations_t> Params;
   1.592 +    return Params(c);
   1.593 +  }    
   1.594 +  
   1.595 +  template<typename T>
   1.596 +  bgl_named_params<std::pair<T, T>, diameter_range_t>
   1.597 +  diameter_range(const std::pair<T, T>& c) {
   1.598 +    typedef bgl_named_params<std::pair<T, T>, diameter_range_t> Params;
   1.599 +    return Params(c);
   1.600 +  }
   1.601 +  
   1.602 +  template<typename T>
   1.603 +  bgl_named_params<std::pair<T, T>, learning_constant_range_t>
   1.604 +  learning_constant_range(const std::pair<T, T>& c) {
   1.605 +    typedef bgl_named_params<std::pair<T, T>, learning_constant_range_t>
   1.606 +      Params;
   1.607 +    return Params(c);
   1.608 +  }
   1.609 +
   1.610 +  //===========================================================================
   1.611 +  // Functions for extracting parameters from bgl_named_params
   1.612 +
   1.613 +  template <class Tag1, class Tag2, class T1, class Base>
   1.614 +  inline
   1.615 +  typename property_value< bgl_named_params<T1,Tag1,Base>, Tag2>::type
   1.616 +  get_param(const bgl_named_params<T1,Tag1,Base>& p, Tag2 tag2)
   1.617 +  {
   1.618 +    enum { match = detail::same_property<Tag1,Tag2>::value };
   1.619 +    typedef typename
   1.620 +      property_value< bgl_named_params<T1,Tag1,Base>, Tag2>::type T2;
   1.621 +    T2* t2 = 0;
   1.622 +    typedef detail::property_value_dispatch<match> Dispatcher;
   1.623 +    return Dispatcher::const_get_value(p, t2, tag2);
   1.624 +  }
   1.625 +
   1.626 +
   1.627 +  namespace detail {
   1.628 +    // MSVC++ workaround
   1.629 +    template <class Param>
   1.630 +    struct choose_param_helper {
   1.631 +      template <class Default> struct result { typedef Param type; };
   1.632 +      template <typename Default>
   1.633 +      static const Param& apply(const Param& p, const Default&) { return p; }
   1.634 +    };
   1.635 +    template <>
   1.636 +    struct choose_param_helper<error_property_not_found> {
   1.637 +      template <class Default> struct result { typedef Default type; };
   1.638 +      template <typename Default>
   1.639 +      static const Default& apply(const error_property_not_found&, const Default& d)
   1.640 +        { return d; }
   1.641 +    };
   1.642 +  } // namespace detail
   1.643 +
   1.644 +  template <class P, class Default> 
   1.645 +  const typename detail::choose_param_helper<P>::template result<Default>::type&
   1.646 +  choose_param(const P& param, const Default& d) { 
   1.647 +    return detail::choose_param_helper<P>::apply(param, d);
   1.648 +  }
   1.649 +
   1.650 +  template <typename T>
   1.651 +  inline bool is_default_param(const T&) { return false; }
   1.652 +
   1.653 +  inline bool is_default_param(const detail::error_property_not_found&)
   1.654 +    { return true; }
   1.655 +
   1.656 +  namespace detail {
   1.657 +
   1.658 +    struct choose_parameter {
   1.659 +      template <class P, class Graph, class Tag>
   1.660 +      struct bind_ {
   1.661 +        typedef const P& const_result_type;
   1.662 +        typedef const P& result_type;
   1.663 +        typedef P type;
   1.664 +      };
   1.665 +
   1.666 +      template <class P, class Graph, class Tag>
   1.667 +      static typename bind_<P, Graph, Tag>::const_result_type
   1.668 +      const_apply(const P& p, const Graph&, Tag&) 
   1.669 +      { return p; }
   1.670 +
   1.671 +      template <class P, class Graph, class Tag>
   1.672 +      static typename bind_<P, Graph, Tag>::result_type
   1.673 +      apply(const P& p, Graph&, Tag&) 
   1.674 +      { return p; }
   1.675 +    };
   1.676 +
   1.677 +    struct choose_default_param {
   1.678 +      template <class P, class Graph, class Tag>
   1.679 +      struct bind_ {
   1.680 +        typedef typename property_map<Graph, Tag>::type 
   1.681 +          result_type;
   1.682 +        typedef typename property_map<Graph, Tag>::const_type 
   1.683 +          const_result_type;
   1.684 +        typedef typename property_map<Graph, Tag>::const_type 
   1.685 +          type;
   1.686 +      };
   1.687 +
   1.688 +      template <class P, class Graph, class Tag>
   1.689 +      static typename bind_<P, Graph, Tag>::const_result_type
   1.690 +      const_apply(const P&, const Graph& g, Tag tag) { 
   1.691 +        return get(tag, g); 
   1.692 +      }
   1.693 +      template <class P, class Graph, class Tag>
   1.694 +      static typename bind_<P, Graph, Tag>::result_type
   1.695 +      apply(const P&, Graph& g, Tag tag) { 
   1.696 +        return get(tag, g); 
   1.697 +      }
   1.698 +    };
   1.699 +
   1.700 +    template <class Param>
   1.701 +    struct choose_property_map {
   1.702 +      typedef choose_parameter type;
   1.703 +    };
   1.704 +    template <>
   1.705 +    struct choose_property_map<detail::error_property_not_found> {
   1.706 +      typedef choose_default_param type;
   1.707 +    };
   1.708 +
   1.709 +    template <class Param, class Graph, class Tag>
   1.710 +    struct choose_pmap_helper {
   1.711 +      typedef typename choose_property_map<Param>::type Selector;
   1.712 +      typedef typename Selector:: template bind_<Param, Graph, Tag> Bind;
   1.713 +      typedef Bind type;
   1.714 +      typedef typename Bind::result_type result_type;
   1.715 +      typedef typename Bind::const_result_type const_result_type;
   1.716 +      typedef typename Bind::type result;
   1.717 +    };
   1.718 +
   1.719 +    // used in the max-flow algorithms
   1.720 +    template <class Graph, class P, class T, class R>
   1.721 +    struct edge_capacity_value
   1.722 +    {
   1.723 +      typedef bgl_named_params<P, T, R> Params;
   1.724 +      typedef typename property_value< Params, edge_capacity_t>::type Param;
   1.725 +      typedef typename detail::choose_pmap_helper<Param, Graph,
   1.726 +        edge_capacity_t>::result CapacityEdgeMap;
   1.727 +      typedef typename property_traits<CapacityEdgeMap>::value_type type;
   1.728 +    };
   1.729 +
   1.730 +  } // namespace detail
   1.731 +  
   1.732 +
   1.733 +  // Use this function instead of choose_param() when you want
   1.734 +  // to avoid requiring get(tag, g) when it is not used. 
   1.735 +  template <typename Param, typename Graph, typename PropertyTag>
   1.736 +  typename
   1.737 +    detail::choose_pmap_helper<Param,Graph,PropertyTag>::const_result_type
   1.738 +  choose_const_pmap(const Param& p, const Graph& g, PropertyTag tag)
   1.739 +  { 
   1.740 +    typedef typename 
   1.741 +      detail::choose_pmap_helper<Param,Graph,PropertyTag>::Selector Choice;
   1.742 +    return Choice::const_apply(p, g, tag);
   1.743 +  }
   1.744 +
   1.745 +  template <typename Param, typename Graph, typename PropertyTag>
   1.746 +  typename detail::choose_pmap_helper<Param,Graph,PropertyTag>::result_type
   1.747 +  choose_pmap(const Param& p, Graph& g, PropertyTag tag)
   1.748 +  { 
   1.749 +    typedef typename 
   1.750 +      detail::choose_pmap_helper<Param,Graph,PropertyTag>::Selector Choice;
   1.751 +    return Choice::apply(p, g, tag);
   1.752 +  }
   1.753 +
   1.754 +} // namespace boost
   1.755 +
   1.756 +#endif // BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP