1 | // (C) Copyright Jeremy Siek 2004 |
2 | // Distributed under the Boost Software License, Version 1.0. (See |
3 | // accompanying file LICENSE_1_0.txt or copy at |
4 | // http://www.boost.org/LICENSE_1_0.txt) |
5 | |
6 | #ifndef BOOST_PROPERTY_HPP |
7 | #define BOOST_PROPERTY_HPP |
8 | |
9 | #include <boost/mpl/bool.hpp> |
10 | #include <boost/mpl/if.hpp> |
11 | #include <boost/mpl/has_xxx.hpp> |
12 | #include <boost/utility/enable_if.hpp> |
13 | #include <boost/type_traits.hpp> |
14 | #include <boost/static_assert.hpp> |
15 | |
16 | namespace boost |
17 | { |
18 | |
19 | struct no_property |
20 | { |
21 | }; |
22 | |
23 | template < class Tag, class T, class Base = no_property > struct property |
24 | { |
25 | typedef Base next_type; |
26 | typedef Tag tag_type; |
27 | typedef T value_type; |
28 | property(const T& v = T()) : m_value(v) {} |
29 | property(const T& v, const Base& b) : m_value(v), m_base(b) {} |
30 | // copy constructor and assignment operator will be generated by compiler |
31 | |
32 | T m_value; |
33 | Base m_base; |
34 | }; |
35 | |
36 | // Kinds of properties |
37 | namespace graph_introspect_detail |
38 | { |
39 | BOOST_MPL_HAS_XXX_TRAIT_DEF(kind) |
40 | template < typename T, bool Cond > struct get_kind |
41 | { |
42 | typedef void type; |
43 | }; |
44 | template < typename T > struct get_kind< T, true > |
45 | { |
46 | typedef typename T::kind type; |
47 | }; |
48 | } |
49 | |
50 | // Having a default is to make this trait work for any type, not just valid |
51 | // properties, to work around VC++ <= 10 bugs related to SFINAE in |
52 | // compressed_sparse_row_graph's get functions and similar |
53 | template < class PropertyTag > |
54 | struct property_kind |
55 | : graph_introspect_detail::get_kind< PropertyTag, |
56 | graph_introspect_detail::has_kind< PropertyTag >::value > |
57 | { |
58 | }; |
59 | |
60 | // Some standard properties defined independently of Boost.Graph: |
61 | enum vertex_all_t |
62 | { |
63 | vertex_all |
64 | }; |
65 | enum edge_all_t |
66 | { |
67 | edge_all |
68 | }; |
69 | enum graph_all_t |
70 | { |
71 | graph_all |
72 | }; |
73 | enum vertex_bundle_t |
74 | { |
75 | vertex_bundle |
76 | }; |
77 | enum edge_bundle_t |
78 | { |
79 | edge_bundle |
80 | }; |
81 | enum graph_bundle_t |
82 | { |
83 | graph_bundle |
84 | }; |
85 | |
86 | // Code to look up one property in a property list: |
87 | template < typename PList, typename PropName, typename Enable = void > |
88 | struct lookup_one_property_internal |
89 | { |
90 | BOOST_STATIC_CONSTANT(bool, found = false); |
91 | typedef void type; |
92 | }; |
93 | |
94 | // Special-case properties (vertex_all, edge_all, graph_all) |
95 | #define BGL_ALL_PROP(tag) \ |
96 | template < typename T > struct lookup_one_property_internal< T, tag > \ |
97 | { \ |
98 | BOOST_STATIC_CONSTANT(bool, found = true); \ |
99 | typedef T type; \ |
100 | static T& lookup(T& x, tag) { return x; } \ |
101 | static const T& lookup(const T& x, tag) { return x; } \ |
102 | }; \ |
103 | template < typename Tag, typename T, typename Base > \ |
104 | struct lookup_one_property_internal< property< Tag, T, Base >, tag > \ |
105 | { /* Avoid ambiguity */ \ |
106 | BOOST_STATIC_CONSTANT(bool, found = true); \ |
107 | typedef property< Tag, T, Base > type; \ |
108 | static type& lookup(type& x, tag) { return x; } \ |
109 | static const type& lookup(const type& x, tag) { return x; } \ |
110 | }; |
111 | |
112 | BGL_ALL_PROP(vertex_all_t) |
113 | BGL_ALL_PROP(edge_all_t) |
114 | BGL_ALL_PROP(graph_all_t) |
115 | #undef BGL_ALL_PROP |
116 | |
117 | // *_bundled; these need to be macros rather than inheritance to resolve |
118 | // ambiguities |
119 | #define BGL_DO_ONE_BUNDLE_TYPE(kind) \ |
120 | template < typename T > \ |
121 | struct lookup_one_property_internal< T, BOOST_JOIN(kind, _bundle_t) > \ |
122 | { \ |
123 | BOOST_STATIC_CONSTANT(bool, found = true); \ |
124 | typedef T type; \ |
125 | static T& lookup(T& x, BOOST_JOIN(kind, _bundle_t)) { return x; } \ |
126 | static const T& lookup(const T& x, BOOST_JOIN(kind, _bundle_t)) \ |
127 | { \ |
128 | return x; \ |
129 | } \ |
130 | }; \ |
131 | \ |
132 | template < typename Tag, typename T, typename Base > \ |
133 | struct lookup_one_property_internal< property< Tag, T, Base >, \ |
134 | BOOST_JOIN(kind, _bundle_t) > \ |
135 | : lookup_one_property_internal< Base, BOOST_JOIN(kind, _bundle_t) > \ |
136 | { \ |
137 | private: \ |
138 | typedef lookup_one_property_internal< Base, \ |
139 | BOOST_JOIN(kind, _bundle_t) > \ |
140 | base_type; \ |
141 | \ |
142 | public: \ |
143 | template < typename BundleTag > \ |
144 | static typename lazy_enable_if_c< \ |
145 | (base_type::found \ |
146 | && (is_same< BundleTag, \ |
147 | BOOST_JOIN(kind, _bundle_t) >::value)), \ |
148 | add_reference< typename base_type::type > >::type \ |
149 | lookup(property< Tag, T, Base >& p, BundleTag) \ |
150 | { \ |
151 | return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)()); \ |
152 | } \ |
153 | template < typename BundleTag > \ |
154 | static typename lazy_enable_if_c< \ |
155 | (base_type::found \ |
156 | && (is_same< BundleTag, \ |
157 | BOOST_JOIN(kind, _bundle_t) >::value)), \ |
158 | add_reference< const typename base_type::type > >::type \ |
159 | lookup(const property< Tag, T, Base >& p, BundleTag) \ |
160 | { \ |
161 | return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)()); \ |
162 | } \ |
163 | }; |
164 | |
165 | BGL_DO_ONE_BUNDLE_TYPE(vertex) |
166 | BGL_DO_ONE_BUNDLE_TYPE(edge) |
167 | BGL_DO_ONE_BUNDLE_TYPE(graph) |
168 | #undef BGL_DO_ONE_BUNDLE_TYPE |
169 | |
170 | // Normal old-style properties; second case also handles chaining of bundled |
171 | // property accesses |
172 | template < typename Tag, typename T, typename Base > |
173 | struct lookup_one_property_internal< boost::property< Tag, T, Base >, Tag > |
174 | { |
175 | BOOST_STATIC_CONSTANT(bool, found = true); |
176 | typedef property< Tag, T, Base > prop; |
177 | typedef T type; |
178 | template < typename U > |
179 | static typename enable_if< is_same< prop, U >, T& >::type lookup( |
180 | U& prop, const Tag&) |
181 | { |
182 | return prop.m_value; |
183 | } |
184 | template < typename U > |
185 | static typename enable_if< is_same< prop, U >, const T& >::type lookup( |
186 | const U& prop, const Tag&) |
187 | { |
188 | return prop.m_value; |
189 | } |
190 | }; |
191 | |
192 | template < typename Tag, typename T, typename Base, typename PropName > |
193 | struct lookup_one_property_internal< boost::property< Tag, T, Base >, PropName > |
194 | : lookup_one_property_internal< Base, PropName > |
195 | { |
196 | private: |
197 | typedef lookup_one_property_internal< Base, PropName > base_type; |
198 | |
199 | public: |
200 | template < typename PL > |
201 | static |
202 | typename lazy_enable_if< is_same< PL, boost::property< Tag, T, Base > >, |
203 | add_reference< typename base_type::type > >::type |
204 | lookup(PL& prop, const PropName& tag) |
205 | { |
206 | return base_type::lookup(prop.m_base, tag); |
207 | } |
208 | template < typename PL > |
209 | static |
210 | typename lazy_enable_if< is_same< PL, boost::property< Tag, T, Base > >, |
211 | add_reference< const typename base_type::type > >::type |
212 | lookup(const PL& prop, const PropName& tag) |
213 | { |
214 | return base_type::lookup(prop.m_base, tag); |
215 | } |
216 | }; |
217 | |
218 | // Pointer-to-member access to bundled properties |
219 | #ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES |
220 | template < typename T, typename TMaybeBase, typename R > |
221 | struct lookup_one_property_internal< T, R TMaybeBase::*, |
222 | typename enable_if< is_base_of< TMaybeBase, T > >::type > |
223 | { |
224 | BOOST_STATIC_CONSTANT(bool, found = true); |
225 | typedef R type; |
226 | static R& lookup(T& x, R TMaybeBase::*ptr) { return x.*ptr; } |
227 | static const R& lookup(const T& x, R TMaybeBase::*ptr) { return x.*ptr; } |
228 | }; |
229 | #endif |
230 | |
231 | // Version of above handling const property lists properly |
232 | template < typename T, typename Tag > |
233 | struct lookup_one_property : lookup_one_property_internal< T, Tag > |
234 | { |
235 | }; |
236 | |
237 | template < typename T, typename Tag > struct lookup_one_property< const T, Tag > |
238 | { |
239 | BOOST_STATIC_CONSTANT( |
240 | bool, found = (lookup_one_property_internal< T, Tag >::found)); |
241 | typedef const typename lookup_one_property_internal< T, Tag >::type type; |
242 | template < typename U > |
243 | static typename lazy_enable_if< is_same< T, U >, |
244 | add_reference< const typename lookup_one_property_internal< T, |
245 | Tag >::type > >::type |
246 | lookup(const U& p, Tag tag) |
247 | { |
248 | return lookup_one_property_internal< T, Tag >::lookup(p, tag); |
249 | } |
250 | }; |
251 | |
252 | // The BGL properties specialize property_kind and |
253 | // property_num, and use enum's for the Property type (see |
254 | // graph/properties.hpp), but the user may want to use a class |
255 | // instead with a nested kind type and num. Also, we may want to |
256 | // switch BGL back to using class types for properties at some point. |
257 | |
258 | template < class P > struct has_property : boost::mpl::true_ |
259 | { |
260 | }; |
261 | template <> struct has_property< no_property > : boost::mpl::false_ |
262 | { |
263 | }; |
264 | |
265 | } // namespace boost |
266 | |
267 | #include <boost/pending/detail/property.hpp> |
268 | |
269 | namespace boost |
270 | { |
271 | |
272 | template < class PropertyList, class Tag > |
273 | struct property_value : lookup_one_property< PropertyList, Tag > |
274 | { |
275 | }; |
276 | |
277 | template < class PropertyList, class Tag > |
278 | inline typename lookup_one_property< PropertyList, Tag >::type& |
279 | get_property_value(PropertyList& p, Tag tag) |
280 | { |
281 | return lookup_one_property< PropertyList, Tag >::lookup(p, tag); |
282 | } |
283 | |
284 | template < class PropertyList, class Tag > |
285 | inline const typename lookup_one_property< PropertyList, Tag >::type& |
286 | get_property_value(const PropertyList& p, Tag tag) |
287 | { |
288 | return lookup_one_property< PropertyList, Tag >::lookup(p, tag); |
289 | } |
290 | |
291 | namespace detail |
292 | { |
293 | |
294 | /** This trait returns true if T is no_property. */ |
295 | template < typename T > |
296 | struct is_no_property : mpl::bool_< is_same< T, no_property >::value > |
297 | { |
298 | }; |
299 | |
300 | template < typename PList, typename Tag > class lookup_one_property_f; |
301 | |
302 | template < typename PList, typename Tag, typename F > |
303 | struct lookup_one_property_f_result; |
304 | |
305 | template < typename PList, typename Tag > |
306 | struct lookup_one_property_f_result< PList, Tag, |
307 | const lookup_one_property_f< PList, Tag >(PList) > |
308 | { |
309 | typedef typename lookup_one_property< PList, Tag >::type type; |
310 | }; |
311 | |
312 | template < typename PList, typename Tag > |
313 | struct lookup_one_property_f_result< PList, Tag, |
314 | const lookup_one_property_f< PList, Tag >(PList&) > |
315 | { |
316 | typedef typename lookup_one_property< PList, Tag >::type& type; |
317 | }; |
318 | |
319 | template < typename PList, typename Tag > |
320 | struct lookup_one_property_f_result< PList, Tag, |
321 | const lookup_one_property_f< PList, Tag >(const PList&) > |
322 | { |
323 | typedef const typename lookup_one_property< PList, Tag >::type& type; |
324 | }; |
325 | |
326 | template < typename PList, typename Tag > class lookup_one_property_f |
327 | { |
328 | Tag tag; |
329 | |
330 | public: |
331 | lookup_one_property_f(Tag tag) : tag(tag) {} |
332 | template < typename F > |
333 | struct result : lookup_one_property_f_result< PList, Tag, F > |
334 | { |
335 | }; |
336 | |
337 | typename lookup_one_property_f_result< PList, Tag, |
338 | const lookup_one_property_f(PList&) >::type |
339 | operator()(PList& pl) const |
340 | { |
341 | return lookup_one_property< PList, Tag >::lookup(pl, tag); |
342 | } |
343 | }; |
344 | |
345 | } // namespace detail |
346 | |
347 | namespace detail |
348 | { |
349 | // Stuff for directed_graph and undirected_graph to skip over their first |
350 | // vertex_index and edge_index properties when providing vertex_all and |
351 | // edge_all; make sure you know the exact structure of your properties if |
352 | // you use there. |
353 | struct remove_first_property |
354 | { |
355 | template < typename F > struct result |
356 | { |
357 | typedef typename boost::function_traits< F >::arg1_type a1; |
358 | typedef typename boost::remove_reference< a1 >::type non_ref; |
359 | typedef typename non_ref::next_type nx; |
360 | typedef typename boost::mpl::if_< boost::is_const< non_ref >, |
361 | boost::add_const< nx >, nx >::type with_const; |
362 | typedef typename boost::add_reference< with_const >::type type; |
363 | }; |
364 | template < typename Prop > |
365 | typename Prop::next_type& operator()(Prop& p) const |
366 | { |
367 | return p.m_base; |
368 | } |
369 | template < typename Prop > |
370 | const typename Prop::next_type& operator()(const Prop& p) const |
371 | { |
372 | return p.m_base; |
373 | } |
374 | }; |
375 | } |
376 | |
377 | } // namesapce boost |
378 | |
379 | #endif /* BOOST_PROPERTY_HPP */ |
380 | |