feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

Merge from trunk

Browse Source 
[SVN r81061]
This commit is contained in:
Joel de Guzman
2012-10-25 02:06:21 +00:00
parent 940c594d3e
commit fc38122f0f
21 changed files with 525 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

239
include/boost/fusion/adapted/struct/detail/define_struct_inline.hpp
View File

@ -20,6 +20,7 @@
#include <boost/mpl/if.hpp> #include <boost/mpl/if.hpp>
#include <boost/type_traits/is_const.hpp> #include <boost/type_traits/is_const.hpp>
#include <boost/preprocessor/comma_if.hpp> #include <boost/preprocessor/comma_if.hpp>
#include <boost/preprocessor/facilities/is_empty.hpp>
#include <boost/preprocessor/repeat.hpp> #include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/seq/for_each_i.hpp> #include <boost/preprocessor/seq/for_each_i.hpp>
#include <boost/preprocessor/seq/size.hpp> #include <boost/preprocessor/seq/size.hpp>
@ -61,15 +62,20 @@
BOOST_PP_COMMA_IF(N) \ BOOST_PP_COMMA_IF(N) \
BOOST_FUSION_MAKE_INIT_LIST_ENTRY_I(BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)) 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 // Note: all template parameter names need to be uglified, otherwise they might
// shadow a template parameter of the struct when used with // shadow a template parameter of the struct when used with
// BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE // BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE
#define BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS(Z, N, NAME) \ #define BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS(Z, N, NAME) \
template <typename boost_fusion_uglified_Sq> \ template <typename boost_fusion_detail_Sq> \
struct value_of<NAME##_iterator<boost_fusion_uglified_Sq, N> > \ struct value_of< \
BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, N> \
> \
: boost::mpl::identity< \ : boost::mpl::identity< \
typename boost_fusion_uglified_Sq::t##N##_type \ typename boost_fusion_detail_Sq::t##N##_type \
> \ > \
{ \ { \
}; };
@ -77,10 +83,10 @@
#define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ #define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
SPEC_TYPE, CALL_ARG_TYPE, TYPE_QUAL, ATTRIBUTE, N) \ SPEC_TYPE, CALL_ARG_TYPE, TYPE_QUAL, ATTRIBUTE, N) \
\ \
template <typename boost_fusion_uglified_Sq> \ template <typename boost_fusion_detail_Sq> \
struct deref<SPEC_TYPE, N> > \ struct deref<SPEC_TYPE, N> > \
{ \ { \
typedef typename boost_fusion_uglified_Sq::t##N##_type TYPE_QUAL& type; \ typedef typename boost_fusion_detail_Sq::t##N##_type TYPE_QUAL& type; \
static type call(CALL_ARG_TYPE, N> const& iter) \ static type call(CALL_ARG_TYPE, N> const& iter) \
{ \ { \
return iter.seq_.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); \ return iter.seq_.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); \
@ -89,48 +95,48 @@
#define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS(R, NAME, N, ATTRIBUTE) \ #define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS(R, NAME, N, ATTRIBUTE) \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
BOOST_PP_CAT(NAME, _iterator)<boost_fusion_uglified_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \
BOOST_PP_CAT(NAME, _iterator)<boost_fusion_uglified_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \
, \ , \
ATTRIBUTE, \ ATTRIBUTE, \
N) \ N) \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
BOOST_PP_CAT(NAME, _iterator)<const boost_fusion_uglified_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \
BOOST_PP_CAT(NAME, _iterator)<const boost_fusion_uglified_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \
const, \ const, \
ATTRIBUTE, \ ATTRIBUTE, \
N) \ N) \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
const BOOST_PP_CAT(NAME, _iterator)<boost_fusion_uglified_Sq, \ const BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \
BOOST_PP_CAT(NAME, _iterator)<boost_fusion_uglified_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \
, \ , \
ATTRIBUTE, \ ATTRIBUTE, \
N) \ N) \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \
const BOOST_PP_CAT(NAME, _iterator)<const boost_fusion_uglified_Sq, \ const BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \
BOOST_PP_CAT(NAME, _iterator)<const boost_fusion_uglified_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \
const, \ const, \
ATTRIBUTE, \ ATTRIBUTE, \
N) \ N) \
#define BOOST_FUSION_MAKE_VALUE_AT_SPECS(Z, N, DATA) \ #define BOOST_FUSION_MAKE_VALUE_AT_SPECS(Z, N, DATA) \
template <typename boost_fusion_uglified_Sq> \ template <typename boost_fusion_detail_Sq> \
struct value_at<boost_fusion_uglified_Sq, boost::mpl::int_<N> > \ struct value_at<boost_fusion_detail_Sq, boost::mpl::int_<N> > \
{ \ { \
typedef typename boost_fusion_uglified_Sq::t##N##_type type; \ typedef typename boost_fusion_detail_Sq::t##N##_type type; \
}; };
#define BOOST_FUSION_MAKE_AT_SPECS(R, DATA, N, ATTRIBUTE) \ #define BOOST_FUSION_MAKE_AT_SPECS(R, DATA, N, ATTRIBUTE) \
template <typename boost_fusion_uglified_Sq> \ template <typename boost_fusion_detail_Sq> \
struct at<boost_fusion_uglified_Sq, boost::mpl::int_<N> > \ struct at<boost_fusion_detail_Sq, boost::mpl::int_<N> > \
{ \ { \
typedef typename boost::mpl::if_< \ typedef typename boost::mpl::if_< \
boost::is_const<boost_fusion_uglified_Sq>, \ boost::is_const<boost_fusion_detail_Sq>, \
typename boost_fusion_uglified_Sq::t##N##_type const&, \ typename boost_fusion_detail_Sq::t##N##_type const&, \
typename boost_fusion_uglified_Sq::t##N##_type& \ typename boost_fusion_detail_Sq::t##N##_type& \
>::type type; \ >::type type; \
\ \
static type call(boost_fusion_uglified_Sq& sq) \ static type call(boost_fusion_detail_Sq& sq) \
{ \ { \
return sq. BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); \ return sq. BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); \
} \ } \
@ -142,7 +148,11 @@
#define BOOST_FUSION_MAKE_DATA_MEMBER(R, DATA, N, ATTRIBUTE) \ #define BOOST_FUSION_MAKE_DATA_MEMBER(R, DATA, N, ATTRIBUTE) \
BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE);
// 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) \ #define BOOST_FUSION_DEFINE_STRUCT_INLINE_IMPL(NAME, ATTRIBUTES) \
BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES) \
struct NAME : boost::fusion::sequence_facade< \ struct NAME : boost::fusion::sequence_facade< \
NAME, \ NAME, \
boost::fusion::random_access_traversal_tag \ boost::fusion::random_access_traversal_tag \
@ -154,6 +164,8 @@
#define BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE_IMPL( \ #define BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE_IMPL( \
TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES) \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES) \
\ \
BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES) \
\
template < \ template < \
BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL( \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL( \
(0)TEMPLATE_PARAMS_SEQ) \ (0)TEMPLATE_PARAMS_SEQ) \
@ -173,176 +185,201 @@
NAME, \ NAME, \
BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END)) 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) \ #define BOOST_FUSION_DEFINE_STRUCT_MEMBERS_IMPL(NAME, ATTRIBUTES_SEQ) \
BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL( \ BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL( \
NAME, \ NAME, \
ATTRIBUTES_SEQ, \ ATTRIBUTES_SEQ, \
BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)) BOOST_PP_DEC(BOOST_PP_SEQ_SIZE((0)ATTRIBUTES_SEQ)))
#define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL( \ #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) \ NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE) \
\ \
NAME() \ template <typename boost_fusion_detail_Seq, int N> \
BOOST_PP_IF( \ struct BOOST_FUSION_ITERATOR_NAME(NAME) \
BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ), \
BOOST_FUSION_MAKE_DEFAULT_INIT_LIST, \
BOOST_FUSION_IGNORE_1) \
(ATTRIBUTES_SEQ) \
{ \
} \
\
BOOST_PP_IF( \
BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ), \
BOOST_FUSION_MAKE_COPY_CONSTRUCTOR, \
BOOST_FUSION_IGNORE_2) \
(NAME, ATTRIBUTES_SEQ) \
\
template <typename boost_fusion_uglified_Seq> \
NAME(const boost_fusion_uglified_Seq& rhs) \
{ \
boost::fusion::copy(rhs, *this); \
} \
\
template <typename boost_fusion_uglified_Seq> \
NAME& operator=(const boost_fusion_uglified_Seq& rhs) \
{ \
boost::fusion::copy(rhs, *this); \
return *this; \
} \
\
template <typename boost_fusion_uglified_Seq, int N> \
struct NAME##_iterator \
: boost::fusion::iterator_facade< \ : boost::fusion::iterator_facade< \
NAME##_iterator<boost_fusion_uglified_Seq, N>, \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Seq, N>, \
boost::fusion::random_access_traversal_tag \ boost::fusion::random_access_traversal_tag \
> \ > \
{ \ { \
typedef boost::mpl::int_<N> index; \ typedef boost::mpl::int_<N> index; \
typedef boost_fusion_uglified_Seq sequence_type; \ typedef boost_fusion_detail_Seq sequence_type; \
\ \
NAME##_iterator(boost_fusion_uglified_Seq& seq) : seq_(seq) {} \ BOOST_FUSION_ITERATOR_NAME(NAME)(boost_fusion_detail_Seq& seq) \
: seq_(seq) {} \
\ \
boost_fusion_uglified_Seq& seq_; \ boost_fusion_detail_Seq& seq_; \
\ \
template <typename boost_fusion_uglified_T> struct value_of; \ template <typename boost_fusion_detail_T> struct value_of; \
BOOST_PP_REPEAT( \ BOOST_PP_REPEAT( \
ATTRIBUTES_SEQ_SIZE, \ ATTRIBUTES_SEQ_SIZE, \
BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS, \ BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS, \
NAME) \ NAME) \
\ \
template <typename boost_fusion_uglified_T> struct deref; \ template <typename boost_fusion_detail_T> struct deref; \
BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_PP_SEQ_FOR_EACH_I( \
BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS, \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS, \
NAME, \ NAME, \
ATTRIBUTES_SEQ) \ ATTRIBUTES_SEQ) \
\ \
template <typename boost_fusion_uglified_It> \ template <typename boost_fusion_detail_It> \
struct next \ struct next \
{ \ { \
typedef NAME##_iterator< \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \
typename boost_fusion_uglified_It::sequence_type, \ typename boost_fusion_detail_It::sequence_type, \
boost_fusion_uglified_It::index::value + 1 \ boost_fusion_detail_It::index::value + 1 \
> type; \ > type; \
\ \
static type call(boost_fusion_uglified_It const& it) \ static type call(boost_fusion_detail_It const& it) \
{ \ { \
return type(it.seq_); \ return type(it.seq_); \
} \ } \
}; \ }; \
\ \
template <typename boost_fusion_uglified_It> \ template <typename boost_fusion_detail_It> \
struct prior \ struct prior \
{ \ { \
typedef NAME##_iterator< \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \
typename boost_fusion_uglified_It::sequence_type, \ typename boost_fusion_detail_It::sequence_type, \
boost_fusion_uglified_It::index::value - 1 \ boost_fusion_detail_It::index::value - 1 \
> type; \ > type; \
\ \
static type call(boost_fusion_uglified_It const& it) \ static type call(boost_fusion_detail_It const& it) \
{ \ { \
return type(it.seq_); \ return type(it.seq_); \
} \ } \
}; \ }; \
\ \
template < \ template < \
typename boost_fusion_uglified_It1, \ typename boost_fusion_detail_It1, \
typename boost_fusion_uglified_It2 \ typename boost_fusion_detail_It2 \
> \ > \
struct distance \ struct distance \
{ \ { \
typedef typename boost::mpl::minus< \ typedef typename boost::mpl::minus< \
typename boost_fusion_uglified_It2::index, \ typename boost_fusion_detail_It2::index, \
typename boost_fusion_uglified_It1::index \ typename boost_fusion_detail_It1::index \
>::type type; \ >::type type; \
\ \
static type call(boost_fusion_uglified_It1 const& it1, \ static type call(boost_fusion_detail_It1 const& it1, \
boost_fusion_uglified_It2 const& it2) \ boost_fusion_detail_It2 const& it2) \
{ \ { \
return type(); \ return type(); \
} \ } \
}; \ }; \
\ \
template < \ template < \
typename boost_fusion_uglified_It, \ typename boost_fusion_detail_It, \
typename boost_fusion_uglified_M \ typename boost_fusion_detail_M \
> \ > \
struct advance \ struct advance \
{ \ { \
typedef NAME##_iterator< \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \
typename boost_fusion_uglified_It::sequence_type, \ typename boost_fusion_detail_It::sequence_type, \
boost_fusion_uglified_It::index::value \ boost_fusion_detail_It::index::value \
+ boost_fusion_uglified_M::value \ + boost_fusion_detail_M::value \
> type; \ > type; \
\ \
static type call(boost_fusion_uglified_It const& it) \ static type call(boost_fusion_detail_It const& it) \
{ \ { \
return type(it.seq_); \ return type(it.seq_); \
} \ } \
}; \ }; \
}; \ };
#define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL( \
NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE) \
\ \
template <typename boost_fusion_uglified_Sq> \ /* 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 \ struct begin \
{ \ { \
typedef NAME##_iterator<boost_fusion_uglified_Sq, 0> type; \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, 0> \
type; \
\ \
static type call(boost_fusion_uglified_Sq& sq) \ static type call(boost_fusion_detail_Sq& sq) \
{ \ { \
return type(sq); \ return type(sq); \
} \ } \
}; \ }; \
\ \
template <typename boost_fusion_uglified_Sq> \ template <typename boost_fusion_detail_Sq> \
struct end \ struct end \
{ \ { \
typedef NAME##_iterator< \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \
boost_fusion_uglified_Sq, \ boost_fusion_detail_Sq, \
ATTRIBUTES_SEQ_SIZE \ ATTRIBUTES_SEQ_SIZE \
> type; \ > type; \
\ \
static type call(boost_fusion_uglified_Sq& sq) \ static type call(boost_fusion_detail_Sq& sq) \
{ \ { \
return type(sq); \ return type(sq); \
} \ } \
}; \ }; \
\ \
template <typename boost_fusion_uglified_Sq> \ template <typename boost_fusion_detail_Sq> \
struct size : boost::mpl::int_<ATTRIBUTES_SEQ_SIZE> \ struct size : boost::mpl::int_<ATTRIBUTES_SEQ_SIZE> \
{ \ { \
}; \ }; \
\ \
template <typename boost_fusion_uglified_Sq> \ template <typename boost_fusion_detail_Sq> \
struct empty : boost::mpl::bool_<ATTRIBUTES_SEQ_SIZE == 0> \ struct empty : boost::mpl::bool_<ATTRIBUTES_SEQ_SIZE == 0> \
{ \ { \
}; \ }; \
\ \
template < \ template < \
typename boost_fusion_uglified_Sq, \ typename boost_fusion_detail_Sq, \
typename boost_fusion_uglified_N \ typename boost_fusion_detail_N \
> \ > \
struct value_at : value_at< \ struct value_at : value_at< \
boost_fusion_uglified_Sq, \ boost_fusion_detail_Sq, \
boost::mpl::int_<boost_fusion_uglified_N::value> \ boost::mpl::int_<boost_fusion_detail_N::value> \
> \ > \
{ \ { \
}; \ }; \
@ -353,12 +390,12 @@
~) \ ~) \
\ \
template < \ template < \
typename boost_fusion_uglified_Sq, \ typename boost_fusion_detail_Sq, \
typename boost_fusion_uglified_N \ typename boost_fusion_detail_N \
> \ > \
struct at : at< \ struct at : at< \
boost_fusion_uglified_Sq, \ boost_fusion_detail_Sq, \
boost::mpl::int_<boost_fusion_uglified_N::value> \ boost::mpl::int_<boost_fusion_detail_N::value> \
> \ > \
{ \ { \
}; \ }; \

2
include/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp
View File

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

2
include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp
View File

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

2
include/boost/fusion/algorithm/query/detail/any.hpp
View File

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

87
include/boost/fusion/container/deque/deque.hpp
View File

@ -11,24 +11,23 @@
#include <boost/config.hpp> #include <boost/config.hpp>
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// With no decltype and variadics, we will use the C++03 version // With variadics, we will use the PP version version
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#if (defined(BOOST_NO_DECLTYPE) \ #if defined(BOOST_NO_VARIADIC_TEMPLATES)
|| defined(BOOST_NO_VARIADIC_TEMPLATES) \ # include <boost/fusion/container/deque/detail/pp_deque.hpp>
|| defined(BOOST_NO_RVALUE_REFERENCES))
# include <boost/fusion/container/deque/detail/cpp03_deque.hpp>
#else #else
# if !defined(BOOST_FUSION_HAS_CPP11_DEQUE) # if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
# define BOOST_FUSION_HAS_CPP11_DEQUE # define BOOST_FUSION_HAS_VARIADIC_DEQUE
# endif # endif
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// C++11 interface // C++11 variadic interface
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#include <boost/fusion/support/sequence_base.hpp> #include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/detail/access.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/keyed_element.hpp>
#include <boost/fusion/container/deque/detail/cpp11_deque_keyed_values.hpp> #include <boost/fusion/container/deque/detail/variadic_deque_keyed_values.hpp>
#include <boost/fusion/container/deque/deque_fwd.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/value_at_impl.hpp>
#include <boost/fusion/container/deque/detail/at_impl.hpp> #include <boost/fusion/container/deque/detail/at_impl.hpp>
@ -36,8 +35,10 @@
#include <boost/fusion/container/deque/detail/end_impl.hpp> #include <boost/fusion/container/deque/detail/end_impl.hpp>
#include <boost/fusion/container/deque/detail/is_sequence_impl.hpp> #include <boost/fusion/container/deque/detail/is_sequence_impl.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp> #include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/empty.hpp>
#include <boost/mpl/int.hpp> #include <boost/mpl/int.hpp>
#include <boost/mpl/and.hpp>
#include <boost/utility/enable_if.hpp> #include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_convertible.hpp> #include <boost/type_traits/is_convertible.hpp>
@ -48,6 +49,22 @@ namespace boost { namespace fusion
template <typename ...Elements> template <typename ...Elements>
struct deque : detail::nil_keyed_element 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> template <typename Head, typename ...Tail>
@ -60,7 +77,7 @@ namespace boost { namespace fusion
typedef typename detail::deque_keyed_values<Head, Tail...>::type base; typedef typename detail::deque_keyed_values<Head, Tail...>::type base;
typedef mpl::int_<(sizeof ...(Tail) + 1)> size; typedef mpl::int_<(sizeof ...(Tail) + 1)> size;
typedef mpl::int_<size::value> next_up; typedef mpl::int_<size::value> next_up;
typedef mpl::int_<mpl::int_<((size::value == 0) ? 0 : -1)>::type::value> next_down; typedef mpl::int_<((size::value == 0) ? 0 : -1)> next_down;
typedef mpl::false_ is_view; typedef mpl::false_ is_view;
deque() deque()
@ -71,11 +88,45 @@ namespace boost { namespace fusion
: base(seq) : base(seq)
{} {}
explicit deque(typename detail::call_param<Head>::type head template <typename ...Elements>
, typename detail::call_param<Tail>::type... tail) deque(deque<Elements...>& seq)
: base(detail::deque_keyed_values<Head, Tail...>::call(head, tail...)) : base(seq)
{} {}
#if !defined(BOOST_NO_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_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_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> template <typename Sequence>
explicit deque(Sequence const& seq explicit deque(Sequence const& seq
, typename disable_if<is_convertible<Sequence, Head> >::type* /*dummy*/ = 0) , typename disable_if<is_convertible<Sequence, Head> >::type* /*dummy*/ = 0)
@ -95,6 +146,16 @@ namespace boost { namespace fusion
base::operator=(rhs); base::operator=(rhs);
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES)
template <typename T>
deque& operator=(T&& rhs)
{
base::operator=(std::forward<T>(rhs));
return *this;
}
#endif
}; };
}} }}

6
include/boost/fusion/container/deque/deque_fwd.hpp
View File

@ -16,10 +16,10 @@
#if (defined(BOOST_NO_DECLTYPE) \ #if (defined(BOOST_NO_DECLTYPE) \
|| defined(BOOST_NO_VARIADIC_TEMPLATES) \ || defined(BOOST_NO_VARIADIC_TEMPLATES) \
|| defined(BOOST_NO_RVALUE_REFERENCES)) || defined(BOOST_NO_RVALUE_REFERENCES))
# include <boost/fusion/container/deque/detail/cpp03_deque_fwd.hpp> # include <boost/fusion/container/deque/detail/pp_deque_fwd.hpp>
#else #else
# if !defined(BOOST_FUSION_HAS_CPP11_DEQUE) # if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
# define BOOST_FUSION_HAS_CPP11_DEQUE # define BOOST_FUSION_HAS_VARIADIC_DEQUE
# endif # endif
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

14
include/boost/fusion/container/deque/detail/deque_forward_ctor.hpp
View File

@ -9,10 +9,12 @@
#if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_FORWARD_CTOR_04122006_2212) #if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_FORWARD_CTOR_04122006_2212)
#define 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_CPP11_DEQUE) #if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included" #error "C++03 only! This file should not have been included"
#endif #endif
#define FUSION_DEQUE_FORWARD_CTOR_FORWARD(z, n, _) std::forward<T##n>(t##n)
#include <boost/preprocessor/iterate.hpp> #include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp> #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp>
@ -22,14 +24,22 @@
#define BOOST_PP_ITERATION_LIMITS (2, FUSION_MAX_DEQUE_SIZE) #define BOOST_PP_ITERATION_LIMITS (2, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE() #include BOOST_PP_ITERATE()
#undef FUSION_DEQUE_FORWARD_CTOR_FORWARD
#endif #endif
#else #else
#define N BOOST_PP_ITERATION() #define N BOOST_PP_ITERATION()
deque(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t)) 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)>::call(BOOST_PP_ENUM_PARAMS(N, t))) : base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::construct(BOOST_PP_ENUM_PARAMS(N, t)))
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
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 #undef N
#endif #endif

2
include/boost/fusion/container/deque/detail/deque_initial_size.hpp
View File

@ -8,7 +8,7 @@
#if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139) #if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139)
#define BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139 #define BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE) #if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included" #error "C++03 only! This file should not have been included"
#endif #endif

20
include/boost/fusion/container/deque/detail/deque_keyed_values_call.hpp
View File

@ -9,25 +9,30 @@
#if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211) #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 #define BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE) #if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included" #error "C++03 only! This file should not have been included"
#endif #endif
#include <boost/preprocessor/iterate.hpp> #include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp> #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum_shifted.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.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 \ #define BOOST_PP_FILENAME_1 \
<boost/fusion/container/deque/detail/deque_keyed_values_call.hpp> <boost/fusion/container/deque/detail/deque_keyed_values_call.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE) #define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE() #include BOOST_PP_ITERATE()
#undef FUSION_DEQUE_KEYED_VALUES_FORWARD
#endif #endif
#else #else
#define N BOOST_PP_ITERATION() #define N BOOST_PP_ITERATION()
static type call(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t)) static type construct(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t))
{ {
return type(t0, return type(t0,
deque_keyed_values_impl< deque_keyed_values_impl<
@ -38,5 +43,16 @@
>::call(BOOST_PP_ENUM_SHIFTED_PARAMS(N, t))); >::call(BOOST_PP_ENUM_SHIFTED_PARAMS(N, t)));
} }
static type forward_(BOOST_PP_ENUM_BINARY_PARAMS(N, T, && t))
{
return type(std::forward<T0>(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, _)));
}
#undef N #undef N
#endif #endif

48
include/boost/fusion/container/deque/detail/keyed_element.hpp
View File

@ -47,16 +47,42 @@ namespace boost { namespace fusion { namespace detail
*it, base::from_iterator(fusion::next(it))); *it, base::from_iterator(fusion::next(it)));
} }
keyed_element(keyed_element const& rhs)
: Rest(rhs.get_base()), value_(rhs.value_)
{}
#if !defined(BOOST_NO_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) keyed_element(keyed_element<Key, U, Rst> const& rhs)
: Rest(rhs.get_base()), value_(rhs.value_) : Rest(rhs.get_base()), value_(rhs.value_)
{} {}
Rest const get_base() const #if !defined(BOOST_NO_RVALUE_REFERENCES)
#endif
Rest& get_base()
{ {
return *this; return *this;
} }
Rest const& get_base() const
{
return *this;
}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
Rest&& forward_base()
{
return std::forward<Rest>(*static_cast<Rest*>(this));
}
#endif
typename cref_result<Value>::type get(Key) const typename cref_result<Value>::type get(Key) const
{ {
return value_; return value_;
@ -67,10 +93,19 @@ namespace boost { namespace fusion { namespace detail
return value_; return value_;
} }
keyed_element(typename call_param<Value>::type value, Rest const& rest) keyed_element(
typename detail::call_param<Value>::type value
, Rest const& rest)
: Rest(rest), value_(value) : Rest(rest), value_(value)
{} {}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
keyed_element(Value&& value, Rest&& rest)
: Rest(std::forward<Rest>(rest))
, value_(std::forward<Value>(value))
{}
#endif
keyed_element() keyed_element()
: Rest(), value_() : Rest(), value_()
{} {}
@ -90,6 +125,15 @@ namespace boost { namespace fusion { namespace detail
return *this; return *this;
} }
#if !defined(BOOST_NO_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_; Value value_;
}; };

43
include/boost/fusion/container/deque/detail/cpp03_deque.hpp → include/boost/fusion/container/deque/detail/pp_deque.hpp
View File

@ -5,17 +5,17 @@
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) file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/ ==============================================================================*/
#if !defined(BOOST_CPP03_FUSION_DEQUE_26112006_1649) #if !defined(BOOST_PP_FUSION_DEQUE_26112006_1649)
#define BOOST_CPP03_FUSION_DEQUE_26112006_1649 #define BOOST_PP_FUSION_DEQUE_26112006_1649
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE) #if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included" #error "C++03 only! This file should not have been included"
#endif #endif
#include <boost/fusion/container/deque/limits.hpp> #include <boost/fusion/container/deque/limits.hpp>
#include <boost/fusion/container/deque/front_extended_deque.hpp> #include <boost/fusion/container/deque/front_extended_deque.hpp>
#include <boost/fusion/container/deque/back_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/pp_deque_keyed_values.hpp>
#include <boost/fusion/container/deque/detail/deque_initial_size.hpp> #include <boost/fusion/container/deque/detail/deque_initial_size.hpp>
#include <boost/fusion/support/sequence_base.hpp> #include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/container/deque/detail/keyed_element.hpp> #include <boost/fusion/container/deque/detail/keyed_element.hpp>
@ -87,13 +87,34 @@ namespace boost { namespace fusion {
: base(t0, detail::nil_keyed_element()) : base(t0, detail::nil_keyed_element())
{} {}
explicit deque(deque const& rhs)
: base(rhs)
{}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
explicit deque(T0&& t0)
: 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)> 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) : base(seq)
{} {}
#if !defined(BOOST_NO_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> 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))) : base(base::from_iterator(fusion::begin(seq)))
{} {}
@ -113,6 +134,16 @@ namespace boost { namespace fusion {
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES)
template <typename T>
deque&
operator=(T&& rhs)
{
base::operator=(std::forward<T>(rhs));
return *this;
}
#endif
}; };
}} }}

6
include/boost/fusion/container/deque/detail/cpp03_deque_fwd.hpp → include/boost/fusion/container/deque/detail/pp_deque_fwd.hpp
View File

@ -5,10 +5,10 @@
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) file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/ ==============================================================================*/
#if !defined(FUSION_CPP03_DEQUE_FORWARD_02092007_0749) #if !defined(FUSION_PP_DEQUE_FORWARD_02092007_0749)
#define FUSION_CPP03_DEQUE_FORWARD_02092007_0749 #define FUSION_PP_DEQUE_FORWARD_02092007_0749
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE) #if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included" #error "C++03 only! This file should not have been included"
#endif #endif

7
include/boost/fusion/container/deque/detail/cpp03_deque_keyed_values.hpp → include/boost/fusion/container/deque/detail/pp_deque_keyed_values.hpp
View File

@ -8,7 +8,7 @@
#if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330) #if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330)
#define BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330 #define BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE) #if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included" #error "C++03 only! This file should not have been included"
#endif #endif
@ -72,6 +72,11 @@ namespace boost { namespace fusion { namespace detail
{ {
return type(); return type();
} }
static type forward_()
{
return type();
}
}; };
template<typename N, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)> template<typename N, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>

17
include/boost/fusion/container/deque/detail/cpp11_deque_keyed_values.hpp → include/boost/fusion/container/deque/detail/variadic_deque_keyed_values.hpp
View File

@ -28,13 +28,23 @@ namespace boost { namespace fusion { namespace detail
typedef typename deque_keyed_values_impl<next_index, Tail...>::type tail; typedef typename deque_keyed_values_impl<next_index, Tail...>::type tail;
typedef keyed_element<N, Head, tail> type; typedef keyed_element<N, Head, tail> type;
static type call( static type construct(
typename detail::call_param<Head>::type head typename detail::call_param<Head>::type head
, typename detail::call_param<Tail>::type... tail) , typename detail::call_param<Tail>::type... tail)
{ {
return type( return type(
head head
, deque_keyed_values_impl<next_index, Tail...>::call(tail...) , 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)...)
); );
} }
}; };
@ -45,7 +55,8 @@ namespace boost { namespace fusion { namespace detail
struct deque_keyed_values_impl<N> struct deque_keyed_values_impl<N>
{ {
typedef nil_keyed_element type; typedef nil_keyed_element type;
static type call() { return type(); } static type construct() { return type(); }
static type forward_() { return type(); }
}; };
template <typename ...Elements> template <typename ...Elements>

2
include/boost/fusion/container/deque/limits.hpp
View File

@ -8,7 +8,7 @@
#if !defined(BOOST_FUSION_DEQUE_LIMITS_26112006_1737) #if !defined(BOOST_FUSION_DEQUE_LIMITS_26112006_1737)
#define BOOST_FUSION_DEQUE_LIMITS_26112006_1737 #define BOOST_FUSION_DEQUE_LIMITS_26112006_1737
#if defined(BOOST_FUSION_HAS_CPP11_DEQUE) #if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
#error "C++03 only! This file should not have been included" #error "C++03 only! This file should not have been included"
#endif #endif

11
include/boost/fusion/container/vector/detail/vector_forward_ctor.hpp
View File

@ -12,11 +12,14 @@
#include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp>
#define FUSION_FORWARD_CTOR_MOVE(z, n, _) std::move(_##n)
#define BOOST_PP_FILENAME_1 \ #define BOOST_PP_FILENAME_1 \
<boost/fusion/container/vector/detail/vector_forward_ctor.hpp> <boost/fusion/container/vector/detail/vector_forward_ctor.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE) #define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE() #include BOOST_PP_ITERATE()
#undef FUSION_FORWARD_CTOR_MOVE
#endif #endif
#else // defined(BOOST_PP_IS_ITERATING) #else // defined(BOOST_PP_IS_ITERATING)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -34,6 +37,14 @@
N, typename detail::call_param<T, >::type _)) N, typename detail::call_param<T, >::type _))
: vec(BOOST_PP_ENUM_PARAMS(N, _)) {} : vec(BOOST_PP_ENUM_PARAMS(N, _)) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
#if N == 1
explicit
#endif
vector(BOOST_PP_ENUM_BINARY_PARAMS(N, T, && _))
: vec(BOOST_PP_ENUM(N, FUSION_FORWARD_CTOR_MOVE, _)) {}
#endif
#undef N #undef N
#endif // defined(BOOST_PP_IS_ITERATING) #endif // defined(BOOST_PP_IS_ITERATING)

79
include/boost/fusion/container/vector/detail/vector_n.hpp
View File

@ -9,24 +9,31 @@
#if !defined(FUSION_MACRO_05042005) #if !defined(FUSION_MACRO_05042005)
#define FUSION_MACRO_05042005 #define FUSION_MACRO_05042005
#define FUSION_MEMBER_DEFAULT_INIT(z, n, _) m##n() #define FUSION_VECTOR_MEMBER_MEMBER_DEFAULT_INIT(z, n, _) m##n()
#define FUSION_MEMBER_INIT(z, n, _) m##n(_##n) #define FUSION_VECTOR_MEMBER_MEMBER_INIT(z, n, _) m##n(_##n)
#define FUSION_COPY_INIT(z, n, _) m##n(other.m##n) #define FUSION_VECTOR_MEMBER_COPY_INIT(z, n, _) m##n(other.m##n)
#define FUSION_MEMBER_DECL(z, n, _) T##n m##n; #define FUSION_VECTOR_MEMBER_FWD(z, n, _) m##n(std::forward<T##n>(other.m##n))
#define FUSION_VECTOR_ARG_FWD(z, n, _) m##n(std::forward<T##n>(_##n))
#define FUSION_VECTOR_MEMBER_MEMBER_DECL(z, n, _) T##n m##n;
#define FUSION_VECTOR_MEMBER_FORWARD(z, n, _) std::forward<T##n>(_##n)
#define FUSION_MEMBER_ASSIGN(z, n, _) \ #define FUSION_VECTOR_MEMBER_MEMBER_ASSIGN(z, n, _) \
this->BOOST_PP_CAT(m, n) = vec.BOOST_PP_CAT(m, n); this->BOOST_PP_CAT(m, n) = vec.BOOST_PP_CAT(m, n);
#define FUSION_DEREF_MEMBER_ASSIGN(z, n, _) \ #define FUSION_VECTOR_MEMBER_DEREF_MEMBER_ASSIGN(z, n, _) \
this->BOOST_PP_CAT(m, n) = *BOOST_PP_CAT(i, n); this->BOOST_PP_CAT(m, n) = *BOOST_PP_CAT(i, n);
#define FUSION_AT_IMPL(z, n, _) \ #define FUSION_VECTOR_MEMBER_MEMBER_FORWARD(z, n, _) \
this->BOOST_PP_CAT(m, n) = std::forward< \
BOOST_PP_CAT(T, n)>(vec.BOOST_PP_CAT(m, n));
#define FUSION_VECTOR_MEMBER_AT_IMPL(z, n, _) \
typename add_reference<T##n>::type \ typename add_reference<T##n>::type \
at_impl(mpl::int_<n>) { return this->m##n; } \ at_impl(mpl::int_<n>) { return this->m##n; } \
typename add_reference<typename add_const<T##n>::type>::type \ typename add_reference<typename add_const<T##n>::type>::type \
at_impl(mpl::int_<n>) const { return this->m##n; } at_impl(mpl::int_<n>) const { return this->m##n; }
#define FUSION_ITER_DECL_VAR(z, n, _) \ #define FUSION_VECTOR_MEMBER_ITER_DECL_VAR(z, n, _) \
typedef typename result_of::next< \ typedef typename result_of::next< \
BOOST_PP_CAT(I, BOOST_PP_DEC(n))>::type BOOST_PP_CAT(I, n); \ BOOST_PP_CAT(I, BOOST_PP_DEC(n))>::type BOOST_PP_CAT(I, n); \
BOOST_PP_CAT(I, n) BOOST_PP_CAT(i, n) \ BOOST_PP_CAT(I, n) BOOST_PP_CAT(i, n) \
@ -40,21 +47,32 @@
struct BOOST_PP_CAT(vector_data, N) struct BOOST_PP_CAT(vector_data, N)
{ {
BOOST_PP_CAT(vector_data, N)() BOOST_PP_CAT(vector_data, N)()
: BOOST_PP_ENUM(N, FUSION_MEMBER_DEFAULT_INIT, _) {} : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_MEMBER_DEFAULT_INIT, _) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, T, && _))
: BOOST_PP_ENUM(N, FUSION_VECTOR_ARG_FWD, _) {}
#endif
BOOST_PP_CAT(vector_data, N)( BOOST_PP_CAT(vector_data, N)(
BOOST_PP_ENUM_BINARY_PARAMS( BOOST_PP_ENUM_BINARY_PARAMS(
N, typename detail::call_param<T, >::type _)) N, typename detail::call_param<T, >::type _))
: BOOST_PP_ENUM(N, FUSION_MEMBER_INIT, _) {} : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_MEMBER_INIT, _) {}
BOOST_PP_CAT(vector_data, N)( BOOST_PP_CAT(vector_data, N)(
BOOST_PP_CAT(vector_data, N) const& other) BOOST_PP_CAT(vector_data, N) const& other)
: BOOST_PP_ENUM(N, FUSION_COPY_INIT, _) {} : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_COPY_INIT, _) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
BOOST_PP_CAT(vector_data, N)(
BOOST_PP_CAT(vector_data, N)&& other)
: BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FWD, _) {}
#endif
BOOST_PP_CAT(vector_data, N)& BOOST_PP_CAT(vector_data, N)&
operator=(BOOST_PP_CAT(vector_data, N) const& vec) operator=(BOOST_PP_CAT(vector_data, N) const& vec)
{ {
BOOST_PP_REPEAT(N, FUSION_MEMBER_ASSIGN, _) BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_MEMBER_ASSIGN, _)
return *this; return *this;
} }
@ -64,7 +82,7 @@
{ {
typedef typename result_of::begin<Sequence const>::type I0; typedef typename result_of::begin<Sequence const>::type I0;
I0 i0 = fusion::begin(seq); I0 i0 = fusion::begin(seq);
BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_ITER_DECL_VAR, _) BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i)); return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
} }
@ -74,11 +92,11 @@
{ {
typedef typename result_of::begin<Sequence>::type I0; typedef typename result_of::begin<Sequence>::type I0;
I0 i0 = fusion::begin(seq); I0 i0 = fusion::begin(seq);
BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_ITER_DECL_VAR, _) BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i)); return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
} }
BOOST_PP_REPEAT(N, FUSION_MEMBER_DECL, _) BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_MEMBER_DECL, _)
}; };
template <BOOST_PP_ENUM_PARAMS(N, typename T)> template <BOOST_PP_ENUM_PARAMS(N, typename T)>
@ -105,6 +123,19 @@
N, typename detail::call_param<T, >::type _)) N, typename detail::call_param<T, >::type _))
: base_type(BOOST_PP_ENUM_PARAMS(N, _)) {} : base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
#if (N == 1)
explicit
#endif
BOOST_PP_CAT(vector, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, T, && _))
: base_type(BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FORWARD, _)) {}
#endif
#if !defined(BOOST_NO_RVALUE_REFERENCES)
BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N)&& rhs)
: base_type(std::forward<base_type>(rhs)) {}
#endif
template <BOOST_PP_ENUM_PARAMS(N, typename U)> template <BOOST_PP_ENUM_PARAMS(N, typename U)>
BOOST_PP_CAT(vector, N)( BOOST_PP_CAT(vector, N)(
BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec) BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
@ -132,7 +163,7 @@
BOOST_PP_CAT(vector, N)& BOOST_PP_CAT(vector, N)&
operator=(BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec) operator=(BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
{ {
BOOST_PP_REPEAT(N, FUSION_MEMBER_ASSIGN, _) BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_MEMBER_ASSIGN, _)
return *this; return *this;
} }
@ -142,12 +173,21 @@
{ {
typedef typename result_of::begin<Sequence const>::type I0; typedef typename result_of::begin<Sequence const>::type I0;
I0 i0 = fusion::begin(seq); I0 i0 = fusion::begin(seq);
BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_ITER_DECL_VAR, _) BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
BOOST_PP_REPEAT(N, FUSION_DEREF_MEMBER_ASSIGN, _) BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_DEREF_MEMBER_ASSIGN, _)
return *this; return *this;
} }
BOOST_PP_REPEAT(N, FUSION_AT_IMPL, _) #if !defined(BOOST_NO_RVALUE_REFERENCES)
BOOST_PP_CAT(vector, N)&
operator=(BOOST_PP_CAT(vector, N)&& vec)
{
BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_MEMBER_FORWARD, _)
return *this;
}
#endif
BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_AT_IMPL, _)
template<typename I> template<typename I>
typename add_reference<typename mpl::at<types, I>::type>::type typename add_reference<typename mpl::at<types, I>::type>::type
@ -166,3 +206,4 @@
#undef N #undef N

22
include/boost/fusion/container/vector/vector.hpp
View File

@ -106,6 +106,11 @@ namespace boost { namespace fusion
vector(vector const& rhs) vector(vector const& rhs)
: vec(rhs.vec) {} : vec(rhs.vec) {}
#if !defined(BOOST_NO_RVALUE_REFERENCES)
vector(vector&& rhs)
: vec(std::forward<vector_n>(rhs.vec)) {}
#endif
template <typename Sequence> template <typename Sequence>
vector(Sequence const& rhs) vector(Sequence const& rhs)
: vec(BOOST_FUSION_VECTOR_COPY_INIT()) {} : vec(BOOST_FUSION_VECTOR_COPY_INIT()) {}
@ -135,6 +140,23 @@ namespace boost { namespace fusion
return *this; return *this;
} }
#if !defined(BOOST_NO_RVALUE_REFERENCES)
vector&
operator=(vector&& rhs)
{
vec = std::forward<vector_n>(rhs.vec);
return *this;
}
template <typename T>
vector&
operator=(T&& rhs)
{
vec = std::forward<T>(rhs);
return *this;
}
#endif
template <int N> template <int N>
typename add_reference< typename add_reference<
typename mpl::at_c<types, N>::type typename mpl::at_c<types, N>::type

81
include/boost/fusion/functional/invocation/invoke.hpp
View File

@ -57,13 +57,13 @@ namespace boost { namespace fusion
template <typename Function, class Sequence> struct invoke; template <typename Function, class Sequence> struct invoke;
} }
template <typename Function, class Sequence> //~ template <typename Function, class Sequence>
inline typename result_of::invoke<Function, Sequence>::type //~ inline typename result_of::invoke<Function, Sequence>::type
invoke(Function, Sequence &); //~ invoke(Function, Sequence &);
template <typename Function, class Sequence> //~ template <typename Function, class Sequence>
inline typename result_of::invoke<Function, Sequence const>::type //~ inline typename result_of::invoke<Function, Sequence const>::type
invoke(Function, Sequence const &); //~ invoke(Function, Sequence const &);
//----- ---- --- -- - - - - //----- ---- --- -- - - - -
@ -85,6 +85,9 @@ namespace boost { namespace fusion
template <typename T, class Sequence> template <typename T, class Sequence>
struct invoke_data_member; struct invoke_data_member;
template <typename Function, class Sequence, int N, bool RandomAccess>
struct invoke_fn_ptr;
template <typename Function, class Sequence, int N, bool RandomAccess> template <typename Function, class Sequence, int N, bool RandomAccess>
struct invoke_mem_fn; struct invoke_mem_fn;
@ -95,10 +98,10 @@ namespace boost { namespace fusion
template <typename F, class Sequence, int N, bool RandomAccess> template <typename F, class Sequence, int N, bool RandomAccess>
struct invoke_nonmember_builtin struct invoke_nonmember_builtin
// use same implementation as for function objects but... // use same implementation as for function objects but...
: invoke_impl< // ...work around boost::result_of bugs : invoke_fn_ptr< // ...work around boost::result_of bugs
typename mpl::eval_if< ft::is_function<F>, typename mpl::eval_if< ft::is_function<F>,
boost::add_reference<F>, boost::remove_cv<F> >::type, boost::add_reference<F>, boost::remove_cv<F> >::type,
Sequence, N, false, RandomAccess > Sequence, N, RandomAccess >
{ }; { };
template <typename Function, class Sequence, int N, bool RandomAccess> template <typename Function, class Sequence, int N, bool RandomAccess>
@ -199,6 +202,35 @@ namespace boost { namespace fusion
Function(BOOST_PP_ENUM(N,M,~)) >::type result_type; Function(BOOST_PP_ENUM(N,M,~)) >::type result_type;
#undef M #undef M
#if N > 0
template <typename F>
static inline result_type
call(F & f, Sequence & s)
{
#define M(z,j,data) fusion::at_c<j>(s)
return f( BOOST_PP_ENUM(N,M,~) );
}
#else
template <typename F>
static inline result_type
call(F & f, Sequence & /*s*/)
{
return f();
}
#endif
};
template <typename Function, class Sequence>
struct invoke_fn_ptr<Function,Sequence,N,true>
{
public:
typedef typename ft::result_type<Function>::type result_type;
#if N > 0 #if N > 0
template <typename F> template <typename F>
@ -278,6 +310,39 @@ namespace boost { namespace fusion
return f(); return f();
} }
#endif
};
template <typename Function, class Sequence>
struct invoke_fn_ptr<Function,Sequence,N,false>
{
private:
typedef invoke_param_types<Sequence,N> seq;
public:
typedef typename ft::result_type<Function>::type result_type;
#if N > 0
template <typename F>
static inline result_type
call(F & f, Sequence & s)
{
typename seq::I0 i0 = fusion::begin(s);
BOOST_PP_REPEAT_FROM_TO(1,N,M,~)
return f( BOOST_PP_ENUM_PARAMS(N,*i) );
}
#else
template <typename F>
static inline result_type
call(F & f, Sequence & /*s*/)
{
return f();
}
#endif #endif
}; };

4
include/boost/fusion/iterator/iterator_adapter.hpp
View File

@ -23,8 +23,8 @@ namespace boost { namespace fusion
iterator_base_type; iterator_base_type;
iterator_base_type iterator_base; iterator_base_type iterator_base;
iterator_adapter(iterator_base_type const& iterator_base) iterator_adapter(iterator_base_type const& iterator_base_)
: iterator_base(iterator_base) {} : iterator_base(iterator_base_) {}
// default implementation // default implementation
template <typename I1, typename I2> template <typename I1, typename I2>

2
include/boost/fusion/sequence/intrinsic/has_key.hpp
View File

@ -68,7 +68,7 @@ namespace boost { namespace fusion
template <typename Key, typename Sequence> template <typename Key, typename Sequence>
inline typename result_of::has_key<Sequence, Key>::type inline typename result_of::has_key<Sequence, Key>::type
has_key(Sequence const& seq) has_key(Sequence const&)
{ {
typedef typename result_of::has_key<Sequence, Key>::type result; typedef typename result_of::has_key<Sequence, Key>::type result;
return result(); return result();