/*=============================================================================
|
Copyright (c) 2005-2012 Joel de Guzman
|
Copyright (c) 2005-2006 Dan Marsden
|
|
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)
|
==============================================================================*/
|
#if !defined(BOOST_FUSION_DEQUE_DETAIL_KEYED_ELEMENT_26112006_1330)
|
#define BOOST_FUSION_DEQUE_DETAIL_KEYED_ELEMENT_26112006_1330
|
|
#include <boost/fusion/support/config.hpp>
|
#include <boost/fusion/support/detail/access.hpp>
|
#include <boost/fusion/iterator/deref.hpp>
|
#include <boost/fusion/iterator/next.hpp>
|
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
|
#include <boost/core/enable_if.hpp>
|
#include <boost/type_traits/is_same.hpp>
|
#endif
|
|
namespace boost { namespace fusion
|
{
|
struct fusion_sequence_tag;
|
}}
|
|
namespace boost { namespace fusion { namespace detail
|
{
|
struct nil_keyed_element
|
{
|
typedef fusion_sequence_tag tag;
|
BOOST_FUSION_GPU_ENABLED
|
void get();
|
|
template<typename It>
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
static nil_keyed_element
|
from_iterator(It const&)
|
{
|
return nil_keyed_element();
|
}
|
};
|
|
template <typename Key, typename Value, typename Rest>
|
struct keyed_element : Rest
|
{
|
typedef Rest base;
|
typedef fusion_sequence_tag tag;
|
using Rest::get;
|
|
template <typename It>
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
static keyed_element
|
from_iterator(It const& it)
|
{
|
return keyed_element(
|
*it, base::from_iterator(fusion::next(it)));
|
}
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element(keyed_element const& rhs)
|
: Rest(rhs.get_base()), value_(rhs.value_)
|
{}
|
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element(keyed_element&& rhs)
|
: Rest(rhs.forward_base())
|
, value_(BOOST_FUSION_FWD_ELEM(Value, rhs.value_))
|
{}
|
#endif
|
|
template <typename U, typename Rst>
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element(keyed_element<Key, U, Rst> const& rhs
|
, typename enable_if<is_convertible<U, Value> >::type* = 0)
|
: Rest(rhs.get_base()), value_(rhs.value_)
|
{}
|
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
#endif
|
|
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
Rest& get_base() BOOST_NOEXCEPT
|
{
|
return *this;
|
}
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
Rest const& get_base() const BOOST_NOEXCEPT
|
{
|
return *this;
|
}
|
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
Rest&& forward_base() BOOST_NOEXCEPT
|
{
|
return std::move(*static_cast<Rest*>(this));
|
}
|
#endif
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
typename cref_result<Value>::type get(Key) const
|
{
|
return value_;
|
}
|
|
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
typename ref_result<Value>::type get(Key)
|
{
|
return value_;
|
}
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element(
|
typename detail::call_param<Value>::type value
|
, Rest const& rest)
|
: Rest(rest), value_(value)
|
{}
|
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
|
template <typename Value_, typename = typename enable_if<is_same<Value_, Value> >::type>
|
#else
|
typedef Value Value_;
|
#endif
|
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element(Value_&& value, Rest&& rest)
|
: Rest(std::move(rest))
|
, value_(BOOST_FUSION_FWD_ELEM(Value, value))
|
{}
|
#endif
|
|
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element()
|
: Rest(), value_()
|
{}
|
|
template<typename U, typename Rst>
|
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element& operator=(keyed_element<Key, U, Rst> const& rhs)
|
{
|
base::operator=(static_cast<Rst const&>(rhs)); // cast for msvc-7.1
|
value_ = rhs.value_;
|
return *this;
|
}
|
|
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element& operator=(keyed_element const& rhs)
|
{
|
base::operator=(rhs);
|
value_ = rhs.value_;
|
return *this;
|
}
|
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
keyed_element& operator=(keyed_element&& rhs)
|
{
|
base::operator=(rhs.forward_base());
|
value_ = std::move(rhs.value_);
|
return *this;
|
}
|
#endif
|
|
Value value_;
|
};
|
|
template<typename Elem, typename Key>
|
struct keyed_element_value_at
|
: keyed_element_value_at<typename Elem::base, Key>
|
{};
|
|
template<typename Key, typename Value, typename Rest>
|
struct keyed_element_value_at<keyed_element<Key, Value, Rest>, Key>
|
{
|
typedef Value type;
|
};
|
}}}
|
|
#endif
|
