ecency-mobile/ios/Pods/boost-for-react-native/boost/pending/property.hpp

271 lines
11 KiB
C++
Raw Normal View History

// (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 */