Compare commits

..

1 Commits

Author SHA1 Message Date
f58cbc45cb Release 1.50.0
[SVN r79156]
2012-06-28 12:37:29 +00:00
217 changed files with 1200 additions and 5003 deletions

View File

@ -658,7 +658,7 @@ __random_access_sequence__.
[heading Synopsis]
BOOST_FUSION_ADAPT_TPL_ADT(
BOOST_FUSION_ADAPT_ADT(
(template_param0)(template_param1)...,
(type_name) (specialization_param0)(specialization_param1)...,
(attribute_type0, attribute_const_type0, get_expr0, set_expr0)
@ -1115,100 +1115,6 @@ defined in __random_access_sequence__.
[endsect]
[section:define_struct_inline BOOST_FUSION_DEFINE_STRUCT_INLINE]
[heading Description]
BOOST_FUSION_DEFINE_STRUCT_INLINE is a macro that can be used to generate all
the necessary boilerplate to define and adapt an arbitrary struct as a model of
__random_access_sequence__. Unlike BOOST_FUSION_DEFINE_STRUCT, it can be used
at class or namespace scope.
[heading Synopsis]
BOOST_FUSION_DEFINE_STRUCT_INLINE(
struct_name,
(member_type0, member_name0)
(member_type1, member_name1)
...
)
[heading Expression Semantics]
The semantics of BOOST_FUSION_DEFINE_STRUCT_INLINE are identical to those of
BOOST_FUSION_DEFINE_STRUCT, with two differences:
# BOOST_FUSION_DEFINE_STRUCT_INLINE can be used at class or namespace scope, and
thus does not take a namespace list parameter.
# The structure generated by BOOST_FUSION_DEFINE_STRUCT_INLINE has a base class,
and is thus not POD in C++03.
[heading Header]
#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
#include <boost/fusion/include/define_struct_inline.hpp>
[heading Example]
// enclosing::employee is a Fusion sequence
class enclosing
{
BOOST_FUSION_DEFINE_STRUCT_INLINE(
employee,
(std::string, name)
(int, age))
};
[endsect]
[section:define_tpl_struct_inline BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE]
[heading Description]
BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE is a macro that can be used to generate
all the necessary boilerplate to define and adapt an arbitrary template struct
as a model of __random_access_sequence__. Unlike BOOST_FUSION_DEFINE_TPL_STRUCT,
it can be used at class or namespace scope.
[heading Synopsis]
BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE(
(template_param0)(template_param1)...,
struct_name,
(member_type0, member_name0)
(member_type1, member_name1)
...
)
[heading Expression Semantics]
The semantics of BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE are identical to those of
BOOST_FUSION_DEFINE_TPL_STRUCT, with two differences:
# BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE can be used at class or namespace scope,
and thus does not take a namespace list parameter.
# The structure generated by BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE has a base
class, and is thus not POD in C++03.
[heading Header]
#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
#include <boost/fusion/include/define_struct_inline.hpp>
[heading Example]
// Any instantiated enclosing::employee is a Fusion sequence
class enclosing
{
BOOST_FUSION_DEFINE_TPL_STRUCT(
(Name)(Age), employee,
(Name, name)
(Age, age))
};
[endsect]
[section:define_assoc_struct BOOST_FUSION_DEFINE_ASSOC_STRUCT]
[heading Description]

View File

@ -492,7 +492,7 @@ Deferences the data property associated with the element referenced by an associ
template<
typename I
>
typename __result_of_deref_data__<I>::type deref_data(I const& i);
typename __result_of_deref_data__<I>::type deref(I const& i);
[table Parameters
[[Parameter] [Requirement] [Description]]

View File

@ -91,7 +91,7 @@ Where `Vi` is `X&` if the cv-unqualified type `Ti` is `reference_wrapper<X>`, ot
template<typename T1, typename T2, ..., typename TN>
tuple<T1&, T2&, ..., TN&> tie(T1& t1, T2& t2, ..., TN& tn);
[*Returns]: tuple<T1&, T2&, ..., TN&>(t1, t2, ..., tN). When argument `ti` is `ignore`, assigning any value to the corresponding tuple element has no effect.
[*Returns]: tuple<T1&, T2&, ..., TN&>(t1, t2, ..., tN). When argument `ti` is `ignore`, assigning any value to the corresponding tuple element has has no effect.
[endsect]
@ -254,7 +254,7 @@ The __tr1__tuple__ interface is specified to provide uniform access to `std::pai
[*Type]: `T2`
[*Value]: Returns the type of the second element of the pair
[*Value]: Returns thetype of the second element of the pair
template<int I, typename T1, typename T2>
P& get(std::pair<T1, T2>& pr);

View File

@ -18,7 +18,7 @@
// The std_tuple_iterator adaptor only supports implementations
// using variadic templates
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
#include <boost/fusion/adapted/std_tuple.hpp>
#endif

View File

@ -12,28 +12,13 @@
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/fusion/support/as_const.hpp>
#include <boost/fusion/adapted/struct/detail/extension.hpp>
namespace boost { namespace fusion
{
namespace detail
{
namespace boost { namespace fusion { namespace detail
{
template <typename T, typename Dummy>
struct get_identity
: remove_const<typename remove_reference<T>::type>
{};
}
namespace extension
{
// Overload as_const() to unwrap adt_attribute_proxy.
template <typename T, int N, bool Const>
typename adt_attribute_proxy<T, N, Const>::type as_const(const adt_attribute_proxy<T, N, Const>& proxy)
{
return proxy.get();
}
}
}}
}}}
#endif

View File

@ -16,6 +16,5 @@
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
#include <boost/fusion/adapted/struct/define_struct.hpp>
#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
#endif

View File

@ -1,25 +0,0 @@
/*=============================================================================
Copyright (c) 2012 Nathan Ridge
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_FUSION_ADAPTED_STRUCT_DEFINE_STRUCT_INLINE_HPP
#define BOOST_FUSION_ADAPTED_STRUCT_DEFINE_STRUCT_INLINE_HPP
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/adapted/struct/detail/define_struct_inline.hpp>
#define BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE( \
TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES) \
\
BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE_IMPL( \
TEMPLATE_PARAMS_SEQ, \
NAME, \
ATTRIBUTES)
#define BOOST_FUSION_DEFINE_STRUCT_INLINE(NAME, ATTRIBUTES) \
BOOST_FUSION_DEFINE_STRUCT_INLINE_IMPL(NAME, ATTRIBUTES) \
#endif

View File

@ -1,523 +0,0 @@
/*=============================================================================
Copyright (c) 2012 Nathan Ridge
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_FUSION_ADAPTED_STRUCT_DETAIL_DEFINE_STRUCT_INLINE_HPP
#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEFINE_STRUCT_INLINE_HPP
#include <boost/config.hpp>
#include <boost/fusion/support/category_of.hpp>
#include <boost/fusion/sequence/sequence_facade.hpp>
#include <boost/fusion/iterator/iterator_facade.hpp>
#include <boost/fusion/algorithm/auxiliary/copy.hpp>
#include <boost/fusion/adapted/struct/detail/define_struct.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/preprocessor/comma_if.hpp>
#include <boost/preprocessor/facilities/is_empty.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/seq/for_each_i.hpp>
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/seq/seq.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
// MSVC and GCC <= 4.4 have a bug that affects partial specializations of
// nested templates under some circumstances. This affects the implementation
// of BOOST_FUSION_DEFINE_STRUCT_INLINE, which uses such specializations for
// the iterator class's 'deref' and 'value_of' metafunctions. On these compilers
// an alternate implementation for these metafunctions is used that does not
// require such specializations. The alternate implementation takes longer
// to compile so its use is restricted to the offending compilers.
// For MSVC, the bug was was reported at https://connect.microsoft.com/VisualStudio/feedback/details/757891/c-compiler-error-involving-partial-specializations-of-nested-templates
// For GCC, 4.4 and earlier are no longer maintained so there is no need
// to report a bug.
#if defined(BOOST_MSVC) || (defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 4)))
#define BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND
#endif
#ifdef BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/mpl/if.hpp>
#include <boost/fusion/sequence/intrinsic/at_c.hpp>
#include <boost/fusion/container/vector.hpp>
#endif
#define BOOST_FUSION_MAKE_DEFAULT_INIT_LIST_ENTRY(R, DATA, N, ATTRIBUTE) \
BOOST_PP_COMMA_IF(N) BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)()
#define BOOST_FUSION_MAKE_DEFAULT_INIT_LIST(ATTRIBUTES_SEQ) \
: BOOST_PP_SEQ_FOR_EACH_I( \
BOOST_FUSION_MAKE_DEFAULT_INIT_LIST_ENTRY, \
~, \
ATTRIBUTES_SEQ) \
#define BOOST_FUSION_IGNORE_1(ARG1)
#define BOOST_FUSION_IGNORE_2(ARG1, ARG2)
#define BOOST_FUSION_MAKE_COPY_CONSTRUCTOR(NAME, ATTRIBUTES_SEQ) \
NAME(BOOST_PP_SEQ_FOR_EACH_I( \
BOOST_FUSION_MAKE_CONST_REF_PARAM, \
~, \
ATTRIBUTES_SEQ)) \
: BOOST_PP_SEQ_FOR_EACH_I( \
BOOST_FUSION_MAKE_INIT_LIST_ENTRY, \
~, \
ATTRIBUTES_SEQ) \
{ \
} \
#define BOOST_FUSION_MAKE_CONST_REF_PARAM(R, DATA, N, ATTRIBUTE) \
BOOST_PP_COMMA_IF(N) \
BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) const& \
BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)
#define BOOST_FUSION_MAKE_INIT_LIST_ENTRY_I(NAME) NAME(NAME)
#define BOOST_FUSION_MAKE_INIT_LIST_ENTRY(R, DATA, N, ATTRIBUTE) \
BOOST_PP_COMMA_IF(N) \
BOOST_FUSION_MAKE_INIT_LIST_ENTRY_I(BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE))
#define BOOST_FUSION_ITERATOR_NAME(NAME) \
BOOST_PP_CAT(boost_fusion_detail_, BOOST_PP_CAT(NAME, _iterator))
// Note: all template parameter names need to be uglified, otherwise they might
// shadow a template parameter of the struct when used with
// BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE
#define BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS(Z, N, NAME) \
template <typename boost_fusion_detail_Sq> \
struct value_of< \
BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, N> \
> \
: boost::mpl::identity< \
typename boost_fusion_detail_Sq::t##N##_type \
> \
{ \
};
#define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
SPEC_TYPE, CALL_ARG_TYPE, TYPE_QUAL, ATTRIBUTE, N) \
\
template <typename boost_fusion_detail_Sq> \
struct deref<SPEC_TYPE, N> > \
{ \
typedef typename boost_fusion_detail_Sq::t##N##_type TYPE_QUAL& type; \
static type call(CALL_ARG_TYPE, N> const& iter) \
{ \
return iter.seq_.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); \
} \
};
#define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS(R, NAME, N, ATTRIBUTE) \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \
BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \
, \
ATTRIBUTE, \
N) \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \
BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \
const, \
ATTRIBUTE, \
N) \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
const BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \
BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \
, \
ATTRIBUTE, \
N) \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
const BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \
BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \
const, \
ATTRIBUTE, \
N) \
#define BOOST_FUSION_MAKE_VALUE_AT_SPECS(Z, N, DATA) \
template <typename boost_fusion_detail_Sq> \
struct value_at<boost_fusion_detail_Sq, boost::mpl::int_<N> > \
{ \
typedef typename boost_fusion_detail_Sq::t##N##_type type; \
};
#define BOOST_FUSION_MAKE_AT_SPECS(R, DATA, N, ATTRIBUTE) \
template <typename boost_fusion_detail_Sq> \
struct at<boost_fusion_detail_Sq, boost::mpl::int_<N> > \
{ \
typedef typename boost::mpl::if_< \
boost::is_const<boost_fusion_detail_Sq>, \
typename boost_fusion_detail_Sq::t##N##_type const&, \
typename boost_fusion_detail_Sq::t##N##_type& \
>::type type; \
\
static type call(boost_fusion_detail_Sq& sq) \
{ \
return sq. BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); \
} \
};
#define BOOST_FUSION_MAKE_TYPEDEF(R, DATA, N, ATTRIBUTE) \
typedef BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) t##N##_type;
#define BOOST_FUSION_MAKE_DATA_MEMBER(R, DATA, N, ATTRIBUTE) \
BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE);
#ifdef BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND
#define BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTE_SEQ_SIZE) \
template <typename boost_fusion_detail_Iterator> \
struct value_of : boost::fusion::result_of::at_c< \
ref_vec_t, \
boost_fusion_detail_Iterator::index::value \
> \
{ \
};
#define BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ) \
template <typename boost_fusion_detail_Iterator> \
struct deref \
{ \
typedef typename boost::remove_const< \
boost_fusion_detail_Iterator \
>::type iterator_raw_type; \
\
static const int index = iterator_raw_type::index::value; \
\
typedef typename boost::fusion::result_of::at_c< \
ref_vec_t, \
index \
>::type result_raw_type; \
\
typedef typename boost::mpl::if_< \
boost::is_const<typename iterator_raw_type::sequence_type>, \
typename boost::add_const<result_raw_type>::type, \
result_raw_type \
>::type type; \
\
static type call(iterator_raw_type const& iter) \
{ \
return boost::fusion::at_c<index>(iter.ref_vec); \
} \
};
#define BOOST_FUSION_MAKE_ITERATOR_WKND_FIELD_NAME(R, DATA, N, ATTRIBUTE) \
BOOST_PP_COMMA_IF(N) seq.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)
#define BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES(ATTRIBUTES_SEQ) \
, ref_vec(BOOST_PP_SEQ_FOR_EACH_I( \
BOOST_FUSION_MAKE_ITERATOR_WKND_FIELD_NAME, \
~, \
BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ)))
#define BOOST_FUSION_MAKE_ITERATOR_WKND_REF(Z, N, DATA) \
BOOST_PP_COMMA_IF(N) \
typename boost::mpl::if_< \
boost::is_const<boost_fusion_detail_Seq>, \
typename boost::add_const< \
typename boost_fusion_detail_Seq::t##N##_type \
>::type, \
typename boost_fusion_detail_Seq::t##N##_type \
>::type&
#define BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE) \
typedef boost::fusion::vector< \
BOOST_PP_REPEAT( \
ATTRIBUTES_SEQ_SIZE, \
BOOST_FUSION_MAKE_ITERATOR_WKND_REF, \
~) \
> ref_vec_t; \
\
ref_vec_t ref_vec;
#else
#define BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTES_SEQ_SIZE) \
template <typename boost_fusion_detail_T> struct value_of; \
BOOST_PP_REPEAT( \
ATTRIBUTES_SEQ_SIZE, \
BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS, \
NAME)
#define BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ) \
template <typename boost_fusion_detail_T> struct deref; \
BOOST_PP_SEQ_FOR_EACH_I( \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS, \
NAME, \
ATTRIBUTES_SEQ)
#define BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES(ATTRIBUTES_SEQ)
#define BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE)
#endif // BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND
// Note: We can't nest the iterator inside the struct because we run into
// a MSVC10 bug involving partial specializations of nested templates.
#define BOOST_FUSION_DEFINE_STRUCT_INLINE_IMPL(NAME, ATTRIBUTES) \
BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES) \
struct NAME : boost::fusion::sequence_facade< \
NAME, \
boost::fusion::random_access_traversal_tag \
> \
{ \
BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES) \
};
#define BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE_IMPL( \
TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES) \
\
BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES) \
\
template < \
BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL( \
(0)TEMPLATE_PARAMS_SEQ) \
> \
struct NAME : boost::fusion::sequence_facade< \
NAME< \
BOOST_PP_SEQ_ENUM(TEMPLATE_PARAMS_SEQ) \
>, \
boost::fusion::random_access_traversal_tag \
> \
{ \
BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES) \
};
#define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES) \
BOOST_FUSION_DEFINE_STRUCT_MEMBERS_IMPL( \
NAME, \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END))
// Note: can't compute BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ) directly because
// ATTRIBUTES_SEQ may be empty and calling BOOST_PP_SEQ_SIZE on an empty
// sequence produces warnings on MSVC.
#define BOOST_FUSION_DEFINE_STRUCT_MEMBERS_IMPL(NAME, ATTRIBUTES_SEQ) \
BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL( \
NAME, \
ATTRIBUTES_SEQ, \
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE((0)ATTRIBUTES_SEQ)))
#define BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES) \
BOOST_FUSION_DEFINE_STRUCT_ITERATOR_IMPL( \
NAME, \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END))
#define BOOST_FUSION_DEFINE_STRUCT_ITERATOR_IMPL(NAME, ATTRIBUTES_SEQ) \
BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR_IMPL_IMPL( \
NAME, \
ATTRIBUTES_SEQ, \
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE((0)ATTRIBUTES_SEQ)))
#define BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR_IMPL_IMPL( \
NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE) \
\
template <typename boost_fusion_detail_Seq, int N> \
struct BOOST_FUSION_ITERATOR_NAME(NAME) \
: boost::fusion::iterator_facade< \
BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Seq, N>, \
boost::fusion::random_access_traversal_tag \
> \
{ \
typedef boost::mpl::int_<N> index; \
typedef boost_fusion_detail_Seq sequence_type; \
\
BOOST_FUSION_ITERATOR_NAME(NAME)(boost_fusion_detail_Seq& seq) \
: seq_(seq) \
BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES( \
(0)ATTRIBUTES_SEQ) \
{} \
\
boost_fusion_detail_Seq& seq_; \
\
BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE) \
\
BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTES_SEQ_SIZE) \
\
BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ) \
\
template <typename boost_fusion_detail_It> \
struct next \
{ \
typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \
typename boost_fusion_detail_It::sequence_type, \
boost_fusion_detail_It::index::value + 1 \
> type; \
\
static type call(boost_fusion_detail_It const& it) \
{ \
return type(it.seq_); \
} \
}; \
\
template <typename boost_fusion_detail_It> \
struct prior \
{ \
typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \
typename boost_fusion_detail_It::sequence_type, \
boost_fusion_detail_It::index::value - 1 \
> type; \
\
static type call(boost_fusion_detail_It const& it) \
{ \
return type(it.seq_); \
} \
}; \
\
template < \
typename boost_fusion_detail_It1, \
typename boost_fusion_detail_It2 \
> \
struct distance \
{ \
typedef typename boost::mpl::minus< \
typename boost_fusion_detail_It2::index, \
typename boost_fusion_detail_It1::index \
>::type type; \
\
static type call(boost_fusion_detail_It1 const& it1, \
boost_fusion_detail_It2 const& it2) \
{ \
return type(); \
} \
}; \
\
template < \
typename boost_fusion_detail_It, \
typename boost_fusion_detail_M \
> \
struct advance \
{ \
typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \
typename boost_fusion_detail_It::sequence_type, \
boost_fusion_detail_It::index::value \
+ boost_fusion_detail_M::value \
> type; \
\
static type call(boost_fusion_detail_It const& it) \
{ \
return type(it.seq_); \
} \
}; \
};
#define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL( \
NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE) \
\
/* Note: second BOOST_PP_IF is necessary to avoid MSVC warning when */ \
/* calling BOOST_FUSION_IGNORE_1 with no arguments. */ \
NAME() \
BOOST_PP_IF( \
ATTRIBUTES_SEQ_SIZE, \
BOOST_FUSION_MAKE_DEFAULT_INIT_LIST, \
BOOST_FUSION_IGNORE_1) \
(BOOST_PP_IF( \
ATTRIBUTES_SEQ_SIZE, \
ATTRIBUTES_SEQ, \
0)) \
{ \
} \
\
BOOST_PP_IF( \
ATTRIBUTES_SEQ_SIZE, \
BOOST_FUSION_MAKE_COPY_CONSTRUCTOR, \
BOOST_FUSION_IGNORE_2) \
(NAME, ATTRIBUTES_SEQ) \
\
template <typename boost_fusion_detail_Seq> \
NAME(const boost_fusion_detail_Seq& rhs) \
{ \
boost::fusion::copy(rhs, *this); \
} \
\
template <typename boost_fusion_detail_Seq> \
NAME& operator=(const boost_fusion_detail_Seq& rhs) \
{ \
boost::fusion::copy(rhs, *this); \
return *this; \
} \
\
template <typename boost_fusion_detail_Sq> \
struct begin \
{ \
typedef BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, 0> \
type; \
\
static type call(boost_fusion_detail_Sq& sq) \
{ \
return type(sq); \
} \
}; \
\
template <typename boost_fusion_detail_Sq> \
struct end \
{ \
typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \
boost_fusion_detail_Sq, \
ATTRIBUTES_SEQ_SIZE \
> type; \
\
static type call(boost_fusion_detail_Sq& sq) \
{ \
return type(sq); \
} \
}; \
\
template <typename boost_fusion_detail_Sq> \
struct size : boost::mpl::int_<ATTRIBUTES_SEQ_SIZE> \
{ \
}; \
\
template <typename boost_fusion_detail_Sq> \
struct empty : boost::mpl::bool_<ATTRIBUTES_SEQ_SIZE == 0> \
{ \
}; \
\
template < \
typename boost_fusion_detail_Sq, \
typename boost_fusion_detail_N \
> \
struct value_at : value_at< \
boost_fusion_detail_Sq, \
boost::mpl::int_<boost_fusion_detail_N::value> \
> \
{ \
}; \
\
BOOST_PP_REPEAT( \
ATTRIBUTES_SEQ_SIZE, \
BOOST_FUSION_MAKE_VALUE_AT_SPECS, \
~) \
\
template < \
typename boost_fusion_detail_Sq, \
typename boost_fusion_detail_N \
> \
struct at : at< \
boost_fusion_detail_Sq, \
boost::mpl::int_<boost_fusion_detail_N::value> \
> \
{ \
}; \
\
BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_MAKE_AT_SPECS, ~, ATTRIBUTES_SEQ) \
\
BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_MAKE_TYPEDEF, ~, ATTRIBUTES_SEQ) \
\
BOOST_PP_SEQ_FOR_EACH_I( \
BOOST_FUSION_MAKE_DATA_MEMBER, \
~, \
ATTRIBUTES_SEQ)
#endif

View File

@ -11,11 +11,8 @@
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/ice.hpp>
#if defined (BOOST_MSVC)
# pragma warning(push)
@ -57,19 +54,11 @@ namespace boost { namespace fusion
}
template <typename Seq1, typename Seq2>
inline
typename
enable_if_c<
type_traits::ice_and<
traits::is_sequence<Seq1>::value
, traits::is_sequence<Seq2>::value
>::value,
void
>::type
inline void
copy(Seq1 const& src, Seq2& dest)
{
BOOST_STATIC_ASSERT(
result_of::size<Seq1>::value <= result_of::size<Seq2>::value);
result_of::size<Seq1>::value == result_of::size<Seq2>::value);
detail::sequence_copy<
Seq1 const, Seq2>::

View File

@ -1,84 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2013 Joel de Guzman
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(FUSION_MOVE_01192013_2225)
#define FUSION_MOVE_01192013_2225
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/ice.hpp>
#if defined (BOOST_MSVC)
# pragma warning(push)
# pragma warning (disable: 4100) // unreferenced formal parameter
#endif
namespace boost { namespace fusion
{
namespace detail
{
template <typename Seq1, typename Seq2>
struct sequence_move
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static void
call(I1 const&, I2 const&, mpl::true_)
{
}
template <typename I1, typename I2>
static void
call(I1 const& src, I2 const& dest, mpl::false_)
{
*dest = std::move(*src);
call(fusion::next(src), fusion::next(dest));
}
template <typename I1, typename I2>
static void
call(I1 const& src, I2 const& dest)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(src, dest, eq);
}
};
}
template <typename Seq1, typename Seq2>
inline
typename
enable_if_c<
type_traits::ice_and<
traits::is_sequence<Seq1>::value
, traits::is_sequence<Seq2>::value
>::value,
void
>::type
move(Seq1&& src, Seq2& dest)
{
BOOST_STATIC_ASSERT(
result_of::size<Seq1>::value <= result_of::size<Seq2>::value);
detail::sequence_move<
Seq1, Seq2>::
call(fusion::begin(src), fusion::begin(dest));
}
}}
#if defined (BOOST_MSVC)
# pragma warning(pop)
#endif
#endif

View File

@ -9,8 +9,6 @@
#include <boost/fusion/algorithm/iteration/accumulate_fwd.hpp>
#include <boost/fusion/algorithm/iteration/fold.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -25,24 +23,14 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename State, typename F>
inline
typename
lazy_enable_if<
traits::is_sequence<Sequence>
, result_of::accumulate<Sequence, State const, F>
>::type
inline typename result_of::accumulate<Sequence, State const, F>::type
accumulate(Sequence& seq, State const& state, F f)
{
return fusion::fold(seq, state, f);
}
template <typename Sequence, typename State, typename F>
inline
typename
lazy_enable_if<
traits::is_sequence<Sequence>
, result_of::accumulate<Sequence const, State const, F>
>::type
inline typename result_of::accumulate<Sequence const, State const, F>::type
accumulate(Sequence const& seq, State const& state, F f)
{
return fusion::fold(seq, state, f);

View File

@ -7,9 +7,6 @@
#if !defined(BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED)
#define BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
namespace result_of
@ -19,19 +16,11 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename State, typename F>
typename
lazy_enable_if<
traits::is_sequence<Sequence>
, result_of::accumulate<Sequence, State const, F>
>::type
typename result_of::accumulate<Sequence, State const, F>::type
accumulate(Sequence& seq, State const& state, F f);
template <typename Sequence, typename State, typename F>
typename
lazy_enable_if<
traits::is_sequence<Sequence>
, result_of::accumulate<Sequence const, State const, F>
>::type
typename result_of::accumulate<Sequence const, State const, F>::type
accumulate(Sequence const& seq, State const& state, F f);
}}

View File

@ -116,7 +116,7 @@ namespace boost { namespace fusion
{
template<typename State, typename It0, typename F>
static Result
call(State const& state,It0 const&, F)
call(State const& state,It0 const& it0, F)
{
return static_cast<Result>(state);
}

View File

@ -115,7 +115,7 @@ namespace boost { namespace fusion
{
template<typename State, typename It0, typename F>
static Result
call(State const& state,It0 const&, F)
call(State const& state,It0 const& it0, F)
{
return static_cast<Result>(state);
}

View File

@ -11,8 +11,6 @@
#include <boost/fusion/algorithm/iteration/detail/for_each.hpp>
#include <boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp>
#include <boost/fusion/support/is_segmented.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -26,24 +24,14 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename F>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, void
>::type
inline void
for_each(Sequence& seq, F const& f)
{
detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
}
template <typename Sequence, typename F>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, void
>::type
inline void
for_each(Sequence const& seq, F const& f)
{
detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());

View File

@ -7,9 +7,6 @@
#if !defined(BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED)
#define BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
namespace result_of
@ -19,21 +16,11 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename F>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, void
>::type
void
for_each(Sequence& seq, F const& f);
template <typename Sequence, typename F>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, void
>::type
void
for_each(Sequence const& seq, F const& f);
}}

View File

@ -10,8 +10,6 @@
#include <boost/fusion/algorithm/query/count_if.hpp>
#include <boost/fusion/algorithm/query/detail/count.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -25,12 +23,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename T>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, int
>::type
inline int
count(Sequence const& seq, T const& x)
{
detail::count_compare<T> f(x);

View File

@ -10,8 +10,6 @@
#include <boost/fusion/algorithm/query/detail/count_if.hpp>
#include <boost/fusion/support/category_of.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -25,12 +23,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename F>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, int
>::type
inline int
count_if(Sequence const& seq, F f)
{
return detail::count_if(

View File

@ -109,7 +109,7 @@ namespace detail
struct unrolled_any<0>
{
template <typename It, typename F>
static bool call(It const&, F)
static bool call(It const& it, F f)
{
return false;
}

View File

@ -16,9 +16,6 @@
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/if.hpp>
namespace boost { namespace fusion
{
@ -56,38 +53,18 @@ namespace boost { namespace fusion
}
};
struct use_default;
template <class T, class Default>
struct fusion_default_help
: mpl::if_<
is_same<T, use_default>
, Default
, T
>
{
};
template <
typename Sequence
, typename First
, typename Last = use_default>
, typename Last = typename compute_erase_last<Sequence, First>::type>
struct erase
{
typedef typename result_of::begin<Sequence>::type seq_first_type;
typedef typename result_of::end<Sequence>::type seq_last_type;
BOOST_STATIC_ASSERT((!result_of::equal_to<seq_first_type, seq_last_type>::value));
typedef First FirstType;
typedef typename
fusion_default_help<
Last
, typename compute_erase_last<Sequence, First>::type
>::type
LastType;
typedef typename convert_iterator<FirstType>::type first_type;
typedef typename convert_iterator<LastType>::type last_type;
typedef typename convert_iterator<First>::type first_type;
typedef typename convert_iterator<Last>::type last_type;
typedef iterator_range<seq_first_type, first_type> left_type;
typedef iterator_range<last_type, seq_last_type> right_type;
typedef joint_view<left_type, right_type> type;
@ -95,11 +72,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename First>
typename
lazy_enable_if<
traits::is_sequence<Sequence>
, typename result_of::erase<Sequence const, First>
>::type
typename result_of::erase<Sequence const, First>::type
erase(Sequence const& seq, First const& first)
{
typedef result_of::erase<Sequence const, First> result_of;

View File

@ -16,8 +16,6 @@
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -40,12 +38,8 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename Position, typename T>
inline
typename
lazy_enable_if<
traits::is_sequence<Sequence>
, result_of::insert<Sequence const, Position, T>
>::type
inline typename result_of::insert<
Sequence const, Position, T>::type
insert(Sequence const& seq, Position const& pos, T const& x)
{
typedef result_of::insert<

View File

@ -10,8 +10,6 @@
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/fusion/view/joint_view/joint_view.hpp>
#include <boost/fusion/view/single_view/single_view.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -26,12 +24,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename T>
inline
typename
lazy_enable_if<
traits::is_sequence<Sequence>
, result_of::push_back<Sequence const, T>
>::type
inline typename result_of::push_back<Sequence const, T>::type
push_back(Sequence const& seq, T const& x)
{
typedef typename result_of::push_back<Sequence const, T> push_back;

View File

@ -10,8 +10,6 @@
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/fusion/view/joint_view/joint_view.hpp>
#include <boost/fusion/view/single_view/single_view.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -26,12 +24,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename T>
inline
typename
lazy_enable_if<
traits::is_sequence<Sequence>
, result_of::push_front<Sequence const, T>
>::type
inline typename result_of::push_front<Sequence const, T>::type
push_front(Sequence const& seq, T const& x)
{
typedef typename result_of::push_front<Sequence const, T> push_front;

View File

@ -9,8 +9,6 @@
#include <boost/fusion/view/transform_view/transform_view.hpp>
#include <boost/fusion/algorithm/transformation/detail/replace.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -24,12 +22,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename T>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, typename result_of::replace<Sequence const, T>::type
>::type
inline typename result_of::replace<Sequence const, T>::type
replace(Sequence const& seq, T const& old_value, T const& new_value)
{
typedef typename result_of::replace<Sequence const, T>::type result;

View File

@ -9,7 +9,6 @@
#include <boost/fusion/view/transform_view/transform_view.hpp>
#include <boost/fusion/algorithm/transformation/detail/replace_if.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
@ -25,12 +24,7 @@ namespace boost { namespace fusion
}
template <typename Sequence, typename F, typename T>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, typename result_of::replace_if<Sequence const, F, T>::type
>::type
inline typename result_of::replace_if<Sequence const, F, T>::type
replace_if(Sequence const& seq, F pred, T const& new_value)
{
typedef typename result_of::replace_if<Sequence const, F, T>::type result;

View File

@ -8,8 +8,6 @@
#define FUSION_REVERSE_07212005_1230
#include <boost/fusion/view/reverse_view/reverse_view.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
@ -23,12 +21,7 @@ namespace boost { namespace fusion
}
template <typename Sequence>
inline
typename
enable_if<
traits::is_sequence<Sequence>
, reverse_view<Sequence const>
>::type
inline reverse_view<Sequence const>
reverse(Sequence const& view)
{
return reverse_view<Sequence const>(view);

View File

@ -8,7 +8,6 @@
#if !defined(BOOST_FUSION_SEQUENCE_CONTAINER_DEQUE_24112006_2036)
#define BOOST_FUSION_SEQUENCE_CONTAINER_DEQUE_24112006_2036
#include <boost/fusion/container/deque/deque_fwd.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#include <boost/fusion/container/deque/convert.hpp>

View File

@ -1,47 +1,36 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
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_BACK_EXTENDED_DEQUE_26112006_2209)
#define BOOST_FUSION_BACK_EXTENDED_DEQUE_26112006_2209
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
namespace boost { namespace fusion
{
template <typename Deque, typename T>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
namespace boost { namespace fusion {
template<typename Deque, typename T>
struct back_extended_deque
: detail::keyed_element<typename Deque::next_up, T, Deque>
, sequence_base<back_extended_deque<Deque, T> >
: detail::keyed_element<typename Deque::next_up, T, Deque>,
sequence_base<back_extended_deque<Deque, T> >
{
typedef detail::keyed_element<typename Deque::next_up, T, Deque> base;
typedef typename Deque::next_down next_down;
typedef mpl::int_<(Deque::next_up::value + 1)> next_up;
typedef mpl::int_<(result_of::size<Deque>::value + 1)> size;
typedef mpl::int_<mpl::plus<typename Deque::next_up, mpl::int_<1> >::value> next_up;
typedef mpl::plus<typename result_of::size<Deque>::type, mpl::int_<1> > size;
template <typename Arg>
back_extended_deque(Deque const& deque, Arg const& val)
: base(val, deque)
back_extended_deque(Deque const& deque, typename add_reference<typename add_const<T>::type>::type t)
: base(t, deque)
{}
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename Arg>
back_extended_deque(Deque const& deque, Arg& val)
: base(val, deque)
{}
#else
template <typename Arg>
back_extended_deque(Deque const& deque, Arg&& val)
: base(std::forward<Arg>(val), deque)
{}
#endif
};
}}

View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2005-2013 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
@ -8,32 +8,23 @@
#if !defined(FUSION_CONVERT_20061213_2207)
#define FUSION_CONVERT_20061213_2207
#include <boost/fusion/container/deque/detail/as_deque.hpp>
#include <boost/fusion/container/deque/detail/convert_impl.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
///////////////////////////////////////////////////////////////////////////////
// C++03 (non-variadic) implementation
///////////////////////////////////////////////////////////////////////////////
#include <boost/fusion/container/deque/detail/cpp03/build_deque.hpp>
#else
///////////////////////////////////////////////////////////////////////////////
// C++11 variadic implementation
///////////////////////////////////////////////////////////////////////////////
#include <boost/fusion/container/deque/detail/build_deque.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
namespace boost { namespace fusion
{
namespace result_of
{
template <typename Sequence>
struct as_deque :
detail::build_deque<
typename result_of::begin<Sequence>::type
, typename result_of::end<Sequence>::type
>
struct as_deque
{
typedef typename detail::as_deque<result_of::size<Sequence>::value> gen;
typedef typename gen::
template apply<typename result_of::begin<Sequence>::type>::type
type;
};
}
@ -41,18 +32,17 @@ namespace boost { namespace fusion
inline typename result_of::as_deque<Sequence>::type
as_deque(Sequence& seq)
{
typedef result_of::as_deque<Sequence> gen;
return gen::call(fusion::begin(seq), fusion::end(seq));
typedef typename result_of::as_deque<Sequence>::gen gen;
return gen::call(fusion::begin(seq));
}
template <typename Sequence>
inline typename result_of::as_deque<Sequence const>::type
as_deque(Sequence const& seq)
{
typedef result_of::as_deque<Sequence const> gen;
return gen::call(fusion::begin(seq), fusion::end(seq));
typedef typename result_of::as_deque<Sequence const>::gen gen;
return gen::call(fusion::begin(seq));
}
}}
#endif
#endif

View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
@ -8,23 +8,39 @@
#if !defined(BOOST_FUSION_DEQUE_26112006_1649)
#define BOOST_FUSION_DEQUE_26112006_1649
# include <boost/fusion/container/deque/deque_fwd.hpp>
#include <boost/fusion/container/deque/limits.hpp>
#include <boost/fusion/container/deque/front_extended_deque.hpp>
#include <boost/fusion/container/deque/back_extended_deque.hpp>
#include <boost/fusion/container/deque/detail/deque_keyed_values.hpp>
#include <boost/fusion/container/deque/detail/deque_initial_size.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/is_convertible.hpp>
///////////////////////////////////////////////////////////////////////////////
// Without variadics, we will use the PP version
// With no decltype and variadics, we will use the C++03 version
///////////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
# include <boost/fusion/container/deque/detail/cpp03/deque.hpp>
#if (defined(BOOST_NO_DECLTYPE) \
|| defined(BOOST_NO_VARIADIC_TEMPLATES) \
|| defined(BOOST_NO_RVALUE_REFERENCES))
# include <boost/fusion/container/deque/detail/cpp03_deque.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
#endif
///////////////////////////////////////////////////////////////////////////////
// C++11 interface
///////////////////////////////////////////////////////////////////////////////
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/fusion/container/deque/detail/deque_keyed_values.hpp>
#include <boost/fusion/container/deque/detail/cpp11_deque_keyed_values.hpp>
#include <boost/fusion/container/deque/deque_fwd.hpp>
#include <boost/fusion/container/deque/detail/value_at_impl.hpp>
#include <boost/fusion/container/deque/detail/at_impl.hpp>
@ -32,10 +48,8 @@
#include <boost/fusion/container/deque/detail/end_impl.hpp>
#include <boost/fusion/container/deque/detail/is_sequence_impl.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/empty.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/and.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_convertible.hpp>
@ -46,22 +60,6 @@ namespace boost { namespace fusion
template <typename ...Elements>
struct deque : detail::nil_keyed_element
{
typedef deque_tag fusion_tag;
typedef bidirectional_traversal_tag category;
typedef mpl::int_<0> size;
typedef mpl::int_<0> next_up;
typedef mpl::int_<0> next_down;
typedef mpl::false_ is_view;
template <typename Sequence>
deque(Sequence const&,
typename enable_if<
mpl::and_<
traits::is_sequence<Sequence>
, result_of::empty<Sequence>>>::type* /*dummy*/ = 0)
{}
deque() {}
};
template <typename Head, typename ...Tail>
@ -74,7 +72,7 @@ namespace boost { namespace fusion
typedef typename detail::deque_keyed_values<Head, Tail...>::type base;
typedef mpl::int_<(sizeof ...(Tail) + 1)> size;
typedef mpl::int_<size::value> next_up;
typedef mpl::int_<((size::value == 0) ? 0 : -1)> next_down;
typedef mpl::int_<mpl::int_<((size::value == 0) ? 0 : -1)>::type::value> next_down;
typedef mpl::false_ is_view;
deque()
@ -85,45 +83,11 @@ namespace boost { namespace fusion
: base(seq)
{}
template <typename ...Elements>
deque(deque<Elements...>& seq)
: base(seq)
explicit deque(typename detail::call_param<Head>::type head
, typename detail::call_param<Tail>::type... tail)
: base(detail::deque_keyed_values<Head, Tail...>::call(head, tail...))
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename ...Elements>
deque(deque<Elements...>&& seq)
: base(std::forward<deque<Elements...>>(seq))
{}
#endif
deque(deque const& seq)
: base(seq)
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
deque(deque&& seq)
: base(std::forward<deque>(seq))
{}
#endif
explicit deque(Head const& head, Tail const&... tail)
: base(detail::deque_keyed_values<Head, Tail...>::construct(head, tail...))
{}
template <typename Head_, typename ...Tail_>
explicit deque(Head_ const& head, Tail_ const&... tail)
: base(detail::deque_keyed_values<Head_, Tail_...>::construct(head, tail...))
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename Head_, typename ...Tail_>
explicit deque(Head_&& head, Tail_&&... tail)
: base(detail::deque_keyed_values<Head, Tail...>
::forward_(std::forward<Head_>(head), std::forward<Tail_>(tail)...))
{}
#endif
template <typename Sequence>
explicit deque(Sequence const& seq
, typename disable_if<is_convertible<Sequence, Head> >::type* /*dummy*/ = 0)
@ -143,16 +107,6 @@ namespace boost { namespace fusion
base::operator=(rhs);
return *this;
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename T>
deque& operator=(T&& rhs)
{
base::operator=(std::forward<T>(rhs));
return *this;
}
#endif
};
}}

View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2007 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
@ -8,19 +8,20 @@
#if !defined(FUSION_DEQUE_FORWARD_02092007_0749)
#define FUSION_DEQUE_FORWARD_02092007_0749
#include <boost/config.hpp>
#include <boost/fusion/container/deque/limits.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
///////////////////////////////////////////////////////////////////////////////
// With no decltype and variadics, we will use the C++03 version
///////////////////////////////////////////////////////////////////////////////
#if (defined(BOOST_NO_CXX11_DECLTYPE) \
|| defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) \
|| defined(BOOST_NO_CXX11_RVALUE_REFERENCES))
# include <boost/fusion/container/deque/detail/cpp03/deque_fwd.hpp>
#if (defined(BOOST_NO_DECLTYPE) \
|| defined(BOOST_NO_VARIADIC_TEMPLATES) \
|| defined(BOOST_NO_RVALUE_REFERENCES))
# include <boost/fusion/container/deque/detail/cpp03_deque_fwd.hpp>
#else
# if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
# define BOOST_FUSION_HAS_VARIADIC_DEQUE
# endif
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR "_fwd.hpp")
#endif
///////////////////////////////////////////////////////////////////////////////
// C++11 interface

View File

@ -1,8 +1,8 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
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_ITERATOR_26112006_2154)
@ -12,13 +12,13 @@
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_const.hpp>
namespace boost { namespace fusion {
struct bidirectional_traversal_tag;
template <typename Seq, int Pos>
template<typename Seq, int Pos>
struct deque_iterator
: iterator_facade<deque_iterator<Seq, Pos>, bidirectional_traversal_tag>
{
@ -84,7 +84,7 @@ namespace boost { namespace fusion {
typedef typename
mpl::minus<
typename I2::index, typename I1::index
>::type
>::type
type;
static type

View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
@ -45,7 +45,7 @@ namespace boost { namespace fusion { namespace detail
}}}
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/as_deque.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/as_deque" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
@ -78,7 +78,7 @@ namespace boost { namespace fusion { namespace detail
typedef typename fusion::result_of::value_of<BOOST_PP_CAT(I, n)>::type \
BOOST_PP_CAT(T, n);
#define BOOST_PP_FILENAME_1 <boost/fusion/container/deque/detail/cpp03/as_deque.hpp>
#define BOOST_PP_FILENAME_1 <boost/fusion/container/deque/detail/as_deque.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()

View File

@ -1,8 +1,8 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
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_AT_IMPL_09122006_2017)
@ -19,15 +19,15 @@
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
namespace boost { namespace fusion
{
namespace boost { namespace fusion {
struct deque_tag;
namespace extension
namespace extension
{
template<typename T>
struct at_impl;
template<>
struct at_impl<deque_tag>
{
@ -37,21 +37,15 @@ namespace boost { namespace fusion
typedef typename Sequence::next_up next_up;
typedef typename Sequence::next_down next_down;
BOOST_MPL_ASSERT_RELATION(next_down::value, !=, next_up::value);
static int const offset = next_down::value + 1;
typedef mpl::int_<(N::value + offset)> adjusted_index;
typedef typename
detail::keyed_element_value_at<Sequence, adjusted_index>::type
element_type;
typedef typename
add_reference<
typename mpl::eval_if<
is_const<Sequence>,
add_const<element_type>,
mpl::identity<element_type> >::type
>::type
type;
typedef mpl::plus<next_down, mpl::int_<1> > offset;
typedef mpl::int_<mpl::plus<N, offset>::value> adjusted_index;
typedef typename detail::keyed_element_value_at<Sequence, adjusted_index>::type element_type;
typedef typename add_reference<
typename mpl::eval_if<
is_const<Sequence>,
add_const<element_type>,
mpl::identity<element_type> >::type>::type type;
static type call(Sequence& seq)
{

View File

@ -1,8 +1,8 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
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_BEGIN_IMPL_09122006_2034)
@ -13,29 +13,27 @@
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/if.hpp>
namespace boost { namespace fusion
{
namespace boost { namespace fusion {
struct deque_tag;
namespace extension
namespace extension
{
template<typename T>
struct begin_impl;
template<>
struct begin_impl<deque_tag>
{
template<typename Sequence>
struct apply
{
typedef typename
mpl::if_c<
(Sequence::next_down::value == Sequence::next_up::value)
, deque_iterator<Sequence, 0>
, deque_iterator<Sequence, (Sequence::next_down::value + 1)>
>::type
type;
typedef typename mpl::if_<
mpl::equal_to<typename Sequence::next_down, typename Sequence::next_up>,
deque_iterator<Sequence, 0>,
deque_iterator<
Sequence, mpl::plus<typename Sequence::next_down, mpl::int_<1> >::value> >::type type;
static type call(Sequence& seq)
{
return type(seq);

View File

@ -1,74 +0,0 @@
/*=============================================================================
Copyright (c) 2005-2013 Joel de Guzman
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_BUILD_DEQUE_02032013_1921)
#define BOOST_FUSION_BUILD_DEQUE_02032013_1921
#include <boost/fusion/iterator/equal_to.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/value_of.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/container/deque/front_extended_deque.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename First, typename Last
, bool is_empty = result_of::equal_to<First, Last>::value>
struct build_deque;
template <typename First, typename Last>
struct build_deque<First, Last, true>
{
typedef deque<> type;
static type
call(First const&, Last const&)
{
return type();
}
};
template <typename T, typename Rest>
struct push_front_deque;
template <typename T, typename ...Rest>
struct push_front_deque<T, deque<Rest...>>
{
typedef deque<T, Rest...> type;
static type
call(T const& first, deque<Rest...> const& rest)
{
return type(front_extended_deque<deque<Rest...>, T>(rest, first));
}
};
template <typename First, typename Last>
struct build_deque<First, Last, false>
{
typedef
build_deque<typename result_of::next<First>::type, Last>
next_build_deque;
typedef push_front_deque<
typename result_of::value_of<First>::type
, typename next_build_deque::type>
push_front;
typedef typename push_front::type type;
static type
call(First const& f, Last const& l)
{
typename result_of::value_of<First>::type v = *f;
return push_front::call(
v, next_build_deque::call(fusion::next(f), l));
}
};
}}}
#endif

View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
@ -8,7 +8,7 @@
#if !defined(FUSION_CONVERT_IMPL_20061213_2207)
#define FUSION_CONVERT_IMPL_20061213_2207
#include <boost/fusion/container/deque/convert.hpp>
#include <boost/fusion/container/deque/detail/as_deque.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
@ -17,12 +17,6 @@ namespace boost { namespace fusion
{
struct deque_tag;
namespace result_of
{
template <typename Sequence>
struct as_deque;
}
namespace extension
{
template <typename T>
@ -34,11 +28,14 @@ namespace boost { namespace fusion
template <typename Sequence>
struct apply
{
typedef result_of::as_deque<Sequence> gen;
typedef typename gen::type type;
typedef typename detail::as_deque<result_of::size<Sequence>::value> gen;
typedef typename gen::
template apply<typename result_of::begin<Sequence>::type>::type
type;
static type call(Sequence& seq)
{
return gen::call(seq);
return gen::call(fusion::begin(seq));
}
};
};

View File

@ -1,52 +0,0 @@
/*=============================================================================
Copyright (c) 2005-2013 Joel de Guzman
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_BUILD_DEQUE_02032013_1921)
#define BOOST_FUSION_BUILD_DEQUE_02032013_1921
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included"
#endif
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/container/deque/detail/cpp03/as_deque.hpp>
#include <boost/fusion/container/deque/front_extended_deque.hpp>
namespace boost { namespace fusion
{
namespace result_of
{
template <typename Sequence>
struct as_deque
{
typedef typename
detail::as_deque<result_of::size<Sequence>::value>
gen;
typedef typename gen::
template apply<typename result_of::begin<Sequence>::type>::type
type;
};
}
template <typename Sequence>
inline typename result_of::as_deque<Sequence>::type
as_deque(Sequence& seq)
{
typedef typename result_of::as_deque<Sequence>::gen gen;
return gen::call(fusion::begin(seq));
}
template <typename Sequence>
inline typename result_of::as_deque<Sequence const>::type
as_deque(Sequence const& seq)
{
typedef typename result_of::as_deque<Sequence const>::gen gen;
return gen::call(fusion::begin(seq));
}
}}
#endif

View File

@ -1,61 +0,0 @@
/*=============================================================================
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_PP_IS_ITERATING)
#if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211)
#define BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included"
#endif
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum_shifted.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#define FUSION_DEQUE_KEYED_VALUES_FORWARD(z, n, _) \
std::forward<BOOST_PP_CAT(T_, n)>(BOOST_PP_CAT(t, n))
#define BOOST_PP_FILENAME_1 \
<boost/fusion/container/deque/detail/cpp03/deque_keyed_values_call.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#undef FUSION_DEQUE_KEYED_VALUES_FORWARD
#endif
#else
#define N BOOST_PP_ITERATION()
static type construct(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t))
{
return type(t0,
deque_keyed_values_impl<
next_index
#if N > 1
, BOOST_PP_ENUM_SHIFTED_PARAMS(N, T)
#endif
>::construct(BOOST_PP_ENUM_SHIFTED_PARAMS(N, t)));
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <BOOST_PP_ENUM_PARAMS(N, typename T_)>
static type forward_(BOOST_PP_ENUM_BINARY_PARAMS(N, T_, && t))
{
return type(std::forward<T_0>(t0),
deque_keyed_values_impl<
next_index
#if N > 1
, BOOST_PP_ENUM_SHIFTED_PARAMS(N, T_)
#endif
>::forward_(BOOST_PP_ENUM_SHIFTED(N, FUSION_DEQUE_KEYED_VALUES_FORWARD, _)));
}
#endif
#undef N
#endif

View File

@ -5,18 +5,18 @@
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_PP_FUSION_DEQUE_26112006_1649)
#define BOOST_PP_FUSION_DEQUE_26112006_1649
#if !defined(BOOST_CPP03_FUSION_DEQUE_26112006_1649)
#define BOOST_CPP03_FUSION_DEQUE_26112006_1649
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE)
#error "C++03 only! This file should not have been included"
#endif
#include <boost/fusion/container/deque/detail/cpp03/limits.hpp>
#include <boost/fusion/container/deque/limits.hpp>
#include <boost/fusion/container/deque/front_extended_deque.hpp>
#include <boost/fusion/container/deque/back_extended_deque.hpp>
#include <boost/fusion/container/deque/detail/cpp03/deque_keyed_values.hpp>
#include <boost/fusion/container/deque/detail/cpp03/deque_initial_size.hpp>
#include <boost/fusion/container/deque/detail/cpp03_deque_keyed_values.hpp>
#include <boost/fusion/container/deque/detail/deque_initial_size.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
@ -40,10 +40,10 @@
#include <boost/utility/enable_if.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
#endif
/*=============================================================================
@ -78,7 +78,7 @@ namespace boost { namespace fusion {
mpl::if_<mpl::equal_to<size, mpl::int_<0> >, mpl::int_<0>, mpl::int_<-1> >::type::value> next_down;
typedef mpl::false_ is_view;
#include <boost/fusion/container/deque/detail/cpp03/deque_forward_ctor.hpp>
#include <boost/fusion/container/deque/detail/deque_forward_ctor.hpp>
deque()
{}
@ -87,37 +87,13 @@ namespace boost { namespace fusion {
: base(t0, detail::nil_keyed_element())
{}
explicit deque(deque const& rhs)
: base(rhs)
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename T0_>
explicit deque(T0_&& t0
, typename enable_if<is_convertible<T0_, T0> >::type* /*dummy*/ = 0
)
: base(std::forward<T0_>(t0), detail::nil_keyed_element())
{}
explicit deque(deque&& rhs)
: base(std::forward<deque>(rhs))
{}
#endif
template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)> const& seq)
deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)> const& seq)
: base(seq)
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>&& seq)
: base(std::forward<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>>(seq))
{}
#endif
template<typename Sequence>
deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0)
deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0)
: base(base::from_iterator(fusion::begin(seq)))
{}
@ -137,39 +113,7 @@ namespace boost { namespace fusion {
return *this;
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename T>
deque&
operator=(T&& rhs)
{
base::operator=(std::forward<T>(rhs));
return *this;
}
#endif
};
template <>
struct deque<> : detail::nil_keyed_element
{
typedef deque_tag fusion_tag;
typedef bidirectional_traversal_tag category;
typedef mpl::int_<0> size;
typedef mpl::int_<0> next_up;
typedef mpl::int_<0> next_down;
typedef mpl::false_ is_view;
template <typename Sequence>
deque(Sequence const&,
typename enable_if<
mpl::and_<
traits::is_sequence<Sequence>
, result_of::empty<Sequence> > >::type* /*dummy*/ = 0)
{}
deque() {}
};
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)

View File

@ -5,21 +5,21 @@
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(FUSION_PP_DEQUE_FORWARD_02092007_0749)
#define FUSION_PP_DEQUE_FORWARD_02092007_0749
#if !defined(FUSION_CPP03_DEQUE_FORWARD_02092007_0749)
#define FUSION_CPP03_DEQUE_FORWARD_02092007_0749
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE)
#error "C++03 only! This file should not have been included"
#endif
#include <boost/fusion/container/deque/detail/cpp03/limits.hpp>
#include <boost/fusion/container/deque/limits.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_fwd.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_fwd.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR "_fwd.hpp")
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR "_fwd.hpp")
#endif
/*=============================================================================

View File

@ -8,11 +8,11 @@
#if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330)
#define BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE)
#error "C++03 only! This file should not have been included"
#endif
#include <boost/fusion/container/deque/detail/cpp03/limits.hpp>
#include <boost/fusion/container/deque/limits.hpp>
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/preprocessor/iterate.hpp>
@ -34,7 +34,7 @@ namespace boost { namespace fusion
}}
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque_keyed_values" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
@ -68,12 +68,7 @@ namespace boost { namespace fusion { namespace detail
{
typedef nil_keyed_element type;
static type construct()
{
return type();
}
static type forward_()
static type call()
{
return type();
}
@ -89,7 +84,7 @@ namespace boost { namespace fusion { namespace detail
BOOST_PP_ENUM_SHIFTED_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type tail;
typedef keyed_element<N, T0, tail> type;
#include <boost/fusion/container/deque/detail/cpp03/deque_keyed_values_call.hpp>
#include <boost/fusion/container/deque/detail/deque_keyed_values_call.hpp>
};

View File

@ -0,0 +1,56 @@
/*=============================================================================
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_CPP11_DEQUE_KEYED_VALUES_07042012_1901)
#define BOOST_FUSION_DEQUE_DETAIL_CPP11_DEQUE_KEYED_VALUES_07042012_1901
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/mpl/int.hpp>
namespace boost { namespace fusion { namespace detail
{
template<typename Key, typename Value, typename Rest>
struct keyed_element;
template <typename N, typename ...Elements>
struct deque_keyed_values_impl;
template <typename N, typename Head, typename ...Tail>
struct deque_keyed_values_impl<N, Head, Tail...>
{
typedef mpl::int_<(N::value + 1)> next_index;
typedef typename deque_keyed_values_impl<next_index, Tail...>::type tail;
typedef keyed_element<N, Head, tail> type;
static type call(
typename detail::call_param<Head>::type head
, typename detail::call_param<Tail>::type... tail)
{
return type(
head
, deque_keyed_values_impl<next_index, Tail...>::call(tail...)
);
}
};
struct nil_keyed_element;
template <typename N>
struct deque_keyed_values_impl<N>
{
typedef nil_keyed_element type;
static type call() { return type(); }
};
template <typename ...Elements>
struct deque_keyed_values
: deque_keyed_values_impl<mpl::int_<0>, Elements...> {};
}}}
#endif

View File

@ -1,52 +1,31 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
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_PP_IS_ITERATING)
#if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_FORWARD_CTOR_04122006_2212)
#define BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_FORWARD_CTOR_04122006_2212
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included"
#endif
#define FUSION_DEQUE_FORWARD_CTOR_FORWARD(z, n, _) std::forward<T_##n>(t##n)
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#define BOOST_PP_FILENAME_1 \
<boost/fusion/container/deque/detail/cpp03/deque_forward_ctor.hpp>
<boost/fusion/container/deque/detail/deque_forward_ctor.hpp>
#define BOOST_PP_ITERATION_LIMITS (2, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#undef FUSION_DEQUE_FORWARD_CTOR_FORWARD
#endif
#else
#define N BOOST_PP_ITERATION()
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
deque(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t))
: base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::construct(BOOST_PP_ENUM_PARAMS(N, t)))
: base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::call(BOOST_PP_ENUM_PARAMS(N, t)))
{}
#else
deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& t))
: base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::construct(BOOST_PP_ENUM_PARAMS(N, t)))
{}
template <BOOST_PP_ENUM_PARAMS(N, typename T_)>
deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T_, && t))
: base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::
forward_(BOOST_PP_ENUM(N, FUSION_DEQUE_FORWARD_CTOR_FORWARD, _)))
{}
#endif
#undef N
#endif

View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
@ -8,10 +8,6 @@
#if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139)
#define BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included"
#endif
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/begin.hpp>
@ -25,7 +21,7 @@ namespace boost { namespace fusion
}}
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque_initial_size" FUSION_MAX_DEQUE_SIZE_STR ".hpp")

View File

@ -1,67 +1,102 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 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_CPP11_DEQUE_KEYED_VALUES_07042012_1901)
#define BOOST_FUSION_DEQUE_DETAIL_CPP11_DEQUE_KEYED_VALUES_07042012_1901
#if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330)
#define BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330
#include <boost/fusion/container/deque/limits.hpp>
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/print.hpp>
#define FUSION_VOID(z, n, _) void_
namespace boost { namespace fusion
{
struct void_;
}}
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque_keyed_values" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
#endif
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion { namespace detail
{
template<typename Key, typename Value, typename Rest>
struct keyed_element;
template <typename N, typename ...Elements>
struct deque_keyed_values_impl;
template <typename N, typename Head, typename ...Tail>
struct deque_keyed_values_impl<N, Head, Tail...>
{
typedef mpl::int_<(N::value + 1)> next_index;
typedef typename deque_keyed_values_impl<next_index, Tail...>::type tail;
typedef keyed_element<N, Head, tail> type;
static type construct(
typename detail::call_param<Head>::type head
, typename detail::call_param<Tail>::type... tail)
{
return type(
head
, deque_keyed_values_impl<next_index, Tail...>::construct(tail...)
);
}
template <typename Head_, typename ...Tail_>
static type forward_(Head_&& head, Tail_&&... tail)
{
return type(
std::forward<Head_>(head)
, deque_keyed_values_impl<next_index, Tail_...>::
forward_(std::forward<Tail_>(tail)...)
);
}
};
struct nil_keyed_element;
template <typename N>
struct deque_keyed_values_impl<N>
template<typename N, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
struct deque_keyed_values_impl;
template<typename N>
struct deque_keyed_values_impl<N, BOOST_PP_ENUM(FUSION_MAX_DEQUE_SIZE, FUSION_VOID, _)>
{
typedef nil_keyed_element type;
static type construct() { return type(); }
static type forward_() { return type(); }
static type call()
{
return type();
}
};
template <typename ...Elements>
template<typename N, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>
struct deque_keyed_values_impl
{
typedef mpl::int_<mpl::plus<N, mpl::int_<1> >::value> next_index;
typedef typename deque_keyed_values_impl<
next_index,
BOOST_PP_ENUM_SHIFTED_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type tail;
typedef keyed_element<N, T0, tail> type;
#include <boost/fusion/container/deque/detail/deque_keyed_values_call.hpp>
};
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
struct deque_keyed_values
: deque_keyed_values_impl<mpl::int_<0>, Elements...> {};
: deque_keyed_values_impl<mpl::int_<0>, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>
{};
}}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#undef FUSION_VOID
#endif

View File

@ -0,0 +1,38 @@
/*=============================================================================
Copyright (c) 2005-2011 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_PP_IS_ITERATING)
#if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211)
#define BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#define BOOST_PP_FILENAME_1 \
<boost/fusion/container/deque/detail/deque_keyed_values_call.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#endif
#else
#define N BOOST_PP_ITERATION()
static type call(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t))
{
return type(t0,
deque_keyed_values_impl<
next_index
#if N > 1
, BOOST_PP_ENUM_SHIFTED_PARAMS(N, T)
#endif
>::call(BOOST_PP_ENUM_SHIFTED_PARAMS(N, t)));
}
#undef N
#endif

View File

@ -1,8 +1,8 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
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_END_IMPL_09122006_2034)
@ -13,29 +13,27 @@
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/if.hpp>
namespace boost { namespace fusion
{
namespace boost { namespace fusion {
struct deque_tag;
namespace extension
namespace extension
{
template<typename T>
struct end_impl;
template<>
struct end_impl<deque_tag>
{
template<typename Sequence>
struct apply
{
typedef typename
mpl::if_c<
(Sequence::next_down::value == Sequence::next_up::value)
, deque_iterator<Sequence, 0>
, deque_iterator<Sequence, Sequence::next_up::value>
>::type
type;
typedef typename mpl::if_<
mpl::equal_to<typename Sequence::next_down, typename Sequence::next_up>,
deque_iterator<Sequence, 0>,
deque_iterator<
Sequence, Sequence::next_up::value> >::type type;
static type call(Sequence& seq)
{
return type(seq);

View File

@ -1,7 +1,7 @@
/*=============================================================================
Copyright (c) 2010 Christopher Schmidt
Distributed under the Boost Software License, Version 1.0. (See accompanying
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)
==============================================================================*/
@ -14,16 +14,18 @@ namespace boost { namespace fusion
{
struct deque_tag;
namespace extension
namespace extension
{
template<typename T>
struct is_sequence_impl;
template<>
struct is_sequence_impl<deque_tag>
{
template<typename Sequence>
struct apply : mpl::true_ {};
struct apply
: mpl::true_
{};
};
}
}}

View File

@ -1,8 +1,8 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
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)
@ -12,34 +12,34 @@
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
namespace boost { namespace fusion
{
struct fusion_sequence_tag;
}}
namespace boost { namespace fusion {
struct fusion_sequence_tag;
namespace detail {
namespace boost { namespace fusion { namespace detail
{
struct nil_keyed_element
{
typedef fusion_sequence_tag tag;
void get();
template<typename It>
static nil_keyed_element
static nil_keyed_element
from_iterator(It const&)
{
return nil_keyed_element();
}
};
template <typename Key, typename Value, typename Rest>
struct keyed_element : Rest
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>
template<typename It>
static keyed_element
from_iterator(It const& it)
{
@ -47,42 +47,16 @@ namespace boost { namespace fusion { namespace detail
*it, base::from_iterator(fusion::next(it)));
}
keyed_element(keyed_element const& rhs)
: Rest(rhs.get_base()), value_(rhs.value_)
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
keyed_element(keyed_element&& rhs)
: Rest(std::forward<Rest>(rhs.forward_base()))
, value_(std::forward<Value>(rhs.value_))
{}
#endif
template <typename U, typename Rst>
template<typename U, typename Rst>
keyed_element(keyed_element<Key, U, Rst> const& rhs)
: Rest(rhs.get_base()), value_(rhs.value_)
: Rest(rhs.get_base()), value_(rhs.value_)
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#endif
Rest& get_base()
Rest const get_base() const
{
return *this;
}
Rest const& get_base() const
{
return *this;
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
Rest&& forward_base()
{
return std::forward<Rest>(*static_cast<Rest*>(this));
}
#endif
typename cref_result<Value>::type get(Key) const
{
return value_;
@ -93,19 +67,10 @@ namespace boost { namespace fusion { namespace detail
return value_;
}
keyed_element(
typename detail::call_param<Value>::type value
, Rest const& rest)
keyed_element(typename call_param<Value>::type value, Rest const& rest)
: Rest(rest), value_(value)
{}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
keyed_element(Value&& value, Rest&& rest)
: Rest(std::forward<Rest>(rest))
, value_(std::forward<Value>(value))
{}
#endif
keyed_element()
: Rest(), value_()
{}
@ -125,21 +90,12 @@ namespace boost { namespace fusion { namespace detail
return *this;
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
keyed_element& operator=(keyed_element&& rhs)
{
base::operator=(std::forward<keyed_element>(rhs));
value_ = std::forward<Value>(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>
: keyed_element_value_at<typename Elem::base, Key>
{};
template<typename Key, typename Value, typename Rest>
@ -147,6 +103,7 @@ namespace boost { namespace fusion { namespace detail
{
typedef Value type;
};
}}}
#endif

View File

@ -8,15 +8,15 @@
==============================================================================*/
#if FUSION_MAX_DEQUE_SIZE <= 10
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque10.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/as_deque10.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 20
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque20.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/as_deque20.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 30
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque30.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/as_deque30.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 40
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque40.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/as_deque40.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 50
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque50.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/as_deque50.hpp>
#else
#error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
#endif

View File

@ -8,15 +8,15 @@
==============================================================================*/
#if FUSION_MAX_DEQUE_SIZE <= 10
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque10.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque10.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 20
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque20.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque20.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 30
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque30.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque30.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 40
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque40.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque40.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 50
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque50.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque50.hpp>
#else
#error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
#endif

View File

@ -8,15 +8,15 @@
==============================================================================*/
#if FUSION_MAX_DEQUE_SIZE <= 10
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque10_fwd.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque10_fwd.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 20
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque20_fwd.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque20_fwd.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 30
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque30_fwd.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque30_fwd.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 40
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque40_fwd.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque40_fwd.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 50
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque50_fwd.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque50_fwd.hpp>
#else
#error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
#endif

View File

@ -8,15 +8,15 @@
==============================================================================*/
#if FUSION_MAX_DEQUE_SIZE <= 10
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size10.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size10.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 20
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size20.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size20.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 30
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size30.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size30.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 40
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size40.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size40.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 50
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size50.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size50.hpp>
#else
#error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
#endif

View File

@ -8,15 +8,15 @@
==============================================================================*/
#if FUSION_MAX_DEQUE_SIZE <= 10
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values10.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values10.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 20
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values20.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values20.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 30
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values30.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values30.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 40
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values40.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values40.hpp>
#elif FUSION_MAX_DEQUE_SIZE <= 50
#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values50.hpp>
#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values50.hpp>
#else
#error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
#endif

View File

@ -1,8 +1,8 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
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_VALUE_AT_IMPL_08122006_0756)
@ -13,15 +13,15 @@
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/assert.hpp>
namespace boost { namespace fusion
{
namespace boost { namespace fusion {
struct deque_tag;
namespace extension
namespace extension
{
template<typename T>
struct value_at_impl;
template<>
struct value_at_impl<deque_tag>
{
@ -31,12 +31,10 @@ namespace boost { namespace fusion
typedef typename Sequence::next_up next_up;
typedef typename Sequence::next_down next_down;
BOOST_MPL_ASSERT_RELATION(next_down::value, !=, next_up::value);
static int const offset = next_down::value + 1;
typedef mpl::int_<(N::value + offset)> adjusted_index;
typedef typename
detail::keyed_element_value_at<Sequence, adjusted_index>::type
type;
typedef mpl::plus<next_down, mpl::int_<1> > offset;
typedef mpl::int_<mpl::plus<N, offset>::value> adjusted_index;
typedef typename detail::keyed_element_value_at<Sequence, adjusted_index>::type type;
};
};
}

View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
@ -8,39 +8,32 @@
#if !defined(BOOST_FUSION_FRONT_EXTENDED_DEQUE_26112006_2209)
#define BOOST_FUSION_FRONT_EXTENDED_DEQUE_26112006_2209
#include <boost/mpl/int.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/container/deque/detail/keyed_element.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/fusion/support/sequence_base.hpp>
namespace boost { namespace fusion
{
template <typename Deque, typename T>
template<typename Deque, typename T>
struct front_extended_deque
: detail::keyed_element<typename Deque::next_down, T, Deque>
, sequence_base<front_extended_deque<Deque, T> >
: detail::keyed_element<typename Deque::next_down, T, Deque>,
sequence_base<front_extended_deque<Deque, T> >
{
typedef detail::keyed_element<typename Deque::next_down, T, Deque> base;
typedef mpl::int_<(Deque::next_down::value - 1)> next_down;
typedef mpl::int_<mpl::minus<typename Deque::next_down, mpl::int_<1> >::value> next_down;
typedef typename Deque::next_up next_up;
typedef mpl::int_<(result_of::size<Deque>::value + 1)> size;
typedef mpl::plus<typename result_of::size<Deque>::type, mpl::int_<1> > size;
template <typename Arg>
front_extended_deque(Deque const& deque, Arg const& val)
: base(val, deque)
front_extended_deque(Deque const& deque, typename add_reference<typename add_const<T>::type>::type t)
: base(t, deque)
{}
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename Arg>
front_extended_deque(Deque const& deque, Arg& val)
: base(val, deque)
{}
#else
template <typename Arg>
front_extended_deque(Deque const& deque, Arg&& val)
: base(std::forward<Arg>(val), deque)
{}
#endif
};
}}

View File

@ -1,5 +1,5 @@
/*=============================================================================
Copyright (c) 2005-2012 Joel de Guzman
Copyright (c) 2005-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
@ -8,10 +8,6 @@
#if !defined(BOOST_FUSION_DEQUE_LIMITS_26112006_1737)
#define BOOST_FUSION_DEQUE_LIMITS_26112006_1737
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included"
#endif
#include <boost/fusion/container/vector/limits.hpp>
#if !defined(FUSION_MAX_DEQUE_SIZE)

View File

@ -11,11 +11,11 @@
namespace boost { namespace fusion
{
struct nil_;
struct nil;
namespace result_of
{
template <typename Car, typename Cdr = nil_>
template <typename Car, typename Cdr = nil>
struct cons_tie
{
typedef cons<Car&, Cdr> type;

View File

@ -1,23 +1,41 @@
/*=============================================================================
Copyright (c) 2001-2013 Joel de Guzman
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 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(FUSION_DEQUE_TIE_01272013_1401)
#define FUSION_DEQUE_TIE_01272013_1401
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_DEQUE_TIE_07192005_1242)
#define FUSION_DEQUE_TIE_07192005_1242
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
# include <boost/fusion/container/generation/detail/pp_deque_tie.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/generation/detail/preprocessed/deque_tie.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque_tie" FUSION_MAX_DEQUE_SIZE_STR".hpp")
#endif
///////////////////////////////////////////////////////////////////////////////
// C++11 variadic interface
///////////////////////////////////////////////////////////////////////////////
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
#include <boost/fusion/support/detail/as_fusion_element.hpp>
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion
{
@ -25,21 +43,63 @@ namespace boost { namespace fusion
namespace result_of
{
template <typename ...T>
struct deque_tie
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_DEQUE_SIZE, typename T, void_)
, typename Extra = void_
>
struct deque_tie;
}
#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/deque_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_REF
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
typedef deque<T&...> type;
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#define TEXT(z, n, text) , text
struct deque_tie< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_DEQUE_SIZE, TEXT, void_) >
#undef TEXT
#else
struct deque_tie<BOOST_PP_ENUM_PARAMS(N, T)>
#endif
{
typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
};
}
template <typename ...T>
inline deque<T&...>
deque_tie(T&... arg)
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
deque_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
{
return deque<T&...>(arg...);
return deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
}}
#endif
#endif
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

View File

@ -1,105 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 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)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_PP_DEQUE_TIE_07192005_1242)
#define FUSION_PP_DEQUE_TIE_07192005_1242
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/generation/detail/preprocessed/deque_tie.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque_tie" FUSION_MAX_DEQUE_SIZE_STR".hpp")
#endif
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_DEQUE_SIZE, typename T, void_)
, typename Extra = void_
>
struct deque_tie;
}
#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_deque_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_REF
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#define TEXT(z, n, text) , text
struct deque_tie< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_DEQUE_SIZE, TEXT, void_) >
#undef TEXT
#else
struct deque_tie<BOOST_PP_ENUM_PARAMS(N, T)>
#endif
{
typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
deque_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
{
return deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

View File

@ -1,121 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 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)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_PP_MAKE_DEQUE_07162005_0243)
#define FUSION_MAKE_PP_DEQUE_07162005_0243
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/generation/detail/preprocessed/make_deque.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_deque" FUSION_MAX_DEQUE_SIZE_STR".hpp")
#endif
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_DEQUE_SIZE, typename T, void_)
, typename Extra = void_
>
struct make_deque;
template <>
struct make_deque<>
{
typedef deque<> type;
};
}
inline deque<>
make_deque()
{
return deque<>();
}
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_deque.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_AS_FUSION_ELEMENT
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#define TEXT(z, n, text) , text
struct make_deque< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_DEQUE_SIZE, TEXT, void_) >
#undef TEXT
#else
struct make_deque<BOOST_PP_ENUM_PARAMS(N, T)>
#endif
{
typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
make_deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
{
return deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

View File

@ -1,132 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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_PP_IS_ITERATING
#if !defined(FUSION_PP_MAKE_MAP_07222005_1247)
#define FUSION_PP_MAKE_MAP_07222005_1247
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/fusion/container/map/map.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/fusion/support/pair.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/generation/detail/preprocessed/make_map.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_map" FUSION_MAX_MAP_SIZE_STR".hpp")
#endif
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename K, void_)
, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename D, void_)
, typename Extra = void_
>
struct make_map;
template <>
struct make_map<>
{
typedef map<> type;
};
}
inline map<>
make_map()
{
return map<>();
}
#define BOOST_FUSION_PAIR(z, n, data) \
fusion::pair< \
BOOST_PP_CAT(K, n) \
, typename detail::as_fusion_element<BOOST_PP_CAT(D, n)>::type>
#define BOOST_FUSION_MAKE_PAIR(z, n, data) \
fusion::make_pair<BOOST_PP_CAT(K, n)>(BOOST_PP_CAT(_, n)) \
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_map.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_PAIR
#undef BOOST_FUSION_MAKE_PAIR
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#define TEXT(z, n, text) , text
struct make_map<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D) BOOST_PP_REPEAT_FROM_TO(N, FUSION_MAX_VECTOR_SIZE, TEXT, void_) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_VECTOR_SIZE, TEXT, void_)>
#undef TEXT
#else
struct make_map<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D)>
#endif
{
typedef map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)> type;
};
}
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
inline map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)>
make_map(BOOST_PP_ENUM_BINARY_PARAMS(N, D, const& _))
{
return map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)>(
BOOST_PP_ENUM(N, BOOST_FUSION_MAKE_PAIR, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

View File

@ -1,136 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 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)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_PP_MAP_TIE_20060814_1116)
#define FUSION_PP_MAP_TIE_20060814_1116
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/fusion/container/map/map.hpp>
#include <boost/fusion/container/map/detail/cpp03/limits.hpp>
#include <boost/fusion/support/pair.hpp>
#include <boost/fusion/container/generation/pair_tie.hpp>
#include <boost/type_traits/add_reference.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/generation/detail/preprocessed/map_tie.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/map_tie" FUSION_MAX_MAP_SIZE_STR".hpp")
#endif
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_MAP_SIZE, typename K, void_)
, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_MAP_SIZE, typename D, void_)
, typename Extra = void_
>
struct map_tie;
template <>
struct map_tie<>
{
typedef map<> type;
};
}
inline map<>
map_tie()
{
return map<>();
}
#define BOOST_FUSION_TIED_PAIR(z, n, data) \
fusion::pair< \
BOOST_PP_CAT(K, n) \
, typename add_reference<BOOST_PP_CAT(D, n)>::type>
#define BOOST_FUSION_PAIR_TIE(z, n, data) \
fusion::pair_tie<BOOST_PP_CAT(K, n)>(BOOST_PP_CAT(_, n)) \
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_map_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_MAP_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_PAIR
#undef BOOST_FUSION_MAKE_PAIR
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#define TEXT(z, n, text) , text
struct map_tie<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D) BOOST_PP_REPEAT_FROM_TO(N, FUSION_MAX_MAP_SIZE, TEXT, void_) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_MAP_SIZE, TEXT, void_)>
#undef TEXT
#else
struct map_tie<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D)>
#endif
{
typedef map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)> type;
};
}
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
inline map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)>
map_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, D, & _))
{
return map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)>(
BOOST_PP_ENUM(N, BOOST_FUSION_PAIR_TIE, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

View File

@ -13,11 +13,11 @@
namespace boost { namespace fusion
{
struct nil_;
struct nil;
namespace result_of
{
template <typename Car, typename Cdr = nil_>
template <typename Car, typename Cdr = nil>
struct make_cons
{
typedef cons<typename detail::as_fusion_element<Car>::type, Cdr> type;

View File

@ -1,43 +1,124 @@
/*=============================================================================
Copyright (c) 2001-2013 Joel de Guzman
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 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(FUSION_MAKE_DEQUE_01272013_1401)
#define FUSION_MAKE_DEQUE_01272013_1401
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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_PP_IS_ITERATING
#if !defined(FUSION_MAKE_DEQUE_07162005_0243)
#define FUSION_MAKE_DEQUE_07162005_0243
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
# include <boost/fusion/container/generation/detail/pp_make_deque.hpp>
#else
///////////////////////////////////////////////////////////////////////////////
// C++11 variadic interface
///////////////////////////////////////////////////////////////////////////////
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/generation/detail/preprocessed/make_deque.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_deque" FUSION_MAX_DEQUE_SIZE_STR".hpp")
#endif
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <typename ...T>
struct make_deque
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_DEQUE_SIZE, typename T, void_)
, typename Extra = void_
>
struct make_deque;
template <>
struct make_deque<>
{
typedef deque<T...> type;
typedef deque<> type;
};
}
template <typename ...T>
inline deque<typename detail::as_fusion_element<T>::type...>
make_deque(T const&... arg)
inline deque<>
make_deque()
{
return deque<typename detail::as_fusion_element<T>::type...>(arg...);
return deque<>();
}
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/make_deque.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_AS_FUSION_ELEMENT
}}
#endif
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#define TEXT(z, n, text) , text
struct make_deque< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_DEQUE_SIZE, TEXT, void_) >
#undef TEXT
#else
struct make_deque<BOOST_PP_ENUM_PARAMS(N, T)>
#endif
{
typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
make_deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
{
return deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

View File

@ -1,62 +1,132 @@
/*=============================================================================
Copyright (c) 2001-2013 Joel de Guzman
Copyright (c) 2001-2011 Joel de Guzman
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_PP_IS_ITERATING
#if !defined(FUSION_MAKE_MAP_07222005_1247)
#define FUSION_MAKE_MAP_07222005_1247
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/fusion/container/map/map.hpp>
#if !defined(BOOST_FUSION_HAS_VARIADIC_MAP)
# include <boost/fusion/container/generation/detail/pp_make_map.hpp>
#else
///////////////////////////////////////////////////////////////////////////////
// C++11 variadic interface
///////////////////////////////////////////////////////////////////////////////
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/fusion/support/pair.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/generation/detail/preprocessed/make_map.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_map" FUSION_MAX_MAP_SIZE_STR".hpp")
#endif
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <typename ...Key>
struct make_map
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename K, void_)
, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename D, void_)
, typename Extra = void_
>
struct make_map;
template <>
struct make_map<>
{
template <typename ...T>
struct apply
{
typedef map<
fusion::pair<
Key
, typename detail::as_fusion_element<T>::type
>...>
type;
};
typedef map<> type;
};
}
template <typename ...Key, typename ...T>
inline map<
fusion::pair<
Key
, typename detail::as_fusion_element<T>::type
>...>
make_map(T const&... arg)
inline map<>
make_map()
{
typedef map<
fusion::pair<
Key
, typename detail::as_fusion_element<T>::type
>...>
result_type;
return result_type(arg...);
return map<>();
}
#define BOOST_FUSION_PAIR(z, n, data) \
fusion::pair< \
BOOST_PP_CAT(K, n) \
, typename detail::as_fusion_element<BOOST_PP_CAT(D, n)>::type>
#define BOOST_FUSION_MAKE_PAIR(z, n, data) \
fusion::make_pair<BOOST_PP_CAT(K, n)>(BOOST_PP_CAT(_, n)) \
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/make_map.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_PAIR
#undef BOOST_FUSION_MAKE_PAIR
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#define TEXT(z, n, text) , text
struct make_map<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D) BOOST_PP_REPEAT_FROM_TO(N, FUSION_MAX_VECTOR_SIZE, TEXT, void_) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_VECTOR_SIZE, TEXT, void_)>
#undef TEXT
#else
struct make_map<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D)>
#endif
{
typedef map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)> type;
};
}
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
inline map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)>
make_map(BOOST_PP_ENUM_BINARY_PARAMS(N, D, const& _))
{
return map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)>(
BOOST_PP_ENUM(N, BOOST_FUSION_MAKE_PAIR, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

View File

@ -1,46 +1,136 @@
/*=============================================================================
Copyright (c) 2001-2013 Joel de Guzman
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 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(FUSION_MAP_TIE_07222005_1247)
#define FUSION_MAP_TIE_07222005_1247
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_MAP_TIE_20060814_1116)
#define FUSION_MAP_TIE_20060814_1116
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/fusion/container/map/map.hpp>
#if !defined(BOOST_FUSION_HAS_VARIADIC_MAP)
# include <boost/fusion/container/generation/detail/pp_map_tie.hpp>
#else
///////////////////////////////////////////////////////////////////////////////
// C++11 variadic interface
///////////////////////////////////////////////////////////////////////////////
#include <boost/fusion/container/map/limits.hpp>
#include <boost/fusion/support/pair.hpp>
#include <boost/fusion/container/generation/pair_tie.hpp>
#include <boost/type_traits/add_reference.hpp>
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
#include <boost/fusion/container/generation/detail/preprocessed/map_tie.hpp>
#else
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/map_tie" FUSION_MAX_MAP_SIZE_STR".hpp")
#endif
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
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)
This is an auto-generated file. Do not edit!
==============================================================================*/
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <typename ...Key>
struct map_tie
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_MAP_SIZE, typename K, void_)
, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_MAP_SIZE, typename D, void_)
, typename Extra = void_
>
struct map_tie;
template <>
struct map_tie<>
{
template <typename ...T>
struct apply
{
typedef map<fusion::pair<Key, T&>...> type;
};
typedef map<> type;
};
}
template <typename ...Key, typename ...T>
inline map<fusion::pair<Key, T&>...>
map_tie(T&... arg)
inline map<>
map_tie()
{
typedef map<fusion::pair<Key, T&>...> result_type;
return result_type(arg...);
return map<>();
}
#define BOOST_FUSION_TIED_PAIR(z, n, data) \
fusion::pair< \
BOOST_PP_CAT(K, n) \
, typename add_reference<BOOST_PP_CAT(D, n)>::type>
#define BOOST_FUSION_PAIR_TIE(z, n, data) \
fusion::pair_tie<BOOST_PP_CAT(K, n)>(BOOST_PP_CAT(_, n)) \
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/map_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_MAP_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_PAIR
#undef BOOST_FUSION_MAKE_PAIR
}}
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
#endif
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
#define TEXT(z, n, text) , text
struct map_tie<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D) BOOST_PP_REPEAT_FROM_TO(N, FUSION_MAX_MAP_SIZE, TEXT, void_) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_MAP_SIZE, TEXT, void_)>
#undef TEXT
#else
struct map_tie<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D)>
#endif
{
typedef map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)> type;
};
}
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
inline map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)>
map_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, D, & _))
{
return map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)>(
BOOST_PP_ENUM(N, BOOST_FUSION_PAIR_TIE, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

View File

@ -34,7 +34,7 @@ namespace boost { namespace fusion
struct forward_traversal_tag;
struct fusion_sequence_tag;
struct nil_ : sequence_base<nil_>
struct nil : sequence_base<nil>
{
typedef mpl::int_<0> size;
typedef cons_tag fusion_tag;
@ -44,10 +44,10 @@ namespace boost { namespace fusion
typedef void_ car_type;
typedef void_ cdr_type;
nil_() {}
nil() {}
template <typename Iterator>
nil_(Iterator const& /*iter*/, mpl::true_ /*this_is_an_iterator*/)
nil(Iterator const& /*iter*/, mpl::true_ /*this_is_an_iterator*/)
{}
template <typename Iterator>
@ -56,7 +56,7 @@ namespace boost { namespace fusion
}
};
template <typename Car, typename Cdr /*= nil_*/>
template <typename Car, typename Cdr /*= nil*/>
struct cons : sequence_base<cons<Car, Cdr> >
{
typedef mpl::int_<Cdr::size::value+1> size;

View File

@ -10,12 +10,9 @@
namespace boost { namespace fusion
{
struct nil_;
#ifndef nil
typedef nil_ nil;
#endif
struct nil;
template <typename Car, typename Cdr = nil_>
template <typename Car, typename Cdr = nil>
struct cons;
}}

View File

@ -18,14 +18,14 @@
namespace boost { namespace fusion
{
struct nil_;
struct nil;
struct cons_iterator_tag;
struct forward_traversal_tag;
template <typename Cons>
struct cons_iterator_identity;
template <typename Cons = nil_>
template <typename Cons = nil>
struct cons_iterator : iterator_base<cons_iterator<Cons> >
{
typedef cons_iterator_tag fusion_tag;
@ -49,40 +49,40 @@ namespace boost { namespace fusion
{
typedef forward_traversal_tag category;
typedef cons_iterator_tag fusion_tag;
typedef nil_ cons_type;
typedef nil cons_type;
typedef cons_iterator_identity<
add_const<nil_>::type>
add_const<nil>::type>
identity;
nil_iterator() {}
explicit nil_iterator(nil_ const&) {}
explicit nil_iterator(nil const&) {}
};
template <>
struct cons_iterator<nil_> : nil_iterator
struct cons_iterator<nil> : nil_iterator
{
cons_iterator() {}
explicit cons_iterator(nil_ const&) {}
explicit cons_iterator(nil const&) {}
};
template <>
struct cons_iterator<nil_ const> : nil_iterator
struct cons_iterator<nil const> : nil_iterator
{
cons_iterator() {}
explicit cons_iterator(nil_ const&) {}
explicit cons_iterator(nil const&) {}
};
template <>
struct cons_iterator<list<> > : nil_iterator
{
cons_iterator() {}
explicit cons_iterator(nil_ const&) {}
explicit cons_iterator(nil const&) {}
};
template <>
struct cons_iterator<list<> const> : nil_iterator
{
cons_iterator() {}
explicit cons_iterator(nil_ const&) {}
explicit cons_iterator(nil const&) {}
};
}}

View File

@ -13,7 +13,7 @@
namespace boost { namespace fusion
{
struct nil_;
struct nil;
struct cons_tag;

View File

@ -24,12 +24,12 @@ namespace boost { namespace fusion { namespace detail
template <typename First, typename Last>
struct build_cons<First, Last, true>
{
typedef nil_ type;
typedef nil type;
static nil_
static nil
call(First const&, Last const&)
{
return nil_();
return nil();
}
};

View File

@ -13,7 +13,7 @@ namespace boost { namespace fusion
{
struct cons_tag;
struct nil_;
struct nil;
template <typename Car, typename Cdr>
struct cons;
@ -28,7 +28,7 @@ namespace boost { namespace fusion
{
template <typename Sequence>
struct apply
: boost::is_convertible<Sequence, nil_>
: boost::is_convertible<Sequence, nil>
{};
};
}

View File

@ -13,7 +13,7 @@
namespace boost { namespace fusion
{
struct nil_;
struct nil;
struct cons_tag;
@ -35,7 +35,7 @@ namespace boost { namespace fusion
struct apply
{
typedef cons_iterator<
typename mpl::if_<is_const<Sequence>, nil_ const, nil_>::type>
typename mpl::if_<is_const<Sequence>, nil const, nil>::type>
type;
static type

Some files were not shown because too many files have changed in this diff Show More