summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorKevin Smith <git@kismith.co.uk>2013-01-12 18:41:34 (GMT)
committerSwift Review <review@swift.im>2013-01-13 10:36:26 (GMT)
commitf3bc816af1b0d61452de973963e453bf3b3f95a2 (patch)
treee895f8afa3580e6cff6f5ad2017d45bf147a17c2 /3rdParty/Boost/src/boost/fusion/algorithm
parent188fc285c6555eadd3c9d50ab8a94adcade78d89 (diff)
downloadswift-f3bc816af1b0d61452de973963e453bf3b3f95a2.zip
swift-f3bc816af1b0d61452de973963e453bf3b3f95a2.tar.bz2
Adding in the spirit Boost stuff
Change-Id: I4f127ce61667243b64081b0aa309028d5077045f
Diffstat (limited to '3rdParty/Boost/src/boost/fusion/algorithm')
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/auxiliary/copy.hpp84
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/fold.hpp462
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/for_each.hpp138
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp381
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp380
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp59
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp48
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/fold.hpp63
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/fold_fwd.hpp52
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/for_each.hpp53
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/for_each_fwd.hpp40
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/reverse_fold.hpp64
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp52
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/query/any.hpp35
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/query/detail/any.hpp130
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/query/detail/find_if.hpp252
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/query/detail/segmented_find.hpp90
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/query/find.hpp69
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/query/find_fwd.hpp34
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/query/find_if_fwd.hpp35
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/erase.hpp135
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/erase_key.hpp34
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/filter_if.hpp32
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/insert.hpp69
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/insert_range.hpp55
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/pop_back.hpp166
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/pop_front.hpp43
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/push_back.hpp46
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/push_front.hpp46
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/reverse.hpp39
-rw-r--r--3rdParty/Boost/src/boost/fusion/algorithm/transformation/transform.hpp51
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
+