#line 1 "include/boost/pending/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 */
