← Back
Editing: property.hpp
// (C) Copyright Jeremy Siek 2004 // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PROPERTY_HPP #define BOOST_PROPERTY_HPP #include <boost/mpl/bool.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/has_xxx.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits.hpp> #include <boost/static_assert.hpp> namespace boost { struct no_property { }; template < class Tag, class T, class Base = no_property > struct property { typedef Base next_type; typedef Tag tag_type; typedef T value_type; property(const T& v = T()) : m_value(v) {} property(const T& v, const Base& b) : m_value(v), m_base(b) {} // copy constructor and assignment operator will be generated by compiler T m_value; Base m_base; }; // Kinds of properties namespace graph_introspect_detail { BOOST_MPL_HAS_XXX_TRAIT_DEF(kind) template < typename T, bool Cond > struct get_kind { typedef void type; }; template < typename T > struct get_kind< T, true > { typedef typename T::kind type; }; } // Having a default is to make this trait work for any type, not just valid // properties, to work around VC++ <= 10 bugs related to SFINAE in // compressed_sparse_row_graph's get functions and similar template < class PropertyTag > struct property_kind : graph_introspect_detail::get_kind< PropertyTag, graph_introspect_detail::has_kind< PropertyTag >::value > { }; // Some standard properties defined independently of Boost.Graph: enum vertex_all_t { vertex_all }; enum edge_all_t { edge_all }; enum graph_all_t { graph_all }; enum vertex_bundle_t { vertex_bundle }; enum edge_bundle_t { edge_bundle }; enum graph_bundle_t { graph_bundle }; // Code to look up one property in a property list: template < typename PList, typename PropName, typename Enable = void > struct lookup_one_property_internal { BOOST_STATIC_CONSTANT(bool, found = false); typedef void type; }; // Special-case properties (vertex_all, edge_all, graph_all) #define BGL_ALL_PROP(tag) \ template < typename T > struct lookup_one_property_internal< T, tag > \ { \ BOOST_STATIC_CONSTANT(bool, found = true); \ typedef T type; \ static T& lookup(T& x, tag) { return x; } \ static const T& lookup(const T& x, tag) { return x; } \ }; \ template < typename Tag, typename T, typename Base > \ struct lookup_one_property_internal< property< Tag, T, Base >, tag > \ { /* Avoid ambiguity */ \ BOOST_STATIC_CONSTANT(bool, found = true); \ typedef property< Tag, T, Base > type; \ static type& lookup(type& x, tag) { return x; } \ static const type& lookup(const type& x, tag) { return x; } \ }; BGL_ALL_PROP(vertex_all_t) BGL_ALL_PROP(edge_all_t) BGL_ALL_PROP(graph_all_t) #undef BGL_ALL_PROP // *_bundled; these need to be macros rather than inheritance to resolve // ambiguities #define BGL_DO_ONE_BUNDLE_TYPE(kind) \ template < typename T > \ struct lookup_one_property_internal< T, BOOST_JOIN(kind, _bundle_t) > \ { \ BOOST_STATIC_CONSTANT(bool, found = true); \ typedef T type; \ static T& lookup(T& x, BOOST_JOIN(kind, _bundle_t)) { return x; } \ static const T& lookup(const T& x, BOOST_JOIN(kind, _bundle_t)) \ { \ return x; \ } \ }; \ \ template < typename Tag, typename T, typename Base > \ struct lookup_one_property_internal< property< Tag, T, Base >, \ BOOST_JOIN(kind, _bundle_t) > \ : lookup_one_property_internal< Base, BOOST_JOIN(kind, _bundle_t) > \ { \ private: \ typedef lookup_one_property_internal< Base, \ BOOST_JOIN(kind, _bundle_t) > \ base_type; \ \ public: \ template < typename BundleTag > \ static typename lazy_enable_if_c< \ (base_type::found \ && (is_same< BundleTag, \ BOOST_JOIN(kind, _bundle_t) >::value)), \ add_reference< typename base_type::type > >::type \ lookup(property< Tag, T, Base >& p, BundleTag) \ { \ return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)()); \ } \ template < typename BundleTag > \ static typename lazy_enable_if_c< \ (base_type::found \ && (is_same< BundleTag, \ BOOST_JOIN(kind, _bundle_t) >::value)), \ add_reference< const typename base_type::type > >::type \ lookup(const property< Tag, T, Base >& p, BundleTag) \ { \ return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)()); \ } \ }; BGL_DO_ONE_BUNDLE_TYPE(vertex) BGL_DO_ONE_BUNDLE_TYPE(edge) BGL_DO_ONE_BUNDLE_TYPE(graph) #undef BGL_DO_ONE_BUNDLE_TYPE // Normal old-style properties; second case also handles chaining of bundled // property accesses template < typename Tag, typename T, typename Base > struct lookup_one_property_internal< boost::property< Tag, T, Base >, Tag > { BOOST_STATIC_CONSTANT(bool, found = true); typedef property< Tag, T, Base > prop; typedef T type; template < typename U > static typename enable_if< is_same< prop, U >, T& >::type lookup( U& prop, const Tag&) { return prop.m_value; } template < typename U > static typename enable_if< is_same< prop, U >, const T& >::type lookup( const U& prop, const Tag&) { return prop.m_value; } }; template < typename Tag, typename T, typename Base, typename PropName > struct lookup_one_property_internal< boost::property< Tag, T, Base >, PropName > : lookup_one_property_internal< Base, PropName > { private: typedef lookup_one_property_internal< Base, PropName > base_type; public: template < typename PL > static typename lazy_enable_if< is_same< PL, boost::property< Tag, T, Base > >, add_reference< typename base_type::type > >::type lookup(PL& prop, const PropName& tag) { return base_type::lookup(prop.m_base, tag); } template < typename PL > static typename lazy_enable_if< is_same< PL, boost::property< Tag, T, Base > >, add_reference< const typename base_type::type > >::type lookup(const PL& prop, const PropName& tag) { return base_type::lookup(prop.m_base, tag); } }; // Pointer-to-member access to bundled properties #ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES template < typename T, typename TMaybeBase, typename R > struct lookup_one_property_internal< T, R TMaybeBase::*, typename enable_if< is_base_of< TMaybeBase, T > >::type > { BOOST_STATIC_CONSTANT(bool, found = true); typedef R type; static R& lookup(T& x, R TMaybeBase::*ptr) { return x.*ptr; } static const R& lookup(const T& x, R TMaybeBase::*ptr) { return x.*ptr; } }; #endif // Version of above handling const property lists properly template < typename T, typename Tag > struct lookup_one_property : lookup_one_property_internal< T, Tag > { }; template < typename T, typename Tag > struct lookup_one_property< const T, Tag > { BOOST_STATIC_CONSTANT( bool, found = (lookup_one_property_internal< T, Tag >::found)); typedef const typename lookup_one_property_internal< T, Tag >::type type; template < typename U > static typename lazy_enable_if< is_same< T, U >, add_reference< const typename lookup_one_property_internal< T, Tag >::type > >::type lookup(const U& p, Tag tag) { return lookup_one_property_internal< T, Tag >::lookup(p, tag); } }; // The BGL properties specialize property_kind and // property_num, and use enum's for the Property type (see // graph/properties.hpp), but the user may want to use a class // instead with a nested kind type and num. Also, we may want to // switch BGL back to using class types for properties at some point. template < class P > struct has_property : boost::mpl::true_ { }; template <> struct has_property< no_property > : boost::mpl::false_ { }; } // namespace boost #include <boost/pending/detail/property.hpp> namespace boost { template < class PropertyList, class Tag > struct property_value : lookup_one_property< PropertyList, Tag > { }; template < class PropertyList, class Tag > inline typename lookup_one_property< PropertyList, Tag >::type& get_property_value(PropertyList& p, Tag tag) { return lookup_one_property< PropertyList, Tag >::lookup(p, tag); } template < class PropertyList, class Tag > inline const typename lookup_one_property< PropertyList, Tag >::type& get_property_value(const PropertyList& p, Tag tag) { return lookup_one_property< PropertyList, Tag >::lookup(p, tag); } namespace detail { /** This trait returns true if T is no_property. */ template < typename T > struct is_no_property : mpl::bool_< is_same< T, no_property >::value > { }; template < typename PList, typename Tag > class lookup_one_property_f; template < typename PList, typename Tag, typename F > struct lookup_one_property_f_result; template < typename PList, typename Tag > struct lookup_one_property_f_result< PList, Tag, const lookup_one_property_f< PList, Tag >(PList) > { typedef typename lookup_one_property< PList, Tag >::type type; }; template < typename PList, typename Tag > struct lookup_one_property_f_result< PList, Tag, const lookup_one_property_f< PList, Tag >(PList&) > { typedef typename lookup_one_property< PList, Tag >::type& type; }; template < typename PList, typename Tag > struct lookup_one_property_f_result< PList, Tag, const lookup_one_property_f< PList, Tag >(const PList&) > { typedef const typename lookup_one_property< PList, Tag >::type& type; }; template < typename PList, typename Tag > class lookup_one_property_f { Tag tag; public: lookup_one_property_f(Tag tag) : tag(tag) {} template < typename F > struct result : lookup_one_property_f_result< PList, Tag, F > { }; typename lookup_one_property_f_result< PList, Tag, const lookup_one_property_f(PList&) >::type operator()(PList& pl) const { return lookup_one_property< PList, Tag >::lookup(pl, tag); } }; } // namespace detail namespace detail { // Stuff for directed_graph and undirected_graph to skip over their first // vertex_index and edge_index properties when providing vertex_all and // edge_all; make sure you know the exact structure of your properties if // you use there. struct remove_first_property { template < typename F > struct result { typedef typename boost::function_traits< F >::arg1_type a1; typedef typename boost::remove_reference< a1 >::type non_ref; typedef typename non_ref::next_type nx; typedef typename boost::mpl::if_< boost::is_const< non_ref >, boost::add_const< nx >, nx >::type with_const; typedef typename boost::add_reference< with_const >::type type; }; template < typename Prop > typename Prop::next_type& operator()(Prop& p) const { return p.m_base; } template < typename Prop > const typename Prop::next_type& operator()(const Prop& p) const { return p.m_base; } }; } } // namesapce boost #endif /* BOOST_PROPERTY_HPP */
Save File
Cancel