Swiftdiff options
| author | Kevin Smith <git@kismith.co.uk> | 2013-01-12 18:41:34 (GMT) |
|---|---|---|
| committer | Swift Review <review@swift.im> | 2013-01-13 10:36:26 (GMT) |
| commit | f3bc816af1b0d61452de973963e453bf3b3f95a2 (patch) | |
| tree | e895f8afa3580e6cff6f5ad2017d45bf147a17c2 /3rdParty/Boost/src/boost/fusion/algorithm | |
| parent | 188fc285c6555eadd3c9d50ab8a94adcade78d89 (diff) | |
| download | swift-f3bc816af1b0d61452de973963e453bf3b3f95a2.zip swift-f3bc816af1b0d61452de973963e453bf3b3f95a2.tar.bz2 | |
Adding in the spirit Boost stuff
Change-Id: I4f127ce61667243b64081b0aa309028d5077045f
Diffstat (limited to '3rdParty/Boost/src/boost/fusion/algorithm')
31 files changed, 3237 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/auxiliary/copy.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/auxiliary/copy.hpp new file mode 100644 index 0000000..fd86646 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/auxiliary/copy.hpp @@ -0,0 +1,84 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_COPY_02162011_2308) +#define FUSION_COPY_02162011_2308 + +#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_copy + { + 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 = *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 + copy(Seq1 const& src, Seq2& dest) + { + BOOST_STATIC_ASSERT( + result_of::size<Seq1>::value == result_of::size<Seq2>::value); + + detail::sequence_copy< + Seq1 const, Seq2>:: + call(fusion::begin(src), fusion::begin(dest)); + } +}} + +#if defined (BOOST_MSVC) +# pragma warning(pop) +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/fold.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/fold.hpp new file mode 100644 index 0000000..174c4b1 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/fold.hpp @@ -0,0 +1,462 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2006 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + 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) +==============================================================================*/ +#include <boost/preprocessor/cat.hpp> + +#ifdef BOOST_FUSION_REVERSE_FOLD +# ifdef BOOST_FUSION_ITER_FOLD +# define BOOST_FUSION_FOLD_NAME reverse_iter_fold +# else +# define BOOST_FUSION_FOLD_NAME reverse_fold +# endif + +# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION end +# define BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION prior +# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(IT) \ + typename fusion::result_of::prior<IT>::type +# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(IT) fusion::prior(IT) +#else +# ifdef BOOST_FUSION_ITER_FOLD +# define BOOST_FUSION_FOLD_NAME iter_fold +# else +# define BOOST_FUSION_FOLD_NAME fold +# endif + +# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION begin +# define BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION next +# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(IT) IT +# define BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(IT) IT +#endif +#ifdef BOOST_FUSION_ITER_FOLD +# define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(IT) IT& +# define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) IT +#else +# define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(IT) \ + typename fusion::result_of::deref<IT>::type +# define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) fusion::deref(IT) +#endif + +namespace boost { namespace fusion +{ + namespace detail + { + template<typename State, typename It, typename F> + struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state) + : boost::result_of< + F( + typename add_reference<typename add_const<State>::type>::type, + BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It)) + > + {}; + + template<typename Result,int N> + struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME) + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It0 const + >::type + It1; + It1 it1 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0); + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It1 + >::type + It2; + It2 it2 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1); + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It2 + >::type + It3; + It3 it3 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it2); + + typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1; + State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)); + + typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State1,It1,F>::type State2; + State2 const state2=f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)); + + typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State2,It2,F>::type State3; + State3 const state3=f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2)); + + return BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)< + Result + , N-4 + >::call( + f(state3,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it3)), + fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it3), + f); + } + }; + + template<typename Result> + struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,3> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It0 const + >::type + It1; + It1 it1 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0); + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It1 + >::type + It2; + It2 it2 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1); + + typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1; + State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)); + + typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State1,It1,F>::type State2; + State2 const state2=f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)); + + return f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2)); + } + }; + + template<typename Result> + struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,2> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1; + State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)); + + return f( + state1, + BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM( + fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0))); + } + }; + + template<typename Result> + struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,1> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + return f(state, + BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)); + } + }; + + template<typename Result> + struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,0> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0, F) + { + return static_cast<Result>(state); + } + }; + + template<typename StateRef, typename It0, typename F, int N> + struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME) + { + typedef typename + BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< + StateRef + , It0 const + , F + >::type + rest1; + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It0 const + >::type + it1; + typedef typename + BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< + rest1 + , it1 + , F + >::type + rest2; + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it1>::type + it2; + typedef typename + BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< + rest2 + , it2 + , F + >::type + rest3; + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it2>::type + it3; + + typedef typename + BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< + typename BOOST_PP_CAT( + BOOST_FUSION_FOLD_NAME, _lvalue_state)< + rest3 + , it3 + , F + >::type + , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + it3 + >::type + , F + , N-4 + >::type + type; + }; + + template<typename StateRef, typename It0, typename F> + struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< + StateRef + , It0 + , F + , 3 + > + { + typedef typename + BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< + StateRef + , It0 const + , F + >::type + rest1; + typedef typename + result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It0 const + >::type + it1; + + typedef typename + BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< + typename BOOST_PP_CAT( + BOOST_FUSION_FOLD_NAME, _lvalue_state)< + rest1 + , it1 + , F + >::type + , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + it1 const + >::type const + , F + >::type + type; + }; + + template<typename StateRef, typename It0, typename F> + struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< + StateRef + , It0 + , F + , 2 + > + : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< + typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< + StateRef + , It0 const + , F + >::type + , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It0 const + >::type const + , F + > + {}; + + template<typename StateRef, typename It0, typename F> + struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< + StateRef + , It0 + , F + , 1 + > + : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)< + StateRef + , It0 const + , F + > + {}; + + template<typename StateRef, typename It0, typename F> + struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< + StateRef + , It0 + , F + , 0 + > + { + typedef StateRef type; + }; + + template<typename StateRef, typename It0, typename F, int SeqSize> + struct BOOST_PP_CAT(result_of_first_unrolled,BOOST_FUSION_FOLD_NAME) + { + typedef typename + BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)< + typename boost::result_of< + F( + StateRef, + BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM( + It0 const) + ) + >::type + , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION< + It0 const + >::type + , F + , SeqSize-1 + >::type + type; + }; + + template<int SeqSize, typename StateRef, typename Seq, typename F> + struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl) + { + typedef typename + BOOST_PP_CAT( + result_of_first_unrolled,BOOST_FUSION_FOLD_NAME)< + StateRef + , BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM( + typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type + ) + , F + , SeqSize + >::type + type; + + static type + call(StateRef state, Seq& seq, F f) + { + typedef + BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)< + type + , SeqSize + > + unrolled_impl; + + return unrolled_impl::call( + state, + BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM( + fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq)), + f); + } + }; + + template<typename StateRef, typename Seq, typename F> + struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)<0,StateRef,Seq,F> + { + typedef StateRef type; + + static StateRef + call(StateRef state, Seq&, F) + { + return static_cast<StateRef>(state); + } + }; + + template<typename Seq, typename State, typename F, bool IsSegmented> + struct BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME) + : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)< + result_of::size<Seq>::value + , typename add_reference< + typename add_const<State>::type + >::type + , Seq + , F + > + {}; + } + + namespace result_of + { + template<typename Seq, typename State, typename F> + struct BOOST_FUSION_FOLD_NAME + : detail::BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME)< + Seq + , State + , F + , traits::is_segmented<Seq>::type::value + > + {}; + } + + template<typename Seq, typename State, typename F> + inline typename result_of::BOOST_FUSION_FOLD_NAME< + Seq + , State const + , F + >::type + BOOST_FUSION_FOLD_NAME(Seq& seq, State const& state, F f) + { + return result_of::BOOST_FUSION_FOLD_NAME<Seq,State const,F>::call( + state, + seq, + f); + } + + template<typename Seq, typename State, typename F> + inline typename result_of::BOOST_FUSION_FOLD_NAME< + Seq const + , State const + , F + >::type + BOOST_FUSION_FOLD_NAME(Seq const& seq, State const& state, F f) + { + return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State const,F>::call( + state, + seq, + f); + } + + template<typename Seq, typename State, typename F> + inline typename result_of::BOOST_FUSION_FOLD_NAME< + Seq + , State const + , F + >::type + BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F f) + { + return result_of::BOOST_FUSION_FOLD_NAME<Seq,State,F>::call( + state, + seq, + f); + } + + template<typename Seq, typename State, typename F> + inline typename result_of::BOOST_FUSION_FOLD_NAME< + Seq const + , State const + , F + >::type + BOOST_FUSION_FOLD_NAME(Seq const& seq, State& state, F f) + { + return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State,F>::call( + state, + seq, + f); + } +}} + +#undef BOOST_FUSION_FOLD_NAME +#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION +#undef BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION +#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM +#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM +#undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM +#undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/for_each.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/for_each.hpp new file mode 100644 index 0000000..66a1935 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/for_each.hpp @@ -0,0 +1,138 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_FOR_EACH_05052005_1028) +#define FUSION_FOR_EACH_05052005_1028 + +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/iterator/next.hpp> +#include <boost/fusion/iterator/deref.hpp> +#include <boost/fusion/iterator/distance.hpp> +#include <boost/fusion/support/category_of.hpp> +#include <boost/mpl/bool.hpp> + +namespace boost { namespace fusion { +namespace detail +{ + template <typename First, typename Last, typename F> + inline void + for_each_linear(First const&, Last const&, F const&, mpl::true_) + { + } + + template <typename First, typename Last, typename F> + inline void + for_each_linear(First const& first, Last const& last, F const& f, mpl::false_) + { + f(*first); + detail::for_each_linear(fusion::next(first), last, f, + result_of::equal_to<typename result_of::next<First>::type, Last>()); + } + + + template <typename Sequence, typename F, typename Tag> + inline void + for_each_dispatch(Sequence& seq, F const& f, Tag) + { + detail::for_each_linear( + fusion::begin(seq) + , fusion::end(seq) + , f + , result_of::equal_to< + typename result_of::begin<Sequence>::type + , typename result_of::end<Sequence>::type>()); + } + + template<int N> + struct for_each_unrolled + { + template<typename I0, typename F> + static void call(I0 const& i0, F const& f) + { + f(*i0); + typedef typename result_of::next<I0>::type I1; + I1 i1(fusion::next(i0)); + f(*i1); + typedef typename result_of::next<I1>::type I2; + I2 i2(fusion::next(i1)); + f(*i2); + typedef typename result_of::next<I2>::type I3; + I3 i3(fusion::next(i2)); + f(*i3); + for_each_unrolled<N-4>::call(fusion::next(i3), f); + } + }; + + template<> + struct for_each_unrolled<3> + { + template<typename I0, typename F> + static void call(I0 const& i0, F const& f) + { + f(*i0); + typedef typename result_of::next<I0>::type I1; + I1 i1(fusion::next(i0)); + f(*i1); + typedef typename result_of::next<I1>::type I2; + I2 i2(fusion::next(i1)); + f(*i2); + } + }; + + template<> + struct for_each_unrolled<2> + { + template<typename I0, typename F> + static void call(I0 const& i0, F const& f) + { + f(*i0); + typedef typename result_of::next<I0>::type I1; + I1 i1(fusion::next(i0)); + f(*i1); + } + }; + + template<> + struct for_each_unrolled<1> + { + template<typename I0, typename F> + static void call(I0 const& i0, F const& f) + { + f(*i0); + } + }; + + template<> + struct for_each_unrolled<0> + { + template<typename It, typename F> + static void call(It const&, F const&) + { + } + }; + + template <typename Sequence, typename F> + inline void + for_each_dispatch(Sequence& seq, F const& f, random_access_traversal_tag) + { + typedef typename result_of::begin<Sequence>::type begin; + typedef typename result_of::end<Sequence>::type end; + for_each_unrolled<result_of::distance<begin, end>::type::value>::call(fusion::begin(seq), f); + } + + template <typename Sequence, typename F> + inline void + for_each(Sequence& seq, F const& f, mpl::false_) // unsegmented implementation + { + detail::for_each_dispatch(seq, f, typename traits::category_of<Sequence>::type()); + } +}}} + + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp new file mode 100644 index 0000000..c89a7dd --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp @@ -0,0 +1,381 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2007 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + 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! +==============================================================================*/ +namespace boost { namespace fusion +{ + namespace detail + { + template<typename State, typename It, typename F> + struct fold_lvalue_state + : boost::result_of< + F( + typename add_reference<typename add_const<State>::type>::type, + typename fusion::result_of::deref<It>::type) + > + {}; + template<typename Result,int N> + struct unrolled_fold + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename + result_of::next< + It0 const + >::type + It1; + It1 it1 = fusion::next(it0); + typedef typename + result_of::next< + It1 + >::type + It2; + It2 it2 = fusion::next(it1); + typedef typename + result_of::next< + It2 + >::type + It3; + It3 it3 = fusion::next(it2); + typedef typename fold_lvalue_state<State,It0,F>::type State1; + State1 const state1=f(state,fusion::deref(it0)); + typedef typename fold_lvalue_state<State1,It1,F>::type State2; + State2 const state2=f(state1,fusion::deref(it1)); + typedef typename fold_lvalue_state<State2,It2,F>::type State3; + State3 const state3=f(state2,fusion::deref(it2)); + return unrolled_fold< + Result + , N-4 + >::call( + f(state3,fusion::deref(it3)), + fusion::next(it3), + f); + } + }; + template<typename Result> + struct unrolled_fold<Result,3> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename + result_of::next< + It0 const + >::type + It1; + It1 it1 = fusion::next(it0); + typedef typename + result_of::next< + It1 + >::type + It2; + It2 it2 = fusion::next(it1); + typedef typename fold_lvalue_state<State,It0,F>::type State1; + State1 const state1=f(state,fusion::deref(it0)); + typedef typename fold_lvalue_state<State1,It1,F>::type State2; + State2 const state2=f(state1,fusion::deref(it1)); + return f(state2,fusion::deref(it2)); + } + }; + template<typename Result> + struct unrolled_fold<Result,2> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename fold_lvalue_state<State,It0,F>::type State1; + State1 const state1=f(state,fusion::deref(it0)); + return f( + state1, + fusion::deref( fusion::next(it0))); + } + }; + template<typename Result> + struct unrolled_fold<Result,1> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + return f(state, + fusion::deref(it0)); + } + }; + template<typename Result> + struct unrolled_fold<Result,0> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const&, F) + { + return static_cast<Result>(state); + } + }; + template<typename StateRef, typename It0, typename F, int N> + struct result_of_unrolled_fold + { + typedef typename + fold_lvalue_state< + StateRef + , It0 const + , F + >::type + rest1; + typedef typename + result_of::next< + It0 const + >::type + it1; + typedef typename + fold_lvalue_state< + rest1 + , it1 + , F + >::type + rest2; + typedef typename + result_of::next<it1>::type + it2; + typedef typename + fold_lvalue_state< + rest2 + , it2 + , F + >::type + rest3; + typedef typename + result_of::next<it2>::type + it3; + typedef typename + result_of_unrolled_fold< + typename fold_lvalue_state< + rest3 + , it3 + , F + >::type + , typename result_of::next< + it3 + >::type + , F + , N-4 + >::type + type; + }; + template<typename StateRef, typename It0, typename F> + struct result_of_unrolled_fold< + StateRef + , It0 + , F + , 3 + > + { + typedef typename + fold_lvalue_state< + StateRef + , It0 const + , F + >::type + rest1; + typedef typename + result_of::next< + It0 const + >::type + it1; + typedef typename + fold_lvalue_state< + typename fold_lvalue_state< + rest1 + , it1 + , F + >::type + , typename result_of::next< + it1 const + >::type const + , F + >::type + type; + }; + template<typename StateRef, typename It0, typename F> + struct result_of_unrolled_fold< + StateRef + , It0 + , F + , 2 + > + : fold_lvalue_state< + typename fold_lvalue_state< + StateRef + , It0 const + , F + >::type + , typename result_of::next< + It0 const + >::type const + , F + > + {}; + template<typename StateRef, typename It0, typename F> + struct result_of_unrolled_fold< + StateRef + , It0 + , F + , 1 + > + : fold_lvalue_state< + StateRef + , It0 const + , F + > + {}; + template<typename StateRef, typename It0, typename F> + struct result_of_unrolled_fold< + StateRef + , It0 + , F + , 0 + > + { + typedef StateRef type; + }; + template<typename StateRef, typename It0, typename F, int SeqSize> + struct result_of_first_unrolledfold + { + typedef typename + result_of_unrolled_fold< + typename boost::result_of< + F( + StateRef, + typename fusion::result_of::deref< It0 const>::type + ) + >::type + , typename result_of::next< + It0 const + >::type + , F + , SeqSize-1 + >::type + type; + }; + template<int SeqSize, typename StateRef, typename Seq, typename F> + struct fold_impl + { + typedef typename + result_of_first_unrolledfold< + StateRef + , typename result_of::begin<Seq>::type + , F + , SeqSize + >::type + type; + static type + call(StateRef state, Seq& seq, F f) + { + typedef + unrolled_fold< + type + , SeqSize + > + unrolled_impl; + return unrolled_impl::call( + state, + fusion::begin(seq), + f); + } + }; + template<typename StateRef, typename Seq, typename F> + struct fold_impl<0,StateRef,Seq,F> + { + typedef StateRef type; + static StateRef + call(StateRef state, Seq&, F) + { + return static_cast<StateRef>(state); + } + }; + template<typename Seq, typename State, typename F, bool IsSegmented> + struct result_of_fold + : fold_impl< + result_of::size<Seq>::value + , typename add_reference< + typename add_const<State>::type + >::type + , Seq + , F + > + {}; + } + namespace result_of + { + template<typename Seq, typename State, typename F> + struct fold + : detail::result_of_fold< + Seq + , State + , F + , traits::is_segmented<Seq>::type::value + > + {}; + } + template<typename Seq, typename State, typename F> + inline typename result_of::fold< + Seq + , State const + , F + >::type + fold(Seq& seq, State const& state, F f) + { + return result_of::fold<Seq,State const,F>::call( + state, + seq, + f); + } + template<typename Seq, typename State, typename F> + inline typename result_of::fold< + Seq const + , State const + , F + >::type + fold(Seq const& seq, State const& state, F f) + { + return result_of::fold<Seq const,State const,F>::call( + state, + seq, + f); + } + template<typename Seq, typename State, typename F> + inline typename result_of::fold< + Seq + , State const + , F + >::type + fold(Seq& seq, State& state, F f) + { + return result_of::fold<Seq,State,F>::call( + state, + seq, + f); + } + template<typename Seq, typename State, typename F> + inline typename result_of::fold< + Seq const + , State const + , F + >::type + fold(Seq const& seq, State& state, F f) + { + return result_of::fold<Seq const,State,F>::call( + state, + seq, + f); + } +}} diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp new file mode 100644 index 0000000..48a4134 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp @@ -0,0 +1,380 @@ +/*============================================================================= + Copyright (c) 2009-2010 Christopher Schmidt + 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! +==============================================================================*/ +namespace boost { namespace fusion +{ + namespace detail + { + template<typename State, typename It, typename F> + struct reverse_fold_lvalue_state + : boost::result_of< + F( + typename add_reference<typename add_const<State>::type>::type, + typename fusion::result_of::deref<It>::type) + > + {}; + template<typename Result,int N> + struct unrolled_reverse_fold + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename + result_of::prior< + It0 const + >::type + It1; + It1 it1 = fusion::prior(it0); + typedef typename + result_of::prior< + It1 + >::type + It2; + It2 it2 = fusion::prior(it1); + typedef typename + result_of::prior< + It2 + >::type + It3; + It3 it3 = fusion::prior(it2); + typedef typename reverse_fold_lvalue_state<State,It0,F>::type State1; + State1 const state1=f(state,fusion::deref(it0)); + typedef typename reverse_fold_lvalue_state<State1,It1,F>::type State2; + State2 const state2=f(state1,fusion::deref(it1)); + typedef typename reverse_fold_lvalue_state<State2,It2,F>::type State3; + State3 const state3=f(state2,fusion::deref(it2)); + return unrolled_reverse_fold< + Result + , N-4 + >::call( + f(state3,fusion::deref(it3)), + fusion::prior(it3), + f); + } + }; + template<typename Result> + struct unrolled_reverse_fold<Result,3> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename + result_of::prior< + It0 const + >::type + It1; + It1 it1 = fusion::prior(it0); + typedef typename + result_of::prior< + It1 + >::type + It2; + It2 it2 = fusion::prior(it1); + typedef typename reverse_fold_lvalue_state<State,It0,F>::type State1; + State1 const state1=f(state,fusion::deref(it0)); + typedef typename reverse_fold_lvalue_state<State1,It1,F>::type State2; + State2 const state2=f(state1,fusion::deref(it1)); + return f(state2,fusion::deref(it2)); + } + }; + template<typename Result> + struct unrolled_reverse_fold<Result,2> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + typedef typename reverse_fold_lvalue_state<State,It0,F>::type State1; + State1 const state1=f(state,fusion::deref(it0)); + return f( + state1, + fusion::deref( fusion::prior(it0))); + } + }; + template<typename Result> + struct unrolled_reverse_fold<Result,1> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const& it0,F f) + { + return f(state, + fusion::deref(it0)); + } + }; + template<typename Result> + struct unrolled_reverse_fold<Result,0> + { + template<typename State, typename It0, typename F> + static Result + call(State const& state,It0 const&, F) + { + return static_cast<Result>(state); + } + }; + template<typename StateRef, typename It0, typename F, int N> + struct result_of_unrolled_reverse_fold + { + typedef typename + reverse_fold_lvalue_state< + StateRef + , It0 const + , F + >::type + rest1; + typedef typename + result_of::prior< + It0 const + >::type + it1; + typedef typename + reverse_fold_lvalue_state< + rest1 + , it1 + , F + >::type + rest2; + typedef typename + result_of::prior<it1>::type + it2; + typedef typename + reverse_fold_lvalue_state< + rest2 + , it2 + , F + >::type + rest3; + typedef typename + result_of::prior<it2>::type + it3; + typedef typename + result_of_unrolled_reverse_fold< + typename reverse_fold_lvalue_state< + rest3 + , it3 + , F + >::type + , typename result_of::prior< + it3 + >::type + , F + , N-4 + >::type + type; + }; + template<typename StateRef, typename It0, typename F> + struct result_of_unrolled_reverse_fold< + StateRef + , It0 + , F + , 3 + > + { + typedef typename + reverse_fold_lvalue_state< + StateRef + , It0 const + , F + >::type + rest1; + typedef typename + result_of::prior< + It0 const + >::type + it1; + typedef typename + reverse_fold_lvalue_state< + typename reverse_fold_lvalue_state< + rest1 + , it1 + , F + >::type + , typename result_of::prior< + it1 const + >::type const + , F + >::type + type; + }; + template<typename StateRef, typename It0, typename F> + struct result_of_unrolled_reverse_fold< + StateRef + , It0 + , F + , 2 + > + : reverse_fold_lvalue_state< + typename reverse_fold_lvalue_state< + StateRef + , It0 const + , F + >::type + , typename result_of::prior< + It0 const + >::type const + , F + > + {}; + template<typename StateRef, typename It0, typename F> + struct result_of_unrolled_reverse_fold< + StateRef + , It0 + , F + , 1 + > + : reverse_fold_lvalue_state< + StateRef + , It0 const + , F + > + {}; + template<typename StateRef, typename It0, typename F> + struct result_of_unrolled_reverse_fold< + StateRef + , It0 + , F + , 0 + > + { + typedef StateRef type; + }; + template<typename StateRef, typename It0, typename F, int SeqSize> + struct result_of_first_unrolledreverse_fold + { + typedef typename + result_of_unrolled_reverse_fold< + typename boost::result_of< + F( + StateRef, + typename fusion::result_of::deref< It0 const>::type + ) + >::type + , typename result_of::prior< + It0 const + >::type + , F + , SeqSize-1 + >::type + type; + }; + template<int SeqSize, typename StateRef, typename Seq, typename F> + struct reverse_fold_impl + { + typedef typename + result_of_first_unrolledreverse_fold< + StateRef + , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type + , F + , SeqSize + >::type + type; + static type + call(StateRef state, Seq& seq, F f) + { + typedef + unrolled_reverse_fold< + type + , SeqSize + > + unrolled_impl; + return unrolled_impl::call( + state, + fusion::prior( fusion::end(seq)), + f); + } + }; + template<typename StateRef, typename Seq, typename F> + struct reverse_fold_impl<0,StateRef,Seq,F> + { + typedef StateRef type; + static StateRef + call(StateRef state, Seq&, F) + { + return static_cast<StateRef>(state); + } + }; + template<typename Seq, typename State, typename F, bool IsSegmented> + struct result_of_reverse_fold + : reverse_fold_impl< + result_of::size<Seq>::value + , typename add_reference< + typename add_const<State>::type + >::type + , Seq + , F + > + {}; + } + namespace result_of + { + template<typename Seq, typename State, typename F> + struct reverse_fold + : detail::result_of_reverse_fold< + Seq + , State + , F + , traits::is_segmented<Seq>::type::value + > + {}; + } + template<typename Seq, typename State, typename F> + inline typename result_of::reverse_fold< + Seq + , State const + , F + >::type + reverse_fold(Seq& seq, State const& state, F f) + { + return result_of::reverse_fold<Seq,State const,F>::call( + state, + seq, + f); + } + template<typename Seq, typename State, typename F> + inline typename result_of::reverse_fold< + Seq const + , State const + , F + >::type + reverse_fold(Seq const& seq, State const& state, F f) + { + return result_of::reverse_fold<Seq const,State const,F>::call( + state, + seq, + f); + } + template<typename Seq, typename State, typename F> + inline typename result_of::reverse_fold< + Seq + , State const + , F + >::type + reverse_fold(Seq& seq, State& state, F f) + { + return result_of::reverse_fold<Seq,State,F>::call( + state, + seq, + f); + } + template<typename Seq, typename State, typename F> + inline typename result_of::reverse_fold< + Seq const + , State const + , F + >::type + reverse_fold(Seq const& seq, State& state, F f) + { + return result_of::reverse_fold<Seq const,State,F>::call( + state, + seq, + f); + } +}} diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp new file mode 100644 index 0000000..2371e18 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp @@ -0,0 +1,59 @@ +/*============================================================================= + Copyright (c) 2011 Eric Niebler + + 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_FOLD_S_HPP_INCLUDED) +#define BOOST_FUSION_FOLD_S_HPP_INCLUDED + +#include <boost/fusion/algorithm/iteration/fold_fwd.hpp> +#include <boost/fusion/support/segmented_fold_until.hpp> + +namespace boost { namespace fusion { namespace detail +{ + template <typename Fun> + struct segmented_fold_fun + { + explicit segmented_fold_fun(Fun const& f) + : fun(f) + {} + + Fun const& fun; + + template <typename Sequence, typename State, typename Context> + struct apply + { + typedef typename result_of::fold<Sequence, State, Fun>::type type; + typedef mpl::true_ continue_type; + + static type call(Sequence& seq, State const& state, Context const&, segmented_fold_fun const& fun) + { + return fusion::fold(seq, state, fun.fun); + } + }; + }; + + // The default implementation of this lives in detail/fold.hpp + template <typename Sequence, typename State, typename Fun, bool IsSegmented> + struct result_of_fold; + + template <typename Sequence, typename State, typename Fun> + struct result_of_fold<Sequence, State, Fun, true> + { + typedef + typename result_of::segmented_fold_until< + Sequence, + State, + segmented_fold_fun<Fun> + >::type + type; + + static type call(State& state, Sequence& seq, Fun fun) + { + return fusion::segmented_fold_until(seq, state, segmented_fold_fun<Fun>(fun)); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp new file mode 100644 index 0000000..f7ffb24 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp @@ -0,0 +1,48 @@ +/*============================================================================= + Copyright (c) 2011 Eric Niebler + + 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_SEGMENTED_FOR_EACH_HPP_INCLUDED) +#define BOOST_FUSION_SEGMENTED_FOR_EACH_HPP_INCLUDED + +#include <boost/mpl/bool.hpp> +#include <boost/fusion/support/void.hpp> +#include <boost/fusion/algorithm/iteration/for_each_fwd.hpp> +#include <boost/fusion/support/segmented_fold_until.hpp> + +namespace boost { namespace fusion { namespace detail +{ + template <typename Fun> + struct segmented_for_each_fun + { + explicit segmented_for_each_fun(Fun const& f) + : fun(f) + {} + + Fun const& fun; + + template <typename Sequence, typename State, typename Context> + struct apply + { + typedef void_ type; + typedef mpl::true_ continue_type; + + static type call(Sequence& seq, State const&, Context const&, segmented_for_each_fun const& fun) + { + fusion::for_each(seq, fun.fun); + return void_(); + } + }; + }; + + template <typename Sequence, typename F> + inline void + for_each(Sequence& seq, F const& f, mpl::true_) // segmented implementation + { + fusion::segmented_fold_until(seq, void_(), segmented_for_each_fun<F>(f)); + } +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/fold.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/fold.hpp new file mode 100644 index 0000000..813bb6b --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/fold.hpp @@ -0,0 +1,63 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2007 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + 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_ALGORITHM_ITERATION_FOLD_HPP +#define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_HPP + +#include <boost/fusion/algorithm/iteration/fold_fwd.hpp> +#include <boost/config.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/sequence/intrinsic/empty.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/fusion/support/is_segmented.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/iterator/deref.hpp> +#include <boost/fusion/iterator/value_of.hpp> +#include <boost/fusion/iterator/prior.hpp> +#include <boost/fusion/iterator/next.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_reference.hpp> + +#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES) +#include <boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp> +#else +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/fold.hpp") +#endif + +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2007 Dan Marsden + Copyright (c) 2009-2010 Christopher Schmidt + + 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 + +#include <boost/fusion/algorithm/iteration/detail/fold.hpp> + +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(output: null) +#endif + +#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES + +#include <boost/fusion/algorithm/iteration/detail/segmented_fold.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/fold_fwd.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/fold_fwd.hpp new file mode 100644 index 0000000..edb43e0 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/fold_fwd.hpp @@ -0,0 +1,52 @@ +/*============================================================================= + Copyright (c) 2011 Eric Niebler + + 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_ALGORITHM_ITERATION_FOLD_FWD_HPP +#define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_FWD_HPP + +namespace boost { namespace fusion +{ + namespace result_of + { + template<typename Seq, typename State, typename F> + struct fold; + } + + template<typename Seq, typename State, typename F> + typename result_of::fold< + Seq + , State const + , F + >::type + fold(Seq& seq, State const& state, F f); + + template<typename Seq, typename State, typename F> + typename result_of::fold< + Seq const + , State const + , F + >::type + fold(Seq const& seq, State const& state, F f); + + template<typename Seq, typename State, typename F> + typename result_of::fold< + Seq + , State const + , F + >::type + fold(Seq& seq, State& state, F f); + + template<typename Seq, typename State, typename F> + typename result_of::fold< + Seq const + , State const + , F + >::type + fold(Seq const& seq, State& state, F f); +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/for_each.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/for_each.hpp new file mode 100644 index 0000000..17cde34 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/for_each.hpp @@ -0,0 +1,53 @@ +/*============================================================================= + Copyright (c) 2001-2007 Joel de Guzman + Copyright (c) 2007 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_FOR_EACH_20070527_0943) +#define BOOST_FUSION_FOR_EACH_20070527_0943 + +#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 +{ + namespace result_of + { + template <typename Sequence, typename F> + struct for_each + { + typedef void type; + }; + } + + template <typename Sequence, typename F> + inline + typename + enable_if< + traits::is_sequence<Sequence> + , void + >::type + 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 + for_each(Sequence const& seq, F const& f) + { + detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type()); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/for_each_fwd.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/for_each_fwd.hpp new file mode 100644 index 0000000..b757873 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/for_each_fwd.hpp @@ -0,0 +1,40 @@ +/*============================================================================= + Copyright (c) 2011 Eric Niebler + + 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_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 + { + template <typename Sequence, typename F> + struct for_each; + } + + template <typename Sequence, typename F> + inline + typename + enable_if< + traits::is_sequence<Sequence> + , void + >::type + for_each(Sequence& seq, F const& f); + + template <typename Sequence, typename F> + inline + typename + enable_if< + traits::is_sequence<Sequence> + , void + >::type + for_each(Sequence const& seq, F const& f); +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/reverse_fold.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/reverse_fold.hpp new file mode 100644 index 0000000..c8bdef5 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/reverse_fold.hpp @@ -0,0 +1,64 @@ +/*============================================================================= + Copyright (c) 2010 Christopher Schmidt + 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_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_HPP +#define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_HPP + +#include <boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp> +#include <boost/config.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/sequence/intrinsic/empty.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/fusion/support/is_segmented.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/iterator/deref.hpp> +#include <boost/fusion/iterator/value_of.hpp> +#include <boost/fusion/iterator/prior.hpp> +#include <boost/fusion/iterator/next.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/utility/result_of.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_reference.hpp> + +#define BOOST_FUSION_REVERSE_FOLD + +#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES) +#include <boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp> +#else +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/reverse_fold.hpp") +#endif + +/*============================================================================= + Copyright (c) 2009-2010 Christopher Schmidt + 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 + +#include <boost/fusion/algorithm/iteration/detail/fold.hpp> + +#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES) +#pragma wave option(output: null) +#endif + +#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES + +#undef BOOST_FUSION_REVERSE_FOLD + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp new file mode 100644 index 0000000..40546b5 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp @@ -0,0 +1,52 @@ +/*============================================================================= + Copyright (c) 2011 Eric Niebler + + 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_ALGORITHM_ITERATION_REVERSE_FOLD_FWD_HPP +#define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_FWD_HPP + +namespace boost { namespace fusion +{ + namespace result_of + { + template<typename Seq, typename State, typename F> + struct reverse_fold; + } + + template<typename Seq, typename State, typename F> + typename result_of::reverse_fold< + Seq + , State const + , F + >::type + reverse_fold(Seq& seq, State const& state, F f); + + template<typename Seq, typename State, typename F> + typename result_of::reverse_fold< + Seq const + , State const + , F + >::type + reverse_fold(Seq const& seq, State const& state, F f); + + template<typename Seq, typename State, typename F> + typename result_of::reverse_fold< + Seq + , State const + , F + >::type + reverse_fold(Seq& seq, State& state, F f); + + template<typename Seq, typename State, typename F> + typename result_of::reverse_fold< + Seq const + , State const + , F + >::type + reverse_fold(Seq const& seq, State& state, F f); +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/query/any.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/query/any.hpp new file mode 100644 index 0000000..8b1fca0 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/query/any.hpp @@ -0,0 +1,35 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005 Eric Niebler + Copyright (c) 2007 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_ANY_05052005_1230) +#define FUSION_ANY_05052005_1230 + +#include <boost/fusion/support/category_of.hpp> +#include <boost/fusion/algorithm/query/detail/any.hpp> + +namespace boost { namespace fusion +{ + namespace result_of + { + template <typename Sequence, typename F> + struct any + { + typedef bool type; + }; + } + + template <typename Sequence, typename F> + inline bool + any(Sequence const& seq, F f) + { + return detail::any(seq, f, typename traits::category_of<Sequence>::type()); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/any.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/any.hpp new file mode 100644 index 0000000..5f6b857 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/any.hpp @@ -0,0 +1,130 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2005 Eric Niebler + Copyright (c) 2007 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_ANY_05052005_1229) +#define FUSION_ANY_05052005_1229 + +#include <boost/mpl/bool.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/iterator/advance.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/iterator/next.hpp> +#include <boost/fusion/iterator/deref.hpp> +#include <boost/fusion/iterator/distance.hpp> + +namespace boost { namespace fusion { + struct random_access_traversal_tag; +namespace detail +{ + template <typename First, typename Last, typename F> + inline bool + linear_any(First const&, Last const&, F const&, mpl::true_) + { + return false; + } + + template <typename First, typename Last, typename F> + inline bool + linear_any(First const& first, Last const& last, F& f, mpl::false_) + { + typename result_of::deref<First>::type x = *first; + return f(x) || + detail::linear_any( + fusion::next(first) + , last + , f + , result_of::equal_to<typename result_of::next<First>::type, Last>()); + } + + template <typename Sequence, typename F, typename Tag> + inline bool + any(Sequence const& seq, F f, Tag) + { + return detail::linear_any( + fusion::begin(seq) + , fusion::end(seq) + , f + , result_of::equal_to< + typename result_of::begin<Sequence>::type + , typename result_of::end<Sequence>::type>()); + } + + template<int N> + struct unrolled_any + { + template <typename It, typename F> + static bool call(It const& it, F f) + { + return + f(*it) || + f(*fusion::advance_c<1>(it))|| + f(*fusion::advance_c<2>(it)) || + f(*fusion::advance_c<3>(it)) || + detail::unrolled_any<N-4>::call(fusion::advance_c<4>(it), f); + } + }; + + template<> + struct unrolled_any<3> + { + template <typename It, typename F> + static bool call(It const& it, F f) + { + return + f(*it) || + f(*fusion::advance_c<1>(it)) || + f(*fusion::advance_c<2>(it)); + } + }; + + template<> + struct unrolled_any<2> + { + template <typename It, typename F> + static bool call(It const& it, F f) + { + return + f(*it) || + f(*fusion::advance_c<1>(it)); + } + }; + + template<> + struct unrolled_any<1> + { + template <typename It, typename F> + static bool call(It const& it, F f) + { + return f(*it); + } + }; + + template<> + struct unrolled_any<0> + { + template <typename It, typename F> + static bool call(It const&, F) + { + return false; + } + }; + + template <typename Sequence, typename F> + inline bool + any(Sequence const& seq, F f, random_access_traversal_tag) + { + typedef typename result_of::begin<Sequence>::type begin; + typedef typename result_of::end<Sequence>::type end; + return detail::unrolled_any<result_of::distance<begin, end>::type::value>::call( + fusion::begin(seq), f); + } +}}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/find_if.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/find_if.hpp new file mode 100644 index 0000000..f7bae45 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/find_if.hpp @@ -0,0 +1,252 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2007 Dan Marsden + Copyright (c) 2009 Christopher Schmidt + + 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_FIND_IF_05052005_1107) +#define FUSION_FIND_IF_05052005_1107 + +#include <boost/mpl/apply.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/mpl/lambda.hpp> +#include <boost/mpl/or.hpp> +#include <boost/fusion/iterator/advance.hpp> +#include <boost/fusion/iterator/distance.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/iterator/next.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/support/category_of.hpp> + +namespace boost { namespace fusion { + struct random_access_traversal_tag; +namespace detail +{ + template <typename Iterator, typename Pred> + struct apply_filter + { + typedef typename mpl::apply1< + Pred, Iterator>::type type; + BOOST_STATIC_CONSTANT(int, value = type::value); + }; + + template <typename First, typename Last, typename Pred> + struct main_find_if; + + template <typename First, typename Last, typename Pred> + struct recursive_find_if + { + typedef typename + main_find_if< + typename result_of::next<First>::type, Last, Pred + >::type + type; + }; + + template <typename First, typename Last, typename Pred> + struct main_find_if + { + typedef mpl::or_< + result_of::equal_to<First, Last> + , apply_filter<First, Pred> > + filter; + + typedef typename + mpl::eval_if< + filter + , mpl::identity<First> + , recursive_find_if<First, Last, Pred> + >::type + type; + }; + + template< + typename First, typename Last, + typename Pred, bool> + struct choose_find_if; + + template<typename First, typename Last, typename Pred> + struct choose_find_if<First, Last, Pred, false> + : main_find_if<First, Last, Pred> + {}; + + template<typename Iter, typename Pred, int n, int unrolling> + struct unroll_again; + + template <typename Iter, typename Pred, int offset> + struct apply_offset_filter + { + typedef typename result_of::advance_c<Iter, offset>::type Shifted; + typedef typename + mpl::apply1< + Pred + , Shifted + >::type + type; + BOOST_STATIC_CONSTANT(int, value = type::value); + }; + + template<typename Iter, typename Pred, int n> + struct unrolled_find_if + { + typedef typename mpl::eval_if< + apply_filter<Iter, Pred>, + mpl::identity<Iter>, + mpl::eval_if< + apply_offset_filter<Iter, Pred, 1>, + result_of::advance_c<Iter, 1>, + mpl::eval_if< + apply_offset_filter<Iter, Pred, 2>, + result_of::advance_c<Iter, 2>, + mpl::eval_if< + apply_offset_filter<Iter, Pred, 3>, + result_of::advance_c<Iter, 3>, + unroll_again< + Iter, + Pred, + n, + 4> > > > >::type type; + }; + + template<typename Iter, typename Pred> + struct unrolled_find_if<Iter, Pred, 3> + { + typedef typename mpl::eval_if< + apply_filter<Iter, Pred>, + mpl::identity<Iter>, + mpl::eval_if< + apply_offset_filter<Iter, Pred, 1>, + result_of::advance_c<Iter, 1>, + mpl::eval_if< + apply_offset_filter<Iter, Pred, 2>, + result_of::advance_c<Iter, 2>, + result_of::advance_c<Iter, 3> > > >::type type; + }; + + template<typename Iter, typename Pred> + struct unrolled_find_if<Iter, Pred, 2> + { + typedef typename mpl::eval_if< + apply_filter<Iter, Pred>, + mpl::identity<Iter>, + mpl::eval_if< + apply_offset_filter<Iter, Pred, 1>, + result_of::advance_c<Iter, 1>, + result_of::advance_c<Iter, 2> > >::type type; + }; + + template<typename Iter, typename Pred> + struct unrolled_find_if<Iter, Pred, 1> + { + typedef typename mpl::eval_if< + apply_filter<Iter, Pred>, + mpl::identity<Iter>, + result_of::advance_c<Iter, 1> >::type type; + }; + + template<typename Iter, typename Pred, int n, int unrolling> + struct unroll_again + { + typedef typename unrolled_find_if< + typename result_of::advance_c<Iter, unrolling>::type, + Pred, + n-unrolling>::type type; + }; + + template<typename Iter, typename Pred> + struct unrolled_find_if<Iter, Pred, 0> + { + typedef Iter type; + }; + + template<typename First, typename Last, typename Pred> + struct choose_find_if<First, Last, Pred, true> + { + typedef typename result_of::distance<First, Last>::type N; + typedef typename unrolled_find_if<First, Pred, N::value>::type type; + }; + + template <typename First, typename Last, typename Pred> + struct static_find_if + { + typedef typename + choose_find_if< + First + , Last + , typename mpl::lambda<Pred>::type + , is_base_of<random_access_traversal_tag, typename traits::category_of<First>::type>::value + >::type + type; + + template <typename Iterator> + static type + recursive_call(Iterator const& iter, mpl::true_) + { + return iter; + } + + template <typename Iterator> + static type + recursive_call(Iterator const& iter, mpl::false_) + { + return recursive_call(fusion::next(iter)); + } + + template <typename Iterator> + static type + recursive_call(Iterator const& iter) + { + typedef result_of::equal_to<Iterator, type> found; + return recursive_call(iter, found()); + } + + template <typename Iterator, typename Tag> + static type + choose_call(Iterator const& iter, Tag) + { + return recursive_call(iter); + } + + template <typename Iterator> + static type + choose_call(Iterator const& iter, random_access_traversal_tag) + { + typedef typename result_of::distance<Iterator, type>::type N; + return fusion::advance<N>(iter); + } + + template <typename Iterator> + static type + iter_call(Iterator const& iter) + { + return choose_call(iter, typename traits::category_of<Iterator>::type()); + } + + template <typename Sequence> + static type + call(Sequence& seq) + { + return iter_call(fusion::begin(seq)); + } + }; + + template <typename Sequence, typename Pred> + struct result_of_find_if + { + typedef + static_find_if< + typename result_of::begin<Sequence>::type + , typename result_of::end<Sequence>::type + , Pred + > + filter; + + typedef typename filter::type type; + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/segmented_find.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/segmented_find.hpp new file mode 100644 index 0000000..ead5783 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/query/detail/segmented_find.hpp @@ -0,0 +1,90 @@ +/*============================================================================= + Copyright (c) 2011 Eric Niebler + + 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_SEGMENTED_FIND_HPP_INCLUDED) +#define BOOST_FUSION_SEGMENTED_FIND_HPP_INCLUDED + +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/fusion/algorithm/query/find_fwd.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/support/segmented_fold_until.hpp> + +namespace boost { namespace fusion { namespace detail +{ + template <typename T> + struct segmented_find_fun + { + template <typename Sequence, typename State, typename Context> + struct apply + { + typedef + typename result_of::find<Sequence, T>::type + iterator_type; + + typedef + typename result_of::equal_to< + iterator_type + , typename result_of::end<Sequence>::type + >::type + continue_type; + + typedef + typename mpl::eval_if< + continue_type + , mpl::identity<State> + , result_of::make_segmented_iterator< + iterator_type + , Context + > + >::type + type; + + static type call(Sequence& seq, State const&state, Context const& context, segmented_find_fun) + { + return call_impl(seq, state, context, continue_type()); + } + + static type call_impl(Sequence&, State const&state, Context const&, mpl::true_) + { + return state; + } + + static type call_impl(Sequence& seq, State const&, Context const& context, mpl::false_) + { + return fusion::make_segmented_iterator(fusion::find<T>(seq), context); + } + }; + }; + + template <typename Sequence, typename T> + struct result_of_segmented_find + { + struct filter + { + typedef + typename result_of::segmented_fold_until< + Sequence + , typename result_of::end<Sequence>::type + , segmented_find_fun<T> + >::type + type; + + static type call(Sequence& seq) + { + return fusion::segmented_fold_until( + seq + , fusion::end(seq) + , detail::segmented_find_fun<T>()); + } + }; + + typedef typename filter::type type; + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/query/find.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/query/find.hpp new file mode 100644 index 0000000..16def08 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/query/find.hpp @@ -0,0 +1,69 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2011 Eric Niebler + + 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_FIND_05052005_1107) +#define FUSION_FIND_05052005_1107 + +#include <boost/fusion/algorithm/query/find_if_fwd.hpp> +#include <boost/fusion/algorithm/query/detail/find_if.hpp> +#include <boost/fusion/algorithm/query/detail/segmented_find.hpp> +#include <boost/fusion/iterator/key_of.hpp> +#include <boost/fusion/iterator/value_of.hpp> +#include <boost/fusion/support/category_of.hpp> +#include <boost/fusion/support/is_segmented.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/placeholders.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/utility/enable_if.hpp> + +namespace boost { namespace fusion +{ + namespace result_of + { + template <typename Sequence, typename T> + struct find + : mpl::if_< + traits::is_segmented<Sequence> + , detail::result_of_segmented_find<Sequence, T> + , detail::result_of_find_if< + Sequence, + is_same< + typename mpl::if_< + traits::is_associative<Sequence> + , key_of<mpl::_1> + , value_of<mpl::_1> + >::type + , T + > + > + >::type + {}; + } + + template <typename T, typename Sequence> + inline typename + lazy_disable_if< + is_const<Sequence> + , result_of::find<Sequence, T> + >::type const + find(Sequence& seq) + { + typedef typename result_of::find<Sequence, T>::filter filter; + return filter::call(seq); + } + + template <typename T, typename Sequence> + inline typename result_of::find<Sequence const, T>::type const + find(Sequence const& seq) + { + typedef typename result_of::find<Sequence const, T>::filter filter; + return filter::call(seq); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/query/find_fwd.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/query/find_fwd.hpp new file mode 100644 index 0000000..96d989a --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/query/find_fwd.hpp @@ -0,0 +1,34 @@ +/*============================================================================= + Copyright (c) 2011 Eric Niebler + + 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_FIND_FWD_HPP_INCLUDED) +#define BOOST_FUSION_FIND_FWD_HPP_INCLUDED + +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/is_const.hpp> + +namespace boost { namespace fusion +{ + namespace result_of + { + template <typename Sequence, typename T> + struct find; + } + + template <typename T, typename Sequence> + inline typename + lazy_disable_if< + is_const<Sequence> + , result_of::find<Sequence, T> + >::type const + find(Sequence& seq); + + template <typename T, typename Sequence> + inline typename result_of::find<Sequence const, T>::type const + find(Sequence const& seq); +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/query/find_if_fwd.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/query/find_if_fwd.hpp new file mode 100644 index 0000000..adb8f2d --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/query/find_if_fwd.hpp @@ -0,0 +1,35 @@ +/*============================================================================= + Copyright (c) 2011 Eric Niebler + + 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_FIND_IF_FWD_HPP_INCLUDED) +#define BOOST_FUSION_FIND_IF_FWD_HPP_INCLUDED + +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/is_const.hpp> + +// Forward declaration of find_if algorithm +namespace boost { namespace fusion +{ + namespace result_of + { + template <typename Sequence, typename Pred> + struct find_if; + } + + template <typename Pred, typename Sequence> + typename + lazy_disable_if< + is_const<Sequence> + , result_of::find_if<Sequence, Pred> + >::type + find_if(Sequence& seq); + + template <typename Pred, typename Sequence> + typename result_of::find_if<Sequence const, Pred>::type const + find_if(Sequence const& seq); +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/erase.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/erase.hpp new file mode 100644 index 0000000..6ad737f --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/erase.hpp @@ -0,0 +1,135 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_ERASE_07232005_0534) +#define FUSION_ERASE_07232005_0534 + +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/iterator/mpl/convert_iterator.hpp> +#include <boost/fusion/container/vector/vector10.hpp> +#include <boost/fusion/view/joint_view/joint_view.hpp> +#include <boost/fusion/view/iterator_range/iterator_range.hpp> +#include <boost/fusion/support/detail/as_fusion_element.hpp> +#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 +{ + namespace result_of + { + template <typename Sequence, typename First> + struct compute_erase_last // put this in detail!!! + { + typedef typename result_of::end<Sequence>::type seq_last_type; + typedef typename convert_iterator<First>::type first_type; + typedef typename + mpl::if_< + result_of::equal_to<first_type, seq_last_type> + , first_type + , typename result_of::next<first_type>::type + >::type + type; + + static type + call(First const& first, mpl::false_) + { + return fusion::next(convert_iterator<First>::call(first)); + } + + static type + call(First const& first, mpl::true_) + { + return convert_iterator<First>::call(first); + } + + static type + call(First const& first) + { + return call(first, result_of::equal_to<first_type, seq_last_type>()); + } + }; + + 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> + 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 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; + }; + } + + template <typename Sequence, typename First> + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , typename result_of::erase<Sequence const, First> + >::type + erase(Sequence const& seq, First const& first) + { + typedef result_of::erase<Sequence const, First> result_of; + typedef typename result_of::left_type left_type; + typedef typename result_of::right_type right_type; + typedef typename result_of::type result_type; + + left_type left( + fusion::begin(seq) + , convert_iterator<First>::call(first)); + right_type right( + fusion::result_of::compute_erase_last<Sequence const, First>::call(first) + , fusion::end(seq)); + return result_type(left, right); + } + + template <typename Sequence, typename First, typename Last> + typename result_of::erase<Sequence const, First, Last>::type + erase(Sequence const& seq, First const& first, Last const& last) + { + typedef result_of::erase<Sequence const, First, Last> result_of; + typedef typename result_of::left_type left_type; + typedef typename result_of::right_type right_type; + typedef typename result_of::type result_type; + + left_type left(fusion::begin(seq), first); + right_type right(last, fusion::end(seq)); + return result_type(left, right); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/erase_key.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/erase_key.hpp new file mode 100644 index 0000000..383f4f8 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/erase_key.hpp @@ -0,0 +1,34 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_ERASE_KEY_10022005_1851) +#define FUSION_ERASE_KEY_10022005_1851 + +#include <boost/fusion/algorithm/query/find.hpp> +#include <boost/fusion/algorithm/transformation/erase.hpp> +#include <boost/mpl/not.hpp> +#include <boost/type_traits/is_same.hpp> + +namespace boost { namespace fusion +{ + namespace result_of + { + template <typename Sequence, typename Key> + struct erase_key + : erase<Sequence, typename find<Sequence, Key>::type> + {}; + } + + template <typename Key, typename Sequence> + inline typename result_of::erase_key<Sequence const, Key>::type + erase_key(Sequence const& seq) + { + return erase(seq, find<Key>(seq)); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/filter_if.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/filter_if.hpp new file mode 100644 index 0000000..d989d30 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/filter_if.hpp @@ -0,0 +1,32 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_FILTER_IF_07172005_0818) +#define FUSION_FILTER_IF_07172005_0818 + +#include <boost/fusion/view/filter_view/filter_view.hpp> + +namespace boost { namespace fusion +{ + namespace result_of + { + template <typename Sequence, typename Pred> + struct filter_if + { + typedef filter_view<Sequence, Pred> type; + }; + } + + template <typename Pred, typename Sequence> + inline typename result_of::filter_if<Sequence const, Pred>::type + filter_if(Sequence const& seq) + { + return filter_view<Sequence const, Pred>(seq); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/insert.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/insert.hpp new file mode 100644 index 0000000..2052fc0 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/insert.hpp @@ -0,0 +1,69 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_INSERT_07222005_0730) +#define FUSION_INSERT_07222005_0730 + +#include <boost/fusion/support/detail/as_fusion_element.hpp> +#include <boost/fusion/iterator/mpl/convert_iterator.hpp> +#include <boost/fusion/container/vector/vector10.hpp> +#include <boost/fusion/view/joint_view/joint_view.hpp> +#include <boost/fusion/view/single_view/single_view.hpp> +#include <boost/fusion/view/iterator_range/iterator_range.hpp> +#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 +{ + namespace result_of + { + template <typename Sequence, typename Position, typename T> + struct insert + { + typedef typename detail::as_fusion_element<T>::type element_type; + typedef typename convert_iterator<Position>::type pos_type; + typedef typename result_of::begin<Sequence>::type first_type; + typedef typename result_of::end<Sequence>::type last_type; + + typedef iterator_range<first_type, pos_type> left_type; + typedef iterator_range<pos_type, last_type> right_type; + typedef fusion::single_view<element_type> single_view; + typedef joint_view<left_type, single_view const> left_insert_type; + typedef joint_view<left_insert_type, right_type> type; + }; + } + + template <typename Sequence, typename Position, typename T> + inline + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::insert<Sequence const, Position, T> + >::type + insert(Sequence const& seq, Position const& pos, T const& x) + { + typedef result_of::insert< + Sequence const, Position, T> + result_of; + typedef typename result_of::left_type left_type; + typedef typename result_of::right_type right_type; + typedef typename result_of::single_view single_view; + typedef typename result_of::left_insert_type left_insert_type; + typedef typename result_of::type result; + + left_type left(fusion::begin(seq), convert_iterator<Position>::call(pos)); + right_type right(convert_iterator<Position>::call(pos), fusion::end(seq)); + single_view insert(x); + left_insert_type left_insert(left, insert); + return result(left_insert, right); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/insert_range.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/insert_range.hpp new file mode 100644 index 0000000..f70a78e --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/insert_range.hpp @@ -0,0 +1,55 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_INSERT_RANGE_009172005_1147) +#define FUSION_INSERT_RANGE_009172005_1147 + +#include <boost/fusion/iterator/mpl/convert_iterator.hpp> +#include <boost/fusion/container/vector/vector10.hpp> +#include <boost/fusion/view/joint_view/joint_view.hpp> +#include <boost/fusion/view/iterator_range/iterator_range.hpp> +#include <boost/fusion/support/detail/as_fusion_element.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/adapted/mpl/mpl_iterator.hpp> + +namespace boost { namespace fusion +{ + namespace result_of + { + template <typename Sequence, typename Position, typename Range> + struct insert_range + { + typedef typename convert_iterator<Position>::type pos_type; + typedef typename result_of::begin<Sequence>::type first_type; + typedef typename result_of::end<Sequence>::type last_type; + + typedef iterator_range<first_type, pos_type> left_type; + typedef iterator_range<pos_type, last_type> right_type; + typedef joint_view<left_type, Range> left_insert_type; + typedef joint_view<left_insert_type, right_type> type; + }; + } + + template <typename Sequence, typename Position, typename Range> + inline typename result_of::insert_range<Sequence const, Position, Range const>::type + insert_range(Sequence const& seq, Position const& pos, Range const& range) + { + typedef result_of::insert_range<Sequence const, Position, Range const> result_of; + typedef typename result_of::left_type left_type; + typedef typename result_of::right_type right_type; + typedef typename result_of::left_insert_type left_insert_type; + typedef typename result_of::type result; + + left_type left(fusion::begin(seq), convert_iterator<Position>::call(pos)); + right_type right(convert_iterator<Position>::call(pos), fusion::end(seq)); + left_insert_type left_insert(left, range); + return result(left_insert, right); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/pop_back.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/pop_back.hpp new file mode 100644 index 0000000..6059c55 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/pop_back.hpp @@ -0,0 +1,166 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_POP_BACK_09172005_1038) +#define FUSION_POP_BACK_09172005_1038 + +#include <boost/fusion/view/iterator_range/iterator_range.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/sequence/intrinsic/empty.hpp> +#include <boost/fusion/iterator/iterator_adapter.hpp> +#include <boost/fusion/iterator/next.hpp> +#include <boost/mpl/minus.hpp> +#include <boost/mpl/int.hpp> +#include <boost/mpl/if.hpp> + +namespace boost { namespace fusion +{ + template <typename Iterator_, bool IsLast> + struct pop_back_iterator + : iterator_adapter< + pop_back_iterator<Iterator_, IsLast> + , Iterator_> + { + typedef iterator_adapter< + pop_back_iterator<Iterator_, IsLast> + , Iterator_> + base_type; + + static bool const is_last = IsLast; + + pop_back_iterator(Iterator_ const& iterator_base) + : base_type(iterator_base) {} + + template <typename BaseIterator> + struct make + { + typedef pop_back_iterator<BaseIterator, is_last> type; + + static type + call(BaseIterator const& i) + { + return type(i); + } + }; + + template <typename I, bool IsLast_> + struct equal_to_helper + : mpl::identity<typename I::iterator_base_type> + {}; + + template <typename I> + struct equal_to_helper<I, true> + : result_of::next< + typename I::iterator_base_type> + {}; + + template <typename I1, typename I2> + struct equal_to + : result_of::equal_to< + typename equal_to_helper<I1, + (I2::is_last && !I1::is_last)>::type + , typename equal_to_helper<I2, + (I1::is_last && !I2::is_last)>::type + > + {}; + + template <typename First, typename Last> + struct distance + : mpl::minus< + typename result_of::distance< + typename First::iterator_base_type + , typename Last::iterator_base_type + >::type + , mpl::int_<(Last::is_last?1:0)> + >::type + {}; + + + template <typename Iterator, bool IsLast_> + struct prior_impl + { + typedef typename Iterator::iterator_base_type base_type; + + typedef typename + result_of::prior<base_type>::type + base_prior; + + typedef pop_back_iterator<base_prior, false> type; + + static type + call(Iterator const& i) + { + return type(fusion::prior(i.iterator_base)); + } + }; + + template <typename Iterator> + struct prior_impl<Iterator, true> + { + // If this is the last iterator, we'll have to double back + typedef typename Iterator::iterator_base_type base_type; + + typedef typename + result_of::prior< + typename result_of::prior<base_type>::type + >::type + base_prior; + + typedef pop_back_iterator<base_prior, false> type; + + static type + call(Iterator const& i) + { + return type(fusion::prior( + fusion::prior(i.iterator_base))); + } + }; + + template <typename Iterator> + struct prior : prior_impl<Iterator, Iterator::is_last> + {}; + }; + + namespace result_of + { + template <typename Sequence> + struct pop_back + { + BOOST_MPL_ASSERT_NOT((result_of::empty<Sequence>)); + + typedef pop_back_iterator< + typename begin<Sequence>::type, false> + begin_type; + + typedef pop_back_iterator< + typename end<Sequence>::type, true> + end_type; + + typedef + iterator_range<begin_type, end_type> + type; + }; + } + + template <typename Sequence> + inline typename result_of::pop_back<Sequence const>::type + pop_back(Sequence const& seq) + { + typedef result_of::pop_back<Sequence const> comp; + typedef typename comp::begin_type begin_type; + typedef typename comp::end_type end_type; + typedef typename comp::type result; + + return result( + begin_type(fusion::begin(seq)) + , end_type(fusion::end(seq)) + ); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/pop_front.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/pop_front.hpp new file mode 100644 index 0000000..75e392c --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/pop_front.hpp @@ -0,0 +1,43 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_POP_FRONT_09172005_1115) +#define FUSION_POP_FRONT_09172005_1115 + +#include <boost/fusion/view/iterator_range/iterator_range.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/iterator/next.hpp> + +namespace boost { namespace fusion +{ + namespace result_of + { + template <typename Sequence> + struct pop_front + { + typedef + iterator_range< + typename next< + typename begin<Sequence>::type + >::type + , typename end<Sequence>::type + > + type; + }; + } + + template <typename Sequence> + inline typename result_of::pop_front<Sequence const>::type + pop_front(Sequence const& seq) + { + typedef typename result_of::pop_front<Sequence const>::type result; + return result(fusion::next(fusion::begin(seq)), fusion::end(seq)); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/push_back.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/push_back.hpp new file mode 100644 index 0000000..9afe538 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/push_back.hpp @@ -0,0 +1,46 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_PUSH_BACK_07162005_0235) +#define FUSION_PUSH_BACK_07162005_0235 + +#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 +{ + namespace result_of + { + template <typename Sequence, typename T> + struct push_back + { + typedef fusion::single_view<typename detail::as_fusion_element<T>::type> single_view; + typedef joint_view<Sequence, single_view const> type; + }; + } + + template <typename Sequence, typename T> + inline + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , 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; + typedef typename push_back::single_view single_view; + typedef typename push_back::type result; + single_view x_(x); + return result(seq, x_); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/push_front.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/push_front.hpp new file mode 100644 index 0000000..abe7faa --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/push_front.hpp @@ -0,0 +1,46 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_PUSH_FRONT_07162005_0749) +#define FUSION_PUSH_FRONT_07162005_0749 + +#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 +{ + namespace result_of + { + template <typename Sequence, typename T> + struct push_front + { + typedef fusion::single_view<typename detail::as_fusion_element<T>::type> single_view; + typedef joint_view<single_view const, Sequence> type; + }; + } + + template <typename Sequence, typename T> + inline + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , 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; + typedef typename push_front::single_view single_view; + typedef typename push_front::type result; + single_view x_(x); + return result(x_, seq); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/reverse.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/reverse.hpp new file mode 100644 index 0000000..923b90f --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/reverse.hpp @@ -0,0 +1,39 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_REVERSE_07212005_1230) +#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 +{ + namespace result_of + { + template <typename Sequence> + struct reverse + { + typedef reverse_view<Sequence> type; + }; + } + + template <typename Sequence> + inline + typename + enable_if< + traits::is_sequence<Sequence> + , reverse_view<Sequence const> + >::type + reverse(Sequence const& view) + { + return reverse_view<Sequence const>(view); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/algorithm/transformation/transform.hpp b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/transform.hpp new file mode 100644 index 0000000..85e8561 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/algorithm/transformation/transform.hpp @@ -0,0 +1,51 @@ +/*============================================================================= + 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) +==============================================================================*/ +#if !defined(FUSION_TRANSFORM_07052005_1057) +#define FUSION_TRANSFORM_07052005_1057 + +#include <boost/fusion/view/transform_view/transform_view.hpp> + +namespace boost { namespace fusion +{ + struct void_; + + namespace result_of + { + template <typename Sequence1, typename Sequence2, typename F = void_> + struct transform + { + typedef transform_view<Sequence1, Sequence2, F> type; + }; + + template <typename Sequence, typename F> +#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS) + struct transform<Sequence, F, void_> +#else + struct transform<Sequence, F> +#endif + { + typedef transform_view<Sequence, F> type; + }; + } + + template <typename Sequence, typename F> + inline typename result_of::transform<Sequence const, F>::type + transform(Sequence const& seq, F f) + { + return transform_view<Sequence const, F>(seq, f); + } + + template <typename Sequence1, typename Sequence2, typename F> + inline typename result_of::transform<Sequence1 const, Sequence2 const, F>::type + transform(Sequence1 const& seq1, Sequence2 const& seq2, F f) + { + return transform_view<Sequence1 const, Sequence2 const, F>(seq1, seq2, f); + } +}} + +#endif + |