boost/graph/named_function_params.hpp

   1 //=======================================================================
   2 // Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
   3 // Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
   4 //
   5 // Distributed under the Boost Software License, Version 1.0. (See
   6 // accompanying file LICENSE_1_0.txt or copy at
   7 // http://www.boost.org/LICENSE_1_0.txt)
   8 //=======================================================================
   9
  10 #ifndef BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP
  11 #define BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP
  12
  13 #include <boost/graph/properties.hpp>
  14
  15 namespace boost {
  16
  17   struct distance_compare_t { };
  18   struct distance_combine_t { };
  19   struct distance_inf_t { };
  20   struct distance_zero_t { };
  21   struct buffer_param_t { };
  22   struct edge_copy_t { };
  23   struct vertex_copy_t { };
  24   struct vertex_isomorphism_t { };
  25   struct vertex_invariant_t { };
  26   struct vertex_invariant1_t { };
  27   struct vertex_invariant2_t { };
  28   struct edge_compare_t { };
  29   struct vertex_max_invariant_t { };
  30   struct orig_to_copy_t { };
  31   struct root_vertex_t { };
  32   struct polling_t { };
  33   struct lookahead_t { };
  34   struct in_parallel_t { };
  35   struct attractive_force_t { };
  36   struct repulsive_force_t { };
  37   struct force_pairs_t { };
  38   struct cooling_t { };
  39   struct vertex_displacement_t { };
  40   struct iterations_t { };
  41   struct diameter_range_t { };
  42   struct learning_constant_range_t { };
  43
  44   namespace detail {
  45     template <class T>
  46     struct wrap_ref {
  47       wrap_ref(T& r) : ref(r) {}
  48       T& ref;
  49     };
  50   }
  51
  52   template <typename T, typename Tag, typename Base = no_property>
  53   struct bgl_named_params : public Base
  54   {
  55     typedef bgl_named_params self;
  56     typedef Base next_type;
  57     typedef Tag tag_type;
  58     typedef T value_type;
  59     bgl_named_params(T v = T()) : m_value(v) { }
  60     bgl_named_params(T v, const Base& b) : Base(b), m_value(v) { }
  61     T m_value;
  62
  63     template <typename WeightMap>
  64     bgl_named_params<WeightMap, edge_weight_t, self>
  65     weight_map(const WeightMap& pmap) const {
  66       typedef bgl_named_params<WeightMap, edge_weight_t, self> Params;
  67       return Params(pmap, *this);
  68     }
  69
  70     template <typename WeightMap>
  71     bgl_named_params<WeightMap, edge_weight2_t, self>
  72     weight_map2(const WeightMap& pmap) const {
  73       typedef bgl_named_params<WeightMap, edge_weight2_t, self> Params;
  74       return Params(pmap, *this);
  75     }
  76
  77     template <typename DistanceMap>
  78     bgl_named_params<DistanceMap, vertex_distance_t, self>
  79     distance_map(const DistanceMap& pmap) const {
  80       typedef bgl_named_params<DistanceMap, vertex_distance_t, self> Params;
  81       return Params(pmap, *this);
  82     }
  83
  84     template <typename PredecessorMap>
  85     bgl_named_params<PredecessorMap, vertex_predecessor_t, self>
  86     predecessor_map(const PredecessorMap& pmap) const {
  87       typedef bgl_named_params<PredecessorMap, vertex_predecessor_t, self>
  88         Params;
  89       return Params(pmap, *this);
  90     }
  91
  92     template <typename RankMap>
  93     bgl_named_params<RankMap, vertex_rank_t, self>
  94     rank_map(const RankMap& pmap) const {
  95       typedef bgl_named_params<RankMap, vertex_rank_t, self>
  96         Params;
  97       return Params(pmap, *this);
  98     }
  99
 100     template <typename RootMap>
 101     bgl_named_params<RootMap, vertex_root_t, self>
 102     root_map(const RootMap& pmap) const {
 103       typedef bgl_named_params<RootMap, vertex_root_t, self>
 104         Params;
 105       return Params(pmap, *this);
 106     }
 107
 108     template <typename Vertex>
 109     bgl_named_params<Vertex, root_vertex_t, self>
 110     root_vertex(const Vertex& r) const {
 111       typedef bgl_named_params<Vertex, root_vertex_t, self> Params;
 112       return Params(r, *this);
 113     }
 114
 115     template <typename EdgeCentralityMap>
 116     bgl_named_params<EdgeCentralityMap, edge_centrality_t, self>
 117     edge_centrality_map(const EdgeCentralityMap& r) const {
 118       typedef bgl_named_params<EdgeCentralityMap, edge_centrality_t, self> Params;
 119       return Params(r, *this);
 120     }
 121
 122     template <typename CentralityMap>
 123     bgl_named_params<CentralityMap, vertex_centrality_t, self>
 124     centrality_map(const CentralityMap& r) const {
 125       typedef bgl_named_params<CentralityMap, vertex_centrality_t, self> Params;
 126       return Params(r, *this);
 127     }
 128
 129     template <typename ColorMap>
 130     bgl_named_params<ColorMap, vertex_color_t, self>
 131     color_map(const ColorMap& pmap) const {
 132       typedef bgl_named_params<ColorMap, vertex_color_t, self> Params;
 133       return Params(pmap, *this);
 134     }
 135
 136     template <typename ColorMap>
 137     bgl_named_params<ColorMap, vertex_color_t, self>
 138     vertex_color_map(const ColorMap& pmap) const {
 139       typedef bgl_named_params<ColorMap, vertex_color_t, self> Params;
 140       return Params(pmap, *this);
 141     }
 142
 143     template <typename ColorMap>
 144     bgl_named_params<ColorMap, edge_color_t, self>
 145     edge_color_map(const ColorMap& pmap) const {
 146       typedef bgl_named_params<ColorMap, edge_color_t, self> Params;
 147       return Params(pmap, *this);
 148     }
 149
 150     template <typename CapacityMap>
 151     bgl_named_params<CapacityMap, edge_capacity_t, self>
 152     capacity_map(CapacityMap pmap) {
 153       typedef bgl_named_params<CapacityMap, edge_capacity_t, self> Params;
 154       return Params(pmap, *this);
 155     }
 156
 157     template <typename Residual_CapacityMap>
 158     bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t, self>
 159     residual_capacity_map(Residual_CapacityMap pmap) {
 160       typedef bgl_named_params<Residual_CapacityMap,
 161         edge_residual_capacity_t, self>
 162         Params;
 163       return Params(pmap, *this);
 164     }
 165
 166     template <typename ReverseMap>
 167     bgl_named_params<ReverseMap, edge_reverse_t, self>
 168     reverse_edge_map(ReverseMap pmap) {
 169       typedef bgl_named_params<ReverseMap,
 170         edge_reverse_t, self>
 171         Params;
 172       return Params(pmap, *this);
 173     }
 174
 175     template <typename DiscoverTimeMap>
 176     bgl_named_params<DiscoverTimeMap, vertex_discover_time_t, self>
 177     discover_time_map(const DiscoverTimeMap& pmap) const {
 178       typedef bgl_named_params<DiscoverTimeMap, vertex_discover_time_t, self>
 179         Params;
 180       return Params(pmap, *this);
 181     }
 182
 183     template <typename LowPointMap>
 184     bgl_named_params<LowPointMap, vertex_lowpoint_t, self>
 185     lowpoint_map(const LowPointMap& pmap) const {
 186       typedef bgl_named_params<LowPointMap, vertex_lowpoint_t, self>
 187         Params;
 188       return Params(pmap, *this);
 189     }
 190
 191     template <typename IndexMap>
 192     bgl_named_params<IndexMap, vertex_index_t, self>
 193     vertex_index_map(const IndexMap& pmap) const {
 194       typedef bgl_named_params<IndexMap, vertex_index_t, self> Params;
 195       return Params(pmap, *this);
 196     }
 197
 198     template <typename IndexMap>
 199     bgl_named_params<IndexMap, vertex_index1_t, self>
 200     vertex_index1_map(const IndexMap& pmap) const {
 201       typedef bgl_named_params<IndexMap, vertex_index1_t, self> Params;
 202       return Params(pmap, *this);
 203     }
 204
 205     template <typename IndexMap>
 206     bgl_named_params<IndexMap, vertex_index2_t, self>
 207     vertex_index2_map(const IndexMap& pmap) const {
 208       typedef bgl_named_params<IndexMap, vertex_index2_t, self> Params;
 209       return Params(pmap, *this);
 210     }
 211
 212     template <typename Visitor>
 213     bgl_named_params<Visitor, graph_visitor_t, self>
 214     visitor(const Visitor& vis) const {
 215       typedef bgl_named_params<Visitor, graph_visitor_t, self> Params;
 216       return Params(vis, *this);
 217     }
 218
 219     template <typename Compare>
 220     bgl_named_params<Compare, distance_compare_t, self>
 221     distance_compare(Compare cmp) const {
 222       typedef bgl_named_params<Compare, distance_compare_t, self> Params;
 223       return Params(cmp, *this);
 224     }
 225
 226     template <typename Combine>
 227     bgl_named_params<Combine, distance_combine_t, self>
 228     distance_combine(Combine cmb) const {
 229       typedef bgl_named_params<Combine, distance_combine_t, self> Params;
 230       return Params(cmb, *this);
 231     }
 232
 233     template <typename Init>
 234     bgl_named_params<Init, distance_inf_t, self>
 235     distance_inf(Init init) const {
 236       typedef bgl_named_params<Init, distance_inf_t, self> Params;
 237       return Params(init, *this);
 238     }
 239
 240     template <typename Init>
 241     bgl_named_params<Init, distance_zero_t, self>
 242     distance_zero(Init init) const {
 243       typedef bgl_named_params<Init, distance_zero_t, self> Params;
 244       return Params(init, *this);
 245     }
 246
 247     template <typename Buffer>
 248     bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t, self>
 249     buffer(Buffer& b) const {
 250       typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t, self>
 251         Params;
 252       return Params(detail::wrap_ref<Buffer>(b), *this);
 253     }
 254
 255     template <typename Copier>
 256     bgl_named_params<Copier, edge_copy_t, self>
 257     edge_copy(const Copier& c) const {
 258       typedef bgl_named_params<Copier, edge_copy_t, self> Params;
 259       return Params(c, *this);
 260     }
 261
 262     template <typename Copier>
 263     bgl_named_params<Copier, vertex_copy_t, self>
 264     vertex_copy(const Copier& c) const {
 265       typedef bgl_named_params<Copier, vertex_copy_t, self> Params;
 266       return Params(c, *this);
 267     }
 268
 269     template <typename Orig2CopyMap>
 270     bgl_named_params<Orig2CopyMap, orig_to_copy_t, self>
 271     orig_to_copy(const Orig2CopyMap& c) const {
 272       typedef bgl_named_params<Orig2CopyMap, orig_to_copy_t, self> Params;
 273       return Params(c, *this);
 274     }
 275
 276     template <typename IsoMap>
 277     bgl_named_params<IsoMap, vertex_isomorphism_t, self>
 278     isomorphism_map(const IsoMap& c) const {
 279       typedef bgl_named_params<IsoMap, vertex_isomorphism_t, self> Params;
 280       return Params(c, *this);
 281     }
 282
 283     template <typename VertexInvar>
 284     bgl_named_params<VertexInvar, vertex_invariant_t, self>
 285     vertex_invariant(const VertexInvar& c) const {
 286       typedef bgl_named_params<VertexInvar, vertex_invariant_t, self> Params;
 287       return Params(c, *this);
 288     }
 289
 290     template <typename VertexInvar>
 291     bgl_named_params<VertexInvar, vertex_invariant1_t, self>
 292     vertex_invariant1(const VertexInvar& c) const {
 293       typedef bgl_named_params<VertexInvar, vertex_invariant1_t, self> Params;
 294       return Params(c, *this);
 295     }
 296
 297     template <typename VertexInvar>
 298     bgl_named_params<VertexInvar, vertex_invariant2_t, self>
 299     vertex_invariant2(const VertexInvar& c) const {
 300       typedef bgl_named_params<VertexInvar, vertex_invariant2_t, self> Params;
 301       return Params(c, *this);
 302     }
 303
 304     template <typename VertexMaxInvar>
 305     bgl_named_params<VertexMaxInvar, vertex_max_invariant_t, self>
 306     vertex_max_invariant(const VertexMaxInvar& c) const {
 307       typedef bgl_named_params<VertexMaxInvar, vertex_max_invariant_t, self> Params;
 308       return Params(c, *this);
 309     }
 310
 311     bgl_named_params<bool, polling_t, self>
 312     polling(bool b) const {
 313       return bgl_named_params<bool, polling_t, self>(b, *this);
 314     }
 315
 316     template<typename Tp>
 317     bgl_named_params<Tp, lookahead_t, self>
 318     lookahead(const Tp& x) const {
 319       return bgl_named_params<Tp, lookahead_t, self>(x, *this);
 320     }
 321
 322     template<typename Tp>
 323     bgl_named_params<Tp, in_parallel_t, self>
 324     in_parallel(const Tp& x) const {
 325       return bgl_named_params<Tp, in_parallel_t, self>(x, *this);
 326     }
 327
 328     template <typename VertexDisplacement>
 329     bgl_named_params<VertexDisplacement, vertex_displacement_t, self>
 330     displacement_map(const VertexDisplacement& c) const {
 331       typedef bgl_named_params<VertexDisplacement, vertex_displacement_t, self> Params;
 332       return Params(c, *this);
 333     }
 334
 335     template <typename AttractiveForce>
 336     bgl_named_params<AttractiveForce, attractive_force_t, self>
 337     attractive_force(const AttractiveForce& c) {
 338       typedef bgl_named_params<AttractiveForce, attractive_force_t, self> Params;
 339       return Params(c, *this);
 340     }
 341
 342     template <typename RepulsiveForce>
 343     bgl_named_params<RepulsiveForce, repulsive_force_t, self>
 344     repulsive_force(const RepulsiveForce& c) {
 345       typedef bgl_named_params<RepulsiveForce, repulsive_force_t, self> Params;
 346       return Params(c, *this);
 347     }
 348
 349     template <typename ForcePairs>
 350     bgl_named_params<ForcePairs, force_pairs_t, self>
 351     force_pairs(const ForcePairs& c) {
 352       typedef bgl_named_params<ForcePairs, force_pairs_t, self> Params;
 353       return Params(c, *this);
 354     }
 355
 356     template <typename Cooling>
 357     bgl_named_params<Cooling, cooling_t, self>
 358     cooling(const Cooling& c) {
 359       typedef bgl_named_params<Cooling, cooling_t, self> Params;
 360       return Params(c, *this);
 361     }
 362
 363     template <typename TP>
 364     bgl_named_params<TP, iterations_t, self>
 365     iterations(const TP& c) {
 366       typedef bgl_named_params<TP, iterations_t, self> Params;
 367       return Params(c, *this);
 368     }
 369
 370     template<typename TP>
 371     bgl_named_params<std::pair<TP, TP>, diameter_range_t, self>
 372     diameter_range(const std::pair<TP, TP>& c) {
 373       typedef bgl_named_params<std::pair<TP, TP>, diameter_range_t, self> Params;
 374       return Params(c, *this);
 375     }
 376
 377     template<typename TP>
 378     bgl_named_params<std::pair<TP, TP>, learning_constant_range_t, self>
 379     learning_constant_range(const std::pair<TP, TP>& c) {
 380       typedef bgl_named_params<std::pair<TP, TP>, learning_constant_range_t, self>
 381         Params;
 382       return Params(c, *this);
 383     }
 384   };
 385
 386   template <typename WeightMap>
 387   bgl_named_params<WeightMap, edge_weight_t>
 388   weight_map(WeightMap pmap) {
 389     typedef bgl_named_params<WeightMap, edge_weight_t> Params;
 390     return Params(pmap);
 391   }
 392
 393   template <typename WeightMap>
 394   bgl_named_params<WeightMap, edge_weight2_t>
 395   weight_map2(WeightMap pmap) {
 396     typedef bgl_named_params<WeightMap, edge_weight2_t> Params;
 397     return Params(pmap);
 398   }
 399
 400   template <typename DistanceMap>
 401   bgl_named_params<DistanceMap, vertex_distance_t>
 402   distance_map(DistanceMap pmap) {
 403     typedef bgl_named_params<DistanceMap, vertex_distance_t> Params;
 404     return Params(pmap);
 405   }
 406
 407   template <typename PredecessorMap>
 408   bgl_named_params<PredecessorMap, vertex_predecessor_t>
 409   predecessor_map(PredecessorMap pmap) {
 410     typedef bgl_named_params<PredecessorMap, vertex_predecessor_t> Params;
 411     return Params(pmap);
 412   }
 413
 414   template <typename RankMap>
 415   bgl_named_params<RankMap, vertex_rank_t>
 416   rank_map(RankMap pmap) {
 417     typedef bgl_named_params<RankMap, vertex_rank_t> Params;
 418     return Params(pmap);
 419   }
 420
 421   template <typename RootMap>
 422   bgl_named_params<RootMap, vertex_root_t>
 423   root_map(RootMap pmap) {
 424     typedef bgl_named_params<RootMap, vertex_root_t> Params;
 425     return Params(pmap);
 426   }
 427
 428   template <typename Vertex>
 429   bgl_named_params<Vertex, root_vertex_t>
 430   root_vertex(const Vertex& r) {
 431     typedef bgl_named_params<Vertex, root_vertex_t> Params;
 432     return Params(r);
 433   }
 434
 435   template <typename EdgeCentralityMap>
 436   bgl_named_params<EdgeCentralityMap, edge_centrality_t>
 437   edge_centrality_map(const EdgeCentralityMap& r) {
 438     typedef bgl_named_params<EdgeCentralityMap, edge_centrality_t> Params;
 439     return Params(r);
 440   }
 441
 442   template <typename CentralityMap>
 443   bgl_named_params<CentralityMap, vertex_centrality_t>
 444   centrality_map(const CentralityMap& r) {
 445     typedef bgl_named_params<CentralityMap, vertex_centrality_t> Params;
 446     return Params(r);
 447   }
 448
 449   template <typename ColorMap>
 450   bgl_named_params<ColorMap, vertex_color_t>
 451   color_map(ColorMap pmap) {
 452     typedef bgl_named_params<ColorMap, vertex_color_t> Params;
 453     return Params(pmap);
 454   }
 455
 456   template <typename CapacityMap>
 457   bgl_named_params<CapacityMap, edge_capacity_t>
 458   capacity_map(CapacityMap pmap) {
 459     typedef bgl_named_params<CapacityMap, edge_capacity_t> Params;
 460     return Params(pmap);
 461   }
 462
 463   template <typename Residual_CapacityMap>
 464   bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t>
 465   residual_capacity_map(Residual_CapacityMap pmap) {
 466     typedef bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t>
 467       Params;
 468     return Params(pmap);
 469   }
 470
 471   template <typename ReverseMap>
 472   bgl_named_params<ReverseMap, edge_reverse_t>
 473   reverse_edge_map(ReverseMap pmap) {
 474     typedef bgl_named_params<ReverseMap, edge_reverse_t>
 475       Params;
 476     return Params(pmap);
 477   }
 478
 479   template <typename DiscoverTimeMap>
 480   bgl_named_params<DiscoverTimeMap, vertex_discover_time_t>
 481   discover_time_map(DiscoverTimeMap pmap) {
 482     typedef bgl_named_params<DiscoverTimeMap, vertex_discover_time_t> Params;
 483     return Params(pmap);
 484   }
 485
 486   template <typename LowPointMap>
 487   bgl_named_params<LowPointMap, vertex_lowpoint_t>
 488   lowpoint_map(LowPointMap pmap) {
 489     typedef bgl_named_params<LowPointMap, vertex_lowpoint_t> Params;
 490     return Params(pmap);
 491   }
 492
 493   template <typename IndexMap>
 494   bgl_named_params<IndexMap, vertex_index_t>
 495   vertex_index_map(IndexMap pmap) {
 496     typedef bgl_named_params<IndexMap, vertex_index_t> Params;
 497     return Params(pmap);
 498   }
 499
 500   template <typename IndexMap>
 501   bgl_named_params<IndexMap, vertex_index1_t>
 502   vertex_index1_map(const IndexMap& pmap) {
 503     typedef bgl_named_params<IndexMap, vertex_index1_t> Params;
 504     return Params(pmap);
 505   }
 506
 507   template <typename IndexMap>
 508   bgl_named_params<IndexMap, vertex_index2_t>
 509   vertex_index2_map(const IndexMap& pmap) {
 510     typedef bgl_named_params<IndexMap, vertex_index2_t> Params;
 511     return Params(pmap);
 512   }
 513
 514   template <typename Visitor>
 515   bgl_named_params<Visitor, graph_visitor_t>
 516   visitor(const Visitor& vis) {
 517     typedef bgl_named_params<Visitor, graph_visitor_t> Params;
 518     return Params(vis);
 519   }
 520
 521   template <typename Compare>
 522   bgl_named_params<Compare, distance_compare_t>
 523   distance_compare(Compare cmp) {
 524     typedef bgl_named_params<Compare, distance_compare_t> Params;
 525     return Params(cmp);
 526   }
 527
 528   template <typename Combine>
 529   bgl_named_params<Combine, distance_combine_t>
 530   distance_combine(Combine cmb) {
 531     typedef bgl_named_params<Combine, distance_combine_t> Params;
 532     return Params(cmb);
 533   }
 534
 535   template <typename Init>
 536   bgl_named_params<Init, distance_inf_t>
 537   distance_inf(Init init) {
 538     typedef bgl_named_params<Init, distance_inf_t> Params;
 539     return Params(init);
 540   }
 541
 542   template <typename Init>
 543   bgl_named_params<Init, distance_zero_t>
 544   distance_zero(Init init) {
 545     typedef bgl_named_params<Init, distance_zero_t> Params;
 546     return Params(init);
 547   }
 548
 549   template <typename Buffer>
 550   bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t>
 551   buffer(Buffer& b) {
 552     typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t> Params;
 553     return Params(detail::wrap_ref<Buffer>(b));
 554   }
 555
 556   template <typename Copier>
 557   bgl_named_params<Copier, edge_copy_t>
 558   edge_copy(const Copier& c) {
 559     typedef bgl_named_params<Copier, edge_copy_t> Params;
 560     return Params(c);
 561   }
 562
 563   template <typename Copier>
 564   bgl_named_params<Copier, vertex_copy_t>
 565   vertex_copy(const Copier& c) {
 566     typedef bgl_named_params<Copier, vertex_copy_t> Params;
 567     return Params(c);
 568   }
 569
 570   template <typename Orig2CopyMap>
 571   bgl_named_params<Orig2CopyMap, orig_to_copy_t>
 572   orig_to_copy(const Orig2CopyMap& c) {
 573     typedef bgl_named_params<Orig2CopyMap, orig_to_copy_t> Params;
 574     return Params(c);
 575   }
 576
 577   template <typename IsoMap>
 578   bgl_named_params<IsoMap, vertex_isomorphism_t>
 579   isomorphism_map(const IsoMap& c) {
 580     typedef bgl_named_params<IsoMap, vertex_isomorphism_t> Params;
 581     return Params(c);
 582   }
 583
 584   template <typename VertexInvar>
 585   bgl_named_params<VertexInvar, vertex_invariant_t>
 586   vertex_invariant(const VertexInvar& c) {
 587     typedef bgl_named_params<VertexInvar, vertex_invariant_t> Params;
 588     return Params(c);
 589   }
 590
 591   template <typename VertexInvar>
 592   bgl_named_params<VertexInvar, vertex_invariant1_t>
 593   vertex_invariant1(const VertexInvar& c) {
 594     typedef bgl_named_params<VertexInvar, vertex_invariant1_t> Params;
 595     return Params(c);
 596   }
 597
 598   template <typename VertexInvar>
 599   bgl_named_params<VertexInvar, vertex_invariant2_t>
 600   vertex_invariant2(const VertexInvar& c) {
 601     typedef bgl_named_params<VertexInvar, vertex_invariant2_t> Params;
 602     return Params(c);
 603   }
 604
 605   template <typename VertexMaxInvar>
 606   bgl_named_params<VertexMaxInvar, vertex_max_invariant_t>
 607   vertex_max_invariant(const VertexMaxInvar& c) {
 608     typedef bgl_named_params<VertexMaxInvar, vertex_max_invariant_t> Params;
 609     return Params(c);
 610   }
 611
 612   bgl_named_params<bool, polling_t>
 613   inline polling(bool b) {
 614     return bgl_named_params<bool, polling_t>(b);
 615   }
 616
 617
 618   template<typename T>
 619   bgl_named_params<T, lookahead_t>
 620   lookahead(const T& x) {
 621     return bgl_named_params<T, lookahead_t>(x);
 622   }
 623
 624   template<typename T>
 625   bgl_named_params<T, in_parallel_t>
 626   in_parallel(const T& x) {
 627     return bgl_named_params<T, in_parallel_t>(x);
 628   }
 629
 630   template <typename VertexDisplacement>
 631   bgl_named_params<VertexDisplacement, vertex_displacement_t>
 632   displacement_map(const VertexDisplacement& c) {
 633     typedef bgl_named_params<VertexDisplacement, vertex_displacement_t> Params;
 634     return Params(c);
 635   }
 636
 637   template <typename AttractiveForce>
 638   bgl_named_params<AttractiveForce, attractive_force_t>
 639   attractive_force(const AttractiveForce& c) {
 640     typedef bgl_named_params<AttractiveForce, attractive_force_t> Params;
 641     return Params(c);
 642   }
 643
 644   template <typename RepulsiveForce>
 645   bgl_named_params<RepulsiveForce, repulsive_force_t>
 646   repulsive_force(const RepulsiveForce& c) {
 647     typedef bgl_named_params<RepulsiveForce, repulsive_force_t> Params;
 648     return Params(c);
 649   }
 650
 651   template <typename ForcePairs>
 652   bgl_named_params<ForcePairs, force_pairs_t>
 653   force_pairs(const ForcePairs& c) {
 654     typedef bgl_named_params<ForcePairs, force_pairs_t> Params;
 655     return Params(c);
 656   }
 657
 658   template <typename Cooling>
 659   bgl_named_params<Cooling, cooling_t>
 660   cooling(const Cooling& c) {
 661     typedef bgl_named_params<Cooling, cooling_t> Params;
 662     return Params(c);
 663   }
 664
 665   template <typename T>
 666   bgl_named_params<T, iterations_t>
 667   iterations(const T& c) {
 668     typedef bgl_named_params<T, iterations_t> Params;
 669     return Params(c);
 670   }
 671
 672   template<typename T>
 673   bgl_named_params<std::pair<T, T>, diameter_range_t>
 674   diameter_range(const std::pair<T, T>& c) {
 675     typedef bgl_named_params<std::pair<T, T>, diameter_range_t> Params;
 676     return Params(c);
 677   }
 678
 679   template<typename T>
 680   bgl_named_params<std::pair<T, T>, learning_constant_range_t>
 681   learning_constant_range(const std::pair<T, T>& c) {
 682     typedef bgl_named_params<std::pair<T, T>, learning_constant_range_t>
 683       Params;
 684     return Params(c);
 685   }
 686
 687   namespace detail {
 688     struct unused_tag_type {};
 689   }
 690   typedef bgl_named_params<char, detail::unused_tag_type> no_named_parameters;
 691
 692   //===========================================================================
 693   // Functions for extracting parameters from bgl_named_params
 694
 695   template <class Tag1, class Tag2, class T1, class Base>
 696   inline
 697   typename property_value< bgl_named_params<T1,Tag1,Base>, Tag2>::type
 698   get_param(const bgl_named_params<T1,Tag1,Base>& p, Tag2 tag2)
 699   {
 700     enum { match = detail::same_property<Tag1,Tag2>::value };
 701     typedef typename
 702       property_value< bgl_named_params<T1,Tag1,Base>, Tag2>::type T2;
 703     T2* t2 = 0;
 704     typedef detail::property_value_dispatch<match> Dispatcher;
 705     return Dispatcher::const_get_value(p, t2, tag2);
 706   }
 707
 708
 709   namespace detail {
 710     // MSVC++ workaround
 711     template <class Param>
 712     struct choose_param_helper {
 713       template <class Default> struct result { typedef Param type; };
 714       template <typename Default>
 715       static const Param& apply(const Param& p, const Default&) { return p; }
 716     };
 717     template <>
 718     struct choose_param_helper<error_property_not_found> {
 719       template <class Default> struct result { typedef Default type; };
 720       template <typename Default>
 721       static const Default& apply(const error_property_not_found&, const Default& d)
 722         { return d; }
 723     };
 724   } // namespace detail
 725
 726   template <class P, class Default>
 727   const typename detail::choose_param_helper<P>::template result<Default>::type&
 728   choose_param(const P& param, const Default& d) {
 729     return detail::choose_param_helper<P>::apply(param, d);
 730   }
 731
 732   template <typename T>
 733   inline bool is_default_param(const T&) { return false; }
 734
 735   inline bool is_default_param(const detail::error_property_not_found&)
 736     { return true; }
 737
 738   namespace detail {
 739
 740     struct choose_parameter {
 741       template <class P, class Graph, class Tag>
 742       struct bind_ {
 743         typedef const P& const_result_type;
 744         typedef const P& result_type;
 745         typedef P type;
 746       };
 747
 748       template <class P, class Graph, class Tag>
 749       static typename bind_<P, Graph, Tag>::const_result_type
 750       const_apply(const P& p, const Graph&, Tag&)
 751       { return p; }
 752
 753       template <class P, class Graph, class Tag>
 754       static typename bind_<P, Graph, Tag>::result_type
 755       apply(const P& p, Graph&, Tag&)
 756       { return p; }
 757     };
 758
 759     struct choose_default_param {
 760       template <class P, class Graph, class Tag>
 761       struct bind_ {
 762         typedef typename property_map<Graph, Tag>::type
 763           result_type;
 764         typedef typename property_map<Graph, Tag>::const_type
 765           const_result_type;
 766         typedef typename property_map<Graph, Tag>::const_type
 767           type;
 768       };
 769
 770       template <class P, class Graph, class Tag>
 771       static typename bind_<P, Graph, Tag>::const_result_type
 772       const_apply(const P&, const Graph& g, Tag tag) {
 773         return get(tag, g);
 774       }
 775       template <class P, class Graph, class Tag>
 776       static typename bind_<P, Graph, Tag>::result_type
 777       apply(const P&, Graph& g, Tag tag) {
 778         return get(tag, g);
 779       }
 780     };
 781
 782     template <class Param>
 783     struct choose_property_map {
 784       typedef choose_parameter type;
 785     };
 786     template <>
 787     struct choose_property_map<detail::error_property_not_found> {
 788       typedef choose_default_param type;
 789     };
 790
 791     template <class Param, class Graph, class Tag>
 792     struct choose_pmap_helper {
 793       typedef typename choose_property_map<Param>::type Selector;
 794       typedef typename Selector:: template bind_<Param, Graph, Tag> Bind;
 795       typedef Bind type;
 796       typedef typename Bind::result_type result_type;
 797       typedef typename Bind::const_result_type const_result_type;
 798       typedef typename Bind::type result;
 799     };
 800
 801     // used in the max-flow algorithms
 802     template <class Graph, class P, class T, class R>
 803     struct edge_capacity_value
 804     {
 805       typedef bgl_named_params<P, T, R> Params;
 806       typedef typename property_value< Params, edge_capacity_t>::type Param;
 807       typedef typename detail::choose_pmap_helper<Param, Graph,
 808         edge_capacity_t>::result CapacityEdgeMap;
 809       typedef typename property_traits<CapacityEdgeMap>::value_type type;
 810     };
 811
 812   } // namespace detail
 813
 814
 815   // Use this function instead of choose_param() when you want
 816   // to avoid requiring get(tag, g) when it is not used.
 817   template <typename Param, typename Graph, typename PropertyTag>
 818   typename
 819     detail::choose_pmap_helper<Param,Graph,PropertyTag>::const_result_type
 820   choose_const_pmap(const Param& p, const Graph& g, PropertyTag tag)
 821   {
 822     typedef typename
 823       detail::choose_pmap_helper<Param,Graph,PropertyTag>::Selector Choice;
 824     return Choice::const_apply(p, g, tag);
 825   }
 826
 827   template <typename Param, typename Graph, typename PropertyTag>
 828   typename detail::choose_pmap_helper<Param,Graph,PropertyTag>::result_type
 829   choose_pmap(const Param& p, Graph& g, PropertyTag tag)
 830   {
 831     typedef typename
 832       detail::choose_pmap_helper<Param,Graph,PropertyTag>::Selector Choice;
 833     return Choice::apply(p, g, tag);
 834   }
 835
 836 } // namespace boost
 837
 838 #endif // BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP