1 //=======================================================================
2 // Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
3 // Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
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 //=======================================================================
10 #ifndef BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP
11 #define BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP
13 #include <boost/graph/properties.hpp>
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 attractive_force_t { };
33 struct repulsive_force_t { };
34 struct force_pairs_t { };
36 struct vertex_displacement_t { };
37 struct iterations_t { };
38 struct diameter_range_t { };
39 struct learning_constant_range_t { };
44 wrap_ref(T& r) : ref(r) {}
49 template <typename T, typename Tag, typename Base = no_property>
50 struct bgl_named_params : public Base
52 typedef bgl_named_params self;
53 typedef Base next_type;
56 bgl_named_params(T v) : m_value(v) { }
57 bgl_named_params(T v, const Base& b) : Base(b), m_value(v) { }
60 template <typename WeightMap>
61 bgl_named_params<WeightMap, edge_weight_t, self>
62 weight_map(const WeightMap& pmap) const {
63 typedef bgl_named_params<WeightMap, edge_weight_t, self> Params;
64 return Params(pmap, *this);
67 template <typename WeightMap>
68 bgl_named_params<WeightMap, edge_weight2_t, self>
69 weight_map2(const WeightMap& pmap) const {
70 typedef bgl_named_params<WeightMap, edge_weight2_t, self> Params;
71 return Params(pmap, *this);
74 template <typename DistanceMap>
75 bgl_named_params<DistanceMap, vertex_distance_t, self>
76 distance_map(const DistanceMap& pmap) const {
77 typedef bgl_named_params<DistanceMap, vertex_distance_t, self> Params;
78 return Params(pmap, *this);
81 template <typename PredecessorMap>
82 bgl_named_params<PredecessorMap, vertex_predecessor_t, self>
83 predecessor_map(const PredecessorMap& pmap) const {
84 typedef bgl_named_params<PredecessorMap, vertex_predecessor_t, self>
86 return Params(pmap, *this);
89 template <typename RankMap>
90 bgl_named_params<RankMap, vertex_rank_t, self>
91 rank_map(const RankMap& pmap) const {
92 typedef bgl_named_params<RankMap, vertex_rank_t, self>
94 return Params(pmap, *this);
97 template <typename RootMap>
98 bgl_named_params<RootMap, vertex_root_t, self>
99 root_map(const RootMap& pmap) const {
100 typedef bgl_named_params<RootMap, vertex_root_t, self>
102 return Params(pmap, *this);
105 template <typename Vertex>
106 bgl_named_params<Vertex, root_vertex_t, self>
107 root_vertex(const Vertex& r) const {
108 typedef bgl_named_params<Vertex, root_vertex_t, self> Params;
109 return Params(r, *this);
112 template <typename EdgeCentralityMap>
113 bgl_named_params<EdgeCentralityMap, edge_centrality_t, self>
114 edge_centrality_map(const EdgeCentralityMap& r) const {
115 typedef bgl_named_params<EdgeCentralityMap, edge_centrality_t, self> Params;
116 return Params(r, *this);
119 template <typename CentralityMap>
120 bgl_named_params<CentralityMap, vertex_centrality_t, self>
121 centrality_map(const CentralityMap& r) const {
122 typedef bgl_named_params<CentralityMap, vertex_centrality_t, self> Params;
123 return Params(r, *this);
126 template <typename ColorMap>
127 bgl_named_params<ColorMap, vertex_color_t, self>
128 color_map(const ColorMap& pmap) const {
129 typedef bgl_named_params<ColorMap, vertex_color_t, self> Params;
130 return Params(pmap, *this);
133 template <typename ColorMap>
134 bgl_named_params<ColorMap, vertex_color_t, self>
135 vertex_color_map(const ColorMap& pmap) const {
136 typedef bgl_named_params<ColorMap, vertex_color_t, self> Params;
137 return Params(pmap, *this);
140 template <typename ColorMap>
141 bgl_named_params<ColorMap, edge_color_t, self>
142 edge_color_map(const ColorMap& pmap) const {
143 typedef bgl_named_params<ColorMap, edge_color_t, self> Params;
144 return Params(pmap, *this);
147 template <typename CapacityMap>
148 bgl_named_params<CapacityMap, edge_capacity_t, self>
149 capacity_map(CapacityMap pmap) {
150 typedef bgl_named_params<CapacityMap, edge_capacity_t, self> Params;
151 return Params(pmap, *this);
154 template <typename Residual_CapacityMap>
155 bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t, self>
156 residual_capacity_map(Residual_CapacityMap pmap) {
157 typedef bgl_named_params<Residual_CapacityMap,
158 edge_residual_capacity_t, self>
160 return Params(pmap, *this);
163 template <typename ReverseMap>
164 bgl_named_params<ReverseMap, edge_reverse_t, self>
165 reverse_edge_map(ReverseMap pmap) {
166 typedef bgl_named_params<ReverseMap,
167 edge_reverse_t, self>
169 return Params(pmap, *this);
172 template <typename DiscoverTimeMap>
173 bgl_named_params<DiscoverTimeMap, vertex_discover_time_t, self>
174 discover_time_map(const DiscoverTimeMap& pmap) const {
175 typedef bgl_named_params<DiscoverTimeMap, vertex_discover_time_t, self>
177 return Params(pmap, *this);
180 template <typename LowPointMap>
181 bgl_named_params<LowPointMap, vertex_lowpoint_t, self>
182 lowpoint_map(const LowPointMap& pmap) const {
183 typedef bgl_named_params<LowPointMap, vertex_lowpoint_t, self>
185 return Params(pmap, *this);
188 template <typename IndexMap>
189 bgl_named_params<IndexMap, vertex_index_t, self>
190 vertex_index_map(const IndexMap& pmap) const {
191 typedef bgl_named_params<IndexMap, vertex_index_t, self> Params;
192 return Params(pmap, *this);
195 template <typename IndexMap>
196 bgl_named_params<IndexMap, vertex_index1_t, self>
197 vertex_index1_map(const IndexMap& pmap) const {
198 typedef bgl_named_params<IndexMap, vertex_index1_t, self> Params;
199 return Params(pmap, *this);
202 template <typename IndexMap>
203 bgl_named_params<IndexMap, vertex_index2_t, self>
204 vertex_index2_map(const IndexMap& pmap) const {
205 typedef bgl_named_params<IndexMap, vertex_index2_t, self> Params;
206 return Params(pmap, *this);
209 template <typename Visitor>
210 bgl_named_params<Visitor, graph_visitor_t, self>
211 visitor(const Visitor& vis) const {
212 typedef bgl_named_params<Visitor, graph_visitor_t, self> Params;
213 return Params(vis, *this);
216 template <typename Compare>
217 bgl_named_params<Compare, distance_compare_t, self>
218 distance_compare(Compare cmp) const {
219 typedef bgl_named_params<Compare, distance_compare_t, self> Params;
220 return Params(cmp, *this);
223 template <typename Combine>
224 bgl_named_params<Combine, distance_combine_t, self>
225 distance_combine(Combine cmb) const {
226 typedef bgl_named_params<Combine, distance_combine_t, self> Params;
227 return Params(cmb, *this);
230 template <typename Init>
231 bgl_named_params<Init, distance_inf_t, self>
232 distance_inf(Init init) const {
233 typedef bgl_named_params<Init, distance_inf_t, self> Params;
234 return Params(init, *this);
237 template <typename Init>
238 bgl_named_params<Init, distance_zero_t, self>
239 distance_zero(Init init) const {
240 typedef bgl_named_params<Init, distance_zero_t, self> Params;
241 return Params(init, *this);
244 template <typename Buffer>
245 bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t, self>
246 buffer(Buffer& b) const {
247 typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t, self>
249 return Params(detail::wrap_ref<Buffer>(b), *this);
252 template <typename Copier>
253 bgl_named_params<Copier, edge_copy_t, self>
254 edge_copy(const Copier& c) const {
255 typedef bgl_named_params<Copier, edge_copy_t, self> Params;
256 return Params(c, *this);
259 template <typename Copier>
260 bgl_named_params<Copier, vertex_copy_t, self>
261 vertex_copy(const Copier& c) const {
262 typedef bgl_named_params<Copier, vertex_copy_t, self> Params;
263 return Params(c, *this);
266 template <typename Orig2CopyMap>
267 bgl_named_params<Orig2CopyMap, orig_to_copy_t, self>
268 orig_to_copy(const Orig2CopyMap& c) const {
269 typedef bgl_named_params<Orig2CopyMap, orig_to_copy_t, self> Params;
270 return Params(c, *this);
273 template <typename IsoMap>
274 bgl_named_params<IsoMap, vertex_isomorphism_t, self>
275 isomorphism_map(const IsoMap& c) const {
276 typedef bgl_named_params<IsoMap, vertex_isomorphism_t, self> Params;
277 return Params(c, *this);
280 template <typename VertexInvar>
281 bgl_named_params<VertexInvar, vertex_invariant_t, self>
282 vertex_invariant(const VertexInvar& c) const {
283 typedef bgl_named_params<VertexInvar, vertex_invariant_t, self> Params;
284 return Params(c, *this);
287 template <typename VertexDisplacement>
288 bgl_named_params<VertexDisplacement, vertex_displacement_t, self>
289 displacement_map(const VertexDisplacement& c) const {
290 typedef bgl_named_params<VertexDisplacement, vertex_displacement_t, self> Params;
291 return Params(c, *this);
294 template <typename AttractiveForce>
295 bgl_named_params<AttractiveForce, attractive_force_t, self>
296 attractive_force(const AttractiveForce& c) {
297 typedef bgl_named_params<AttractiveForce, attractive_force_t, self> Params;
298 return Params(c, *this);
301 template <typename RepulsiveForce>
302 bgl_named_params<RepulsiveForce, repulsive_force_t, self>
303 repulsive_force(const RepulsiveForce& c) {
304 typedef bgl_named_params<RepulsiveForce, repulsive_force_t, self> Params;
305 return Params(c, *this);
308 template <typename ForcePairs>
309 bgl_named_params<ForcePairs, force_pairs_t, self>
310 force_pairs(const ForcePairs& c) {
311 typedef bgl_named_params<ForcePairs, force_pairs_t, self> Params;
312 return Params(c, *this);
315 template <typename Cooling>
316 bgl_named_params<Cooling, cooling_t, self>
317 cooling(const Cooling& c) {
318 typedef bgl_named_params<Cooling, cooling_t, self> Params;
319 return Params(c, *this);
322 template <typename TP>
323 bgl_named_params<TP, iterations_t, self>
324 iterations(const TP& c) {
325 typedef bgl_named_params<TP, iterations_t, self> Params;
326 return Params(c, *this);
329 template<typename TP>
330 bgl_named_params<std::pair<TP, TP>, diameter_range_t, self>
331 diameter_range(const std::pair<TP, TP>& c) {
332 typedef bgl_named_params<std::pair<TP, TP>, diameter_range_t, self> Params;
333 return Params(c, *this);
336 template<typename TP>
337 bgl_named_params<std::pair<TP, TP>, learning_constant_range_t, self>
338 learning_constant_range(const std::pair<TP, TP>& c) {
339 typedef bgl_named_params<std::pair<TP, TP>, learning_constant_range_t, self>
341 return Params(c, *this);
345 template <typename WeightMap>
346 bgl_named_params<WeightMap, edge_weight_t>
347 weight_map(WeightMap pmap) {
348 typedef bgl_named_params<WeightMap, edge_weight_t> Params;
352 template <typename WeightMap>
353 bgl_named_params<WeightMap, edge_weight2_t>
354 weight_map2(WeightMap pmap) {
355 typedef bgl_named_params<WeightMap, edge_weight2_t> Params;
359 template <typename DistanceMap>
360 bgl_named_params<DistanceMap, vertex_distance_t>
361 distance_map(DistanceMap pmap) {
362 typedef bgl_named_params<DistanceMap, vertex_distance_t> Params;
366 template <typename PredecessorMap>
367 bgl_named_params<PredecessorMap, vertex_predecessor_t>
368 predecessor_map(PredecessorMap pmap) {
369 typedef bgl_named_params<PredecessorMap, vertex_predecessor_t> Params;
373 template <typename RankMap>
374 bgl_named_params<RankMap, vertex_rank_t>
375 rank_map(RankMap pmap) {
376 typedef bgl_named_params<RankMap, vertex_rank_t> Params;
380 template <typename RootMap>
381 bgl_named_params<RootMap, vertex_root_t>
382 root_map(RootMap pmap) {
383 typedef bgl_named_params<RootMap, vertex_root_t> Params;
387 template <typename Vertex>
388 bgl_named_params<Vertex, root_vertex_t>
389 root_vertex(const Vertex& r) {
390 typedef bgl_named_params<Vertex, root_vertex_t> Params;
394 template <typename EdgeCentralityMap>
395 bgl_named_params<EdgeCentralityMap, edge_centrality_t>
396 edge_centrality_map(const EdgeCentralityMap& r) {
397 typedef bgl_named_params<EdgeCentralityMap, edge_centrality_t> Params;
401 template <typename CentralityMap>
402 bgl_named_params<CentralityMap, vertex_centrality_t>
403 centrality_map(const CentralityMap& r) {
404 typedef bgl_named_params<CentralityMap, vertex_centrality_t> Params;
408 template <typename ColorMap>
409 bgl_named_params<ColorMap, vertex_color_t>
410 color_map(ColorMap pmap) {
411 typedef bgl_named_params<ColorMap, vertex_color_t> Params;
415 template <typename CapacityMap>
416 bgl_named_params<CapacityMap, edge_capacity_t>
417 capacity_map(CapacityMap pmap) {
418 typedef bgl_named_params<CapacityMap, edge_capacity_t> Params;
422 template <typename Residual_CapacityMap>
423 bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t>
424 residual_capacity_map(Residual_CapacityMap pmap) {
425 typedef bgl_named_params<Residual_CapacityMap, edge_residual_capacity_t>
430 template <typename ReverseMap>
431 bgl_named_params<ReverseMap, edge_reverse_t>
432 reverse_edge_map(ReverseMap pmap) {
433 typedef bgl_named_params<ReverseMap, edge_reverse_t>
438 template <typename DiscoverTimeMap>
439 bgl_named_params<DiscoverTimeMap, vertex_discover_time_t>
440 discover_time_map(DiscoverTimeMap pmap) {
441 typedef bgl_named_params<DiscoverTimeMap, vertex_discover_time_t> Params;
445 template <typename LowPointMap>
446 bgl_named_params<LowPointMap, vertex_lowpoint_t>
447 lowpoint_map(LowPointMap pmap) {
448 typedef bgl_named_params<LowPointMap, vertex_lowpoint_t> Params;
452 template <typename IndexMap>
453 bgl_named_params<IndexMap, vertex_index_t>
454 vertex_index_map(IndexMap pmap) {
455 typedef bgl_named_params<IndexMap, vertex_index_t> Params;
459 template <typename IndexMap>
460 bgl_named_params<IndexMap, vertex_index1_t>
461 vertex_index1_map(const IndexMap& pmap) {
462 typedef bgl_named_params<IndexMap, vertex_index1_t> Params;
466 template <typename IndexMap>
467 bgl_named_params<IndexMap, vertex_index2_t>
468 vertex_index2_map(const IndexMap& pmap) {
469 typedef bgl_named_params<IndexMap, vertex_index2_t> Params;
473 template <typename Visitor>
474 bgl_named_params<Visitor, graph_visitor_t>
475 visitor(const Visitor& vis) {
476 typedef bgl_named_params<Visitor, graph_visitor_t> Params;
480 template <typename Compare>
481 bgl_named_params<Compare, distance_compare_t>
482 distance_compare(Compare cmp) {
483 typedef bgl_named_params<Compare, distance_compare_t> Params;
487 template <typename Combine>
488 bgl_named_params<Combine, distance_combine_t>
489 distance_combine(Combine cmb) {
490 typedef bgl_named_params<Combine, distance_combine_t> Params;
494 template <typename Init>
495 bgl_named_params<Init, distance_inf_t>
496 distance_inf(Init init) {
497 typedef bgl_named_params<Init, distance_inf_t> Params;
501 template <typename Init>
502 bgl_named_params<Init, distance_zero_t>
503 distance_zero(Init init) {
504 typedef bgl_named_params<Init, distance_zero_t> Params;
508 template <typename Buffer>
509 bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t>
511 typedef bgl_named_params<detail::wrap_ref<Buffer>, buffer_param_t> Params;
512 return Params(detail::wrap_ref<Buffer>(b));
515 template <typename Copier>
516 bgl_named_params<Copier, edge_copy_t>
517 edge_copy(const Copier& c) {
518 typedef bgl_named_params<Copier, edge_copy_t> Params;
522 template <typename Copier>
523 bgl_named_params<Copier, vertex_copy_t>
524 vertex_copy(const Copier& c) {
525 typedef bgl_named_params<Copier, vertex_copy_t> Params;
529 template <typename Orig2CopyMap>
530 bgl_named_params<Orig2CopyMap, orig_to_copy_t>
531 orig_to_copy(const Orig2CopyMap& c) {
532 typedef bgl_named_params<Orig2CopyMap, orig_to_copy_t> Params;
536 template <typename IsoMap>
537 bgl_named_params<IsoMap, vertex_isomorphism_t>
538 isomorphism_map(const IsoMap& c) {
539 typedef bgl_named_params<IsoMap, vertex_isomorphism_t> Params;
543 template <typename VertexInvar>
544 bgl_named_params<VertexInvar, vertex_invariant_t>
545 vertex_invariant(const VertexInvar& c) {
546 typedef bgl_named_params<VertexInvar, vertex_invariant_t> Params;
550 template <typename VertexDisplacement>
551 bgl_named_params<VertexDisplacement, vertex_displacement_t>
552 displacement_map(const VertexDisplacement& c) {
553 typedef bgl_named_params<VertexDisplacement, vertex_displacement_t> Params;
557 template <typename AttractiveForce>
558 bgl_named_params<AttractiveForce, attractive_force_t>
559 attractive_force(const AttractiveForce& c) {
560 typedef bgl_named_params<AttractiveForce, attractive_force_t> Params;
564 template <typename RepulsiveForce>
565 bgl_named_params<RepulsiveForce, repulsive_force_t>
566 repulsive_force(const RepulsiveForce& c) {
567 typedef bgl_named_params<RepulsiveForce, repulsive_force_t> Params;
571 template <typename ForcePairs>
572 bgl_named_params<ForcePairs, force_pairs_t>
573 force_pairs(const ForcePairs& c) {
574 typedef bgl_named_params<ForcePairs, force_pairs_t> Params;
578 template <typename Cooling>
579 bgl_named_params<Cooling, cooling_t>
580 cooling(const Cooling& c) {
581 typedef bgl_named_params<Cooling, cooling_t> Params;
585 template <typename T>
586 bgl_named_params<T, iterations_t>
587 iterations(const T& c) {
588 typedef bgl_named_params<T, iterations_t> Params;
593 bgl_named_params<std::pair<T, T>, diameter_range_t>
594 diameter_range(const std::pair<T, T>& c) {
595 typedef bgl_named_params<std::pair<T, T>, diameter_range_t> Params;
600 bgl_named_params<std::pair<T, T>, learning_constant_range_t>
601 learning_constant_range(const std::pair<T, T>& c) {
602 typedef bgl_named_params<std::pair<T, T>, learning_constant_range_t>
607 //===========================================================================
608 // Functions for extracting parameters from bgl_named_params
610 template <class Tag1, class Tag2, class T1, class Base>
612 typename property_value< bgl_named_params<T1,Tag1,Base>, Tag2>::type
613 get_param(const bgl_named_params<T1,Tag1,Base>& p, Tag2 tag2)
615 enum { match = detail::same_property<Tag1,Tag2>::value };
617 property_value< bgl_named_params<T1,Tag1,Base>, Tag2>::type T2;
619 typedef detail::property_value_dispatch<match> Dispatcher;
620 return Dispatcher::const_get_value(p, t2, tag2);
626 template <class Param>
627 struct choose_param_helper {
628 template <class Default> struct result { typedef Param type; };
629 template <typename Default>
630 static const Param& apply(const Param& p, const Default&) { return p; }
633 struct choose_param_helper<error_property_not_found> {
634 template <class Default> struct result { typedef Default type; };
635 template <typename Default>
636 static const Default& apply(const error_property_not_found&, const Default& d)
639 } // namespace detail
641 template <class P, class Default>
642 const typename detail::choose_param_helper<P>::template result<Default>::type&
643 choose_param(const P& param, const Default& d) {
644 return detail::choose_param_helper<P>::apply(param, d);
647 template <typename T>
648 inline bool is_default_param(const T&) { return false; }
650 inline bool is_default_param(const detail::error_property_not_found&)
655 struct choose_parameter {
656 template <class P, class Graph, class Tag>
658 typedef const P& const_result_type;
659 typedef const P& result_type;
663 template <class P, class Graph, class Tag>
664 static typename bind_<P, Graph, Tag>::const_result_type
665 const_apply(const P& p, const Graph&, Tag&)
668 template <class P, class Graph, class Tag>
669 static typename bind_<P, Graph, Tag>::result_type
670 apply(const P& p, Graph&, Tag&)
674 struct choose_default_param {
675 template <class P, class Graph, class Tag>
677 typedef typename property_map<Graph, Tag>::type
679 typedef typename property_map<Graph, Tag>::const_type
681 typedef typename property_map<Graph, Tag>::const_type
685 template <class P, class Graph, class Tag>
686 static typename bind_<P, Graph, Tag>::const_result_type
687 const_apply(const P&, const Graph& g, Tag tag) {
690 template <class P, class Graph, class Tag>
691 static typename bind_<P, Graph, Tag>::result_type
692 apply(const P&, Graph& g, Tag tag) {
697 template <class Param>
698 struct choose_property_map {
699 typedef choose_parameter type;
702 struct choose_property_map<detail::error_property_not_found> {
703 typedef choose_default_param type;
706 template <class Param, class Graph, class Tag>
707 struct choose_pmap_helper {
708 typedef typename choose_property_map<Param>::type Selector;
709 typedef typename Selector:: template bind_<Param, Graph, Tag> Bind;
711 typedef typename Bind::result_type result_type;
712 typedef typename Bind::const_result_type const_result_type;
713 typedef typename Bind::type result;
716 // used in the max-flow algorithms
717 template <class Graph, class P, class T, class R>
718 struct edge_capacity_value
720 typedef bgl_named_params<P, T, R> Params;
721 typedef typename property_value< Params, edge_capacity_t>::type Param;
722 typedef typename detail::choose_pmap_helper<Param, Graph,
723 edge_capacity_t>::result CapacityEdgeMap;
724 typedef typename property_traits<CapacityEdgeMap>::value_type type;
727 } // namespace detail
730 // Use this function instead of choose_param() when you want
731 // to avoid requiring get(tag, g) when it is not used.
732 template <typename Param, typename Graph, typename PropertyTag>
734 detail::choose_pmap_helper<Param,Graph,PropertyTag>::const_result_type
735 choose_const_pmap(const Param& p, const Graph& g, PropertyTag tag)
738 detail::choose_pmap_helper<Param,Graph,PropertyTag>::Selector Choice;
739 return Choice::const_apply(p, g, tag);
742 template <typename Param, typename Graph, typename PropertyTag>
743 typename detail::choose_pmap_helper<Param,Graph,PropertyTag>::result_type
744 choose_pmap(const Param& p, Graph& g, PropertyTag tag)
747 detail::choose_pmap_helper<Param,Graph,PropertyTag>::Selector Choice;
748 return Choice::apply(p, g, tag);
753 #endif // BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP