Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/fusion/sequence')
24 files changed, 1615 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/fusion/sequence/comparison/detail/equal_to.hpp b/3rdParty/Boost/src/boost/fusion/sequence/comparison/detail/equal_to.hpp new file mode 100644 index 0000000..56cfe1b --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/comparison/detail/equal_to.hpp @@ -0,0 +1,61 @@ +/*============================================================================= + Copyright (c) 1999-2003 Jaakko Jarvi + 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_EQUAL_TO_05052005_1142) +#define FUSION_EQUAL_TO_05052005_1142 + +#include <boost/mpl/bool.hpp> +#include <boost/fusion/iterator/deref.hpp> +#include <boost/fusion/iterator/next.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/support/as_const.hpp> + +namespace boost { namespace fusion { namespace detail +{ + template <typename Seq1, typename Seq2, bool same_size> + struct sequence_equal_to + { + typedef typename result_of::end<Seq1>::type end1_type; + typedef typename result_of::end<Seq2>::type end2_type; + + template <typename I1, typename I2> + static bool + call(I1 const&, I2 const&, mpl::true_) + { + return true; + } + + template <typename I1, typename I2> + static bool + call(I1 const& a, I2 const& b, mpl::false_) + { + return extension::as_const(*a) == extension::as_const(*b) + && call(fusion::next(a), fusion::next(b)); + } + + template <typename I1, typename I2> + static bool + call(I1 const& a, I2 const& b) + { + typename result_of::equal_to<I1, end1_type>::type eq; + return call(a, b, eq); + } + }; + + template <typename Seq1, typename Seq2> + struct sequence_equal_to<Seq1, Seq2, false> + { + template <typename I1, typename I2> + static bool + call(I1 const& /*a*/, I2 const& /*b*/) + { + return false; + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/comparison/enable_comparison.hpp b/3rdParty/Boost/src/boost/fusion/sequence/comparison/enable_comparison.hpp new file mode 100644 index 0000000..bd55ac3 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/comparison/enable_comparison.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_ENABLE_COMPARISON_09232005_1958) +#define FUSION_ENABLE_COMPARISON_09232005_1958 + +#include <boost/mpl/or.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/not.hpp> +#include <boost/mpl/equal_to.hpp> +#include <boost/fusion/support/sequence_base.hpp> +#include <boost/fusion/support/is_sequence.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> + +namespace boost { namespace fusion { namespace traits +{ + template <typename Seq1, typename Seq2, typename Enable = void> + struct enable_equality + : mpl::or_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> > + {}; + + template <typename Seq1, typename Seq2, typename Enable = void> + struct enable_comparison + : mpl::and_< + mpl::or_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> > + , mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> > + > + {}; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/convert.hpp b/3rdParty/Boost/src/boost/fusion/sequence/convert.hpp new file mode 100644 index 0000000..5264810 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/convert.hpp @@ -0,0 +1,48 @@ +/*============================================================================= + 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_CONVERT_10022005_1442) +#define FUSION_CONVERT_10022005_1442 + +namespace boost { namespace fusion +{ + namespace extension + { + template <typename Tag> + struct convert_impl; + } + + namespace result_of + { + template <typename Tag, typename Sequence> + struct convert + { + typedef typename extension::convert_impl<Tag> gen; + + typedef typename + gen::template apply<Sequence>::type + type; + }; + } + + template <typename Tag, typename Sequence> + inline typename result_of::convert<Tag, Sequence>::type + convert(Sequence& seq) + { + typedef typename result_of::convert<Tag, Sequence>::gen gen; + return gen::call(seq); + } + + template <typename Tag, typename Sequence> + inline typename result_of::convert<Tag, Sequence const>::type + convert(Sequence const& seq) + { + typedef typename result_of::convert<Tag, Sequence const>::gen gen; + return gen::call(seq); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic.hpp new file mode 100644 index 0000000..7da2cf0 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic.hpp @@ -0,0 +1,23 @@ +/*============================================================================= + 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_SEQUENCE_INTRINSIC_10022005_0618) +#define FUSION_SEQUENCE_INTRINSIC_10022005_0618 + +#include <boost/fusion/sequence/intrinsic/at.hpp> +#include <boost/fusion/sequence/intrinsic/back.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/empty.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/sequence/intrinsic/front.hpp> +#include <boost/fusion/sequence/intrinsic/has_key.hpp> +#include <boost/fusion/sequence/intrinsic/segments.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/fusion/sequence/intrinsic/value_at.hpp> +#include <boost/fusion/sequence/intrinsic/at_key.hpp> +#include <boost/fusion/sequence/intrinsic/value_at_key.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at.hpp new file mode 100644 index 0000000..92da7bb --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at.hpp @@ -0,0 +1,111 @@ +/*============================================================================= + 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_AT_05042005_0722) +#define FUSION_AT_05042005_0722 + +#include <boost/mpl/int.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/support/tag_of.hpp> +#include <boost/fusion/support/detail/access.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; + struct boost_tuple_tag; // boost::tuples::tuple tag + struct boost_array_tag; // boost::array tag + struct mpl_sequence_tag; // mpl sequence tag + struct std_pair_tag; // std::pair tag + struct std_tuple_tag; // std::tuple tag + + namespace extension + { + template <typename Tag> + struct at_impl + { + template <typename Sequence, typename N> + struct apply; + }; + + template <> + struct at_impl<sequence_facade_tag> + { + template <typename Sequence, typename N> + struct apply : Sequence::template at<Sequence, N> {}; + }; + + template <> + struct at_impl<boost_tuple_tag>; + + template <> + struct at_impl<boost_array_tag>; + + template <> + struct at_impl<mpl_sequence_tag>; + + template <> + struct at_impl<std_pair_tag>; + + template <> + struct at_impl<std_tuple_tag>; + } + + namespace result_of + { + template <typename Sequence, typename N> + struct at + : extension::at_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence, N> + {}; + + template <typename Sequence, int N> + struct at_c + : at<Sequence, mpl::int_<N> > + {}; + } + + + template <typename N, typename Sequence> + inline typename + lazy_disable_if< + is_const<Sequence> + , result_of::at<Sequence, N> + >::type + at(Sequence& seq) + { + return result_of::at<Sequence, N>::call(seq); + } + + template <typename N, typename Sequence> + inline typename result_of::at<Sequence const, N>::type + at(Sequence const& seq) + { + return result_of::at<Sequence const, N>::call(seq); + } + + template <int N, typename Sequence> + inline typename + lazy_disable_if< + is_const<Sequence> + , result_of::at_c<Sequence, N> + >::type + at_c(Sequence& seq) + { + return fusion::at<mpl::int_<N> >(seq); + } + + template <int N, typename Sequence> + inline typename result_of::at_c<Sequence const, N>::type + at_c(Sequence const& seq) + { + return fusion::at<mpl::int_<N> >(seq); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at_c.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at_c.hpp new file mode 100644 index 0000000..449e3f4 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at_c.hpp @@ -0,0 +1,13 @@ +/*============================================================================= + 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_AT_C_08252008_0308) +#define FUSION_AT_C_08252008_0308 + +#include <boost/fusion/sequence/intrinsic/at.hpp> + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at_key.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at_key.hpp new file mode 100644 index 0000000..24c2fff --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/at_key.hpp @@ -0,0 +1,93 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2006 Dan Marsden + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(BOOST_FUSION_AT_KEY_20060304_1755) +#define BOOST_FUSION_AT_KEY_20060304_1755 + +#include <boost/type_traits/is_const.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/algorithm/query/find.hpp> +#include <boost/fusion/iterator/deref_data.hpp> +#include <boost/fusion/support/tag_of.hpp> +#include <boost/fusion/support/detail/access.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; + struct boost_array_tag; // boost::array tag + struct mpl_sequence_tag; // mpl sequence tag + struct std_pair_tag; // std::pair tag + + namespace extension + { + template <typename Tag> + struct at_key_impl + { + template <typename Seq, typename Key> + struct apply + { + typedef typename + result_of::deref_data< + typename result_of::find<Seq, Key>::type + >::type + type; + + static type + call(Seq& seq) + { + return fusion::deref_data(fusion::find<Key>(seq)); + } + }; + }; + + template <> + struct at_key_impl<sequence_facade_tag> + { + template <typename Sequence, typename Key> + struct apply : Sequence::template at_key_impl<Sequence, Key> {}; + }; + + template <> + struct at_key_impl<boost_array_tag>; + + template <> + struct at_key_impl<mpl_sequence_tag>; + + template <> + struct at_key_impl<std_pair_tag>; + } + + namespace result_of + { + template <typename Sequence, typename Key> + struct at_key + : extension::at_key_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence, Key> + {}; + } + + template <typename Key, typename Sequence> + inline typename + lazy_disable_if< + is_const<Sequence> + , result_of::at_key<Sequence, Key> + >::type + at_key(Sequence& seq) + { + return result_of::at_key<Sequence, Key>::call(seq); + } + + template <typename Key, typename Sequence> + inline typename result_of::at_key<Sequence const, Key>::type + at_key(Sequence const& seq) + { + return result_of::at_key<Sequence const, Key>::call(seq); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/back.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/back.hpp new file mode 100644 index 0000000..0a4d482 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/back.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_BACK_09162005_0350) +#define FUSION_BACK_09162005_0350 + +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/iterator/prior.hpp> +#include <boost/fusion/iterator/deref.hpp> +#include <boost/mpl/bool.hpp> + +namespace boost { namespace fusion +{ + struct fusion_sequence_tag; + + namespace result_of + { + template <typename Sequence> + struct back + : result_of::deref<typename result_of::prior<typename result_of::end<Sequence>::type>::type> + {}; + } + + template <typename Sequence> + inline typename result_of::back<Sequence>::type + back(Sequence& seq) + { + return *fusion::prior(fusion::end(seq)); + } + + template <typename Sequence> + inline typename result_of::back<Sequence const>::type + back(Sequence const& seq) + { + return *fusion::prior(fusion::end(seq)); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/begin.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/begin.hpp new file mode 100644 index 0000000..7a7ecf6 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/begin.hpp @@ -0,0 +1,95 @@ +/*============================================================================= + 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_BEGIN_04052005_1132) +#define FUSION_BEGIN_04052005_1132 + +#include <boost/blank.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/mpl/if.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/support/tag_of.hpp> +#include <boost/fusion/support/is_sequence.hpp> +#include <boost/fusion/support/is_segmented.hpp> +#include <boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; // iterator facade tag + struct boost_tuple_tag; // boost::tuples::tuple tag + struct boost_array_tag; // boost::array tag + struct mpl_sequence_tag; // mpl sequence tag + struct std_pair_tag; // std::pair tag + + namespace extension + { + template <typename Tag> + struct begin_impl + { + template <typename Sequence> + struct apply + : mpl::if_< + traits::is_segmented<Sequence> + , detail::segmented_begin<Sequence> + , blank + >::type + {}; + }; + + template <> + struct begin_impl<sequence_facade_tag> + { + template <typename Sequence> + struct apply : Sequence::template begin<Sequence> {}; + }; + + template <> + struct begin_impl<boost_tuple_tag>; + + template <> + struct begin_impl<boost_array_tag>; + + template <> + struct begin_impl<mpl_sequence_tag>; + + template <> + struct begin_impl<std_pair_tag>; + } + + namespace result_of + { + template <typename Sequence> + struct begin + : extension::begin_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence> + {}; + } + + template <typename Sequence> + inline typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::begin<Sequence> + >::type const + begin(Sequence& seq) + { + return result_of::begin<Sequence>::call(seq); + } + + template <typename Sequence> + inline typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::begin<Sequence const> + >::type const + begin(Sequence const& seq) + { + return result_of::begin<Sequence const>::call(seq); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp new file mode 100644 index 0000000..968718e --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp @@ -0,0 +1,43 @@ +/*============================================================================= + 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_BEGIN_HPP_INCLUDED) +#define BOOST_FUSION_SEGMENTED_BEGIN_HPP_INCLUDED + +#include <boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp> +#include <boost/fusion/iterator/segmented_iterator.hpp> +#include <boost/fusion/view/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/container/list/cons.hpp> + +namespace boost { namespace fusion { namespace detail +{ + //auto segmented_begin( seq ) + //{ + // return make_segmented_iterator( segmented_begin_impl( seq, nil ) ); + //} + + template <typename Sequence, typename Nil = fusion::nil> + struct segmented_begin + { + typedef + segmented_iterator< + typename segmented_begin_impl<Sequence, Nil>::type + > + type; + + static type call(Sequence& seq) + { + return type( + segmented_begin_impl<Sequence, Nil>::call(seq, Nil())); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp new file mode 100644 index 0000000..5069432 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp @@ -0,0 +1,92 @@ +/*============================================================================= + 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_BEGIN_IMPL_HPP_INCLUDED) +#define BOOST_FUSION_SEGMENTED_BEGIN_IMPL_HPP_INCLUDED + +#include <boost/type_traits/remove_const.hpp> +#include <boost/fusion/container/list/cons_fwd.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/support/is_segmented.hpp> +#include <boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp> +#include <boost/fusion/support/detail/segmented_fold_until_impl.hpp> + +namespace boost { namespace fusion +{ + template <typename First, typename Last> + struct iterator_range; +}} + +namespace boost { namespace fusion { namespace detail +{ + struct segmented_begin_fun + { + template <typename Sequence, typename State, typename Context> + struct apply + { + typedef + iterator_range< + typename fusion::result_of::begin<Sequence>::type + , typename fusion::result_of::end<Sequence>::type + > + range_type; + + typedef cons<range_type, Context> type; + typedef mpl::false_ continue_type; + + static type call(Sequence& seq, State const&, Context const& context, segmented_begin_fun) + { + return type(range_type(fusion::begin(seq), fusion::end(seq)), context); + } + }; + }; + + template <typename Sequence, typename Stack, bool IsSegmented = traits::is_segmented<Sequence>::type::value> + struct segmented_begin_impl_aux + { + typedef + segmented_end_impl<Sequence, Stack> + end_impl; + + typedef + segmented_fold_until_impl< + Sequence + , typename end_impl::type + , Stack + , segmented_begin_fun + > + fold_impl; + + typedef typename fold_impl::type type; + + static type call(Sequence& seq, Stack const& stack) + { + return fold_impl::call(seq, end_impl::call(seq, stack), stack, segmented_begin_fun()); + } + }; + + template <typename Sequence, typename Stack> + struct segmented_begin_impl_aux<Sequence, Stack, false> + { + typedef typename result_of::begin<Sequence>::type begin_type; + typedef typename result_of::end<Sequence>::type end_type; + typedef iterator_range<begin_type, end_type> pair_type; + typedef cons<pair_type, Stack> type; + + static type call(Sequence& seq, Stack stack) + { + return type(pair_type(fusion::begin(seq), fusion::end(seq)), stack); + } + }; + + template <typename Sequence, typename Stack> + struct segmented_begin_impl + : segmented_begin_impl_aux<Sequence, Stack> + {}; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp new file mode 100644 index 0000000..469862a --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp @@ -0,0 +1,39 @@ +/*============================================================================= + 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_END_HPP_INCLUDED) +#define BOOST_FUSION_SEGMENTED_END_HPP_INCLUDED + +#include <boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp> +#include <boost/fusion/iterator/segmented_iterator.hpp> +#include <boost/fusion/container/list/cons.hpp> + +namespace boost { namespace fusion { namespace detail +{ + //auto segmented_end( seq ) + //{ + // return make_segmented_iterator( segmented_end_impl( seq ) ); + //} + + template <typename Sequence, typename Nil = fusion::nil> + struct segmented_end + { + typedef + segmented_iterator< + typename segmented_end_impl<Sequence, Nil>::type + > + type; + + static type call(Sequence & seq) + { + return type( + segmented_end_impl<Sequence, Nil>::call(seq, Nil())); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp new file mode 100644 index 0000000..149027b --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.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_SEGMENTED_END_IMPL_HPP_INCLUDED) +#define BOOST_FUSION_SEGMENTED_END_IMPL_HPP_INCLUDED + +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/container/list/cons_fwd.hpp> +#include <boost/fusion/support/is_segmented.hpp> + +namespace boost { namespace fusion +{ + template <typename First, typename Last> + struct iterator_range; +}} + +namespace boost { namespace fusion { namespace detail +{ + //auto segmented_end_impl( seq, stack ) + //{ + // assert(is_segmented(seq)); + // auto it = end(segments(seq)); + // return cons(iterator_range(it, it), stack); + //} + + template <typename Sequence, typename Stack> + struct segmented_end_impl + { + BOOST_MPL_ASSERT((traits::is_segmented<Sequence>)); + + typedef + typename result_of::end< + typename remove_reference< + typename add_const< + typename result_of::segments<Sequence>::type + >::type + >::type + >::type + end_type; + + typedef iterator_range<end_type, end_type> pair_type; + typedef cons<pair_type, Stack> type; + + static type call(Sequence & seq, Stack stack) + { + end_type end = fusion::end(fusion::segments(seq)); + return type(pair_type(end, end), stack); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp new file mode 100644 index 0000000..03cef28 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp @@ -0,0 +1,54 @@ +/*============================================================================= + 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_SIZE_08112006_1141) +#define BOOST_FUSION_SEGMENTED_SIZE_08112006_1141 + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/mpl/fold.hpp> +#include <boost/mpl/plus.hpp> +#include <boost/mpl/size_t.hpp> +#include <boost/mpl/placeholders.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/mpl/begin.hpp> +#include <boost/fusion/mpl/end.hpp> +#include <boost/fusion/support/is_segmented.hpp> + +namespace boost { namespace fusion { namespace detail +{ + /////////////////////////////////////////////////////////////////////////// + // calculates the size of any segmented data structure. + template<typename Sequence> + struct segmented_size; + + /////////////////////////////////////////////////////////////////////////// + template<typename Sequence, bool IsSegmented = traits::is_segmented<Sequence>::value> + struct segmented_size_impl + : mpl::fold< + typename remove_reference< + typename add_const< + typename result_of::segments<Sequence>::type + >::type + >::type + , mpl::size_t<0> + , mpl::plus<mpl::_1, segmented_size<remove_reference<mpl::_2> > > + >::type + {}; + + template<typename Sequence> + struct segmented_size_impl<Sequence, false> + : result_of::size<Sequence>::type + {}; + + template<typename Sequence> + struct segmented_size + : segmented_size_impl<Sequence> + {}; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/empty.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/empty.hpp new file mode 100644 index 0000000..a9928ab --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/empty.hpp @@ -0,0 +1,61 @@ +/*============================================================================= + 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_EMPTY_09162005_0335) +#define FUSION_EMPTY_09162005_0335 + +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/fusion/support/tag_of.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; + struct mpl_sequence_tag; // mpl sequence tag + + namespace extension + { + template <typename Tag> + struct empty_impl + { + template <typename Sequence> + struct apply + : mpl::bool_<(result_of::size<Sequence>::value == 0)> + {}; + }; + + template <> + struct empty_impl<sequence_facade_tag> + { + template <typename Sequence> + struct apply : Sequence::template empty<Sequence> {}; + }; + + template <> + struct empty_impl<mpl_sequence_tag>; + } + + namespace result_of + { + template <typename Sequence> + struct empty + : extension::empty_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence> + {}; + } + + template <typename Sequence> + inline typename result_of::empty<Sequence>::type + empty(Sequence const&) + { + typedef typename result_of::empty<Sequence>::type result; + return result(); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/end.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/end.hpp new file mode 100644 index 0000000..995ed7a --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/end.hpp @@ -0,0 +1,95 @@ +/*============================================================================= + 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_END_04052005_1141) +#define FUSION_END_04052005_1141 + +#include <boost/blank.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/mpl/if.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/support/tag_of.hpp> +#include <boost/fusion/support/is_sequence.hpp> +#include <boost/fusion/support/is_segmented.hpp> +#include <boost/fusion/sequence/intrinsic/detail/segmented_end.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; + struct boost_tuple_tag; // boost::tuples::tuple tag + struct boost_array_tag; // boost::array tag + struct mpl_sequence_tag; // mpl sequence tag + struct std_pair_tag; // std::pair tag + + namespace extension + { + template <typename Tag> + struct end_impl + { + template <typename Sequence> + struct apply + : mpl::if_< + traits::is_segmented<Sequence> + , detail::segmented_end<Sequence> + , blank + >::type + {}; + }; + + template <> + struct end_impl<sequence_facade_tag> + { + template <typename Sequence> + struct apply : Sequence::template end<Sequence> {}; + }; + + template <> + struct end_impl<boost_tuple_tag>; + + template <> + struct end_impl<boost_array_tag>; + + template <> + struct end_impl<mpl_sequence_tag>; + + template <> + struct end_impl<std_pair_tag>; + } + + namespace result_of + { + template <typename Sequence> + struct end + : extension::end_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence> + {}; + } + + template <typename Sequence> + inline typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::end<Sequence> + >::type const + end(Sequence& seq) + { + return result_of::end<Sequence>::call(seq); + } + + template <typename Sequence> + inline typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::end<Sequence const> + >::type const + end(Sequence const& seq) + { + return result_of::end<Sequence const>::call(seq); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/front.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/front.hpp new file mode 100644 index 0000000..0e50e3c --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/front.hpp @@ -0,0 +1,42 @@ +/*============================================================================= + 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_FRONT_09162005_0343) +#define FUSION_FRONT_09162005_0343 + +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/iterator/deref.hpp> +#include <boost/mpl/bool.hpp> + +namespace boost { namespace fusion +{ + struct fusion_sequence_tag; + + namespace result_of + { + template <typename Sequence> + struct front + : result_of::deref<typename result_of::begin<Sequence>::type> + {}; + } + + template <typename Sequence> + inline typename result_of::front<Sequence>::type + front(Sequence& seq) + { + return *fusion::begin(seq); + } + + template <typename Sequence> + inline typename result_of::front<Sequence const>::type + front(Sequence const& seq) + { + return *fusion::begin(seq); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/has_key.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/has_key.hpp new file mode 100644 index 0000000..9e0969a --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/has_key.hpp @@ -0,0 +1,79 @@ +/*============================================================================= + 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_HAS_KEY_09232005_1454) +#define FUSION_HAS_KEY_09232005_1454 + +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/support/tag_of.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/algorithm/query/find.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/mpl/not.hpp> + +namespace boost { namespace fusion +{ + struct void_; + + // Special tags: + struct sequence_facade_tag; + struct boost_array_tag; // boost::array tag + struct mpl_sequence_tag; // mpl sequence tag + struct std_pair_tag; // std::pair tag + + namespace extension + { + template <typename Tag> + struct has_key_impl + { + template <typename Seq, typename Key> + struct apply + : mpl::not_< + typename result_of::equal_to< + typename result_of::find<Seq, Key>::type + , typename result_of::end<Seq>::type + >::type + >::type + {}; + }; + + template <> + struct has_key_impl<sequence_facade_tag> + { + template <typename Sequence, typename Key> + struct apply : Sequence::template has_key<Sequence, Key> {}; + }; + + template <> + struct has_key_impl<boost_array_tag>; + + template <> + struct has_key_impl<mpl_sequence_tag>; + + template <> + struct has_key_impl<std_pair_tag>; + } + + namespace result_of + { + template <typename Sequence, typename Key> + struct has_key + : extension::has_key_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence, Key> + {}; + } + + template <typename Key, typename Sequence> + inline typename result_of::has_key<Sequence, Key>::type + has_key(Sequence const&) + { + typedef typename result_of::has_key<Sequence, Key>::type result; + return result(); + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/segments.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/segments.hpp new file mode 100644 index 0000000..afd5d40 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/segments.hpp @@ -0,0 +1,76 @@ +/*============================================================================= + Copyright (c) 2006 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_SEGMENTS_04052005_1141) +#define BOOST_FUSION_SEGMENTS_04052005_1141 + +#include <boost/type_traits/is_const.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/support/tag_of.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; + struct iterator_range_tag; + + // segments: returns a sequence of sequences + namespace extension + { + template <typename Tag> + struct segments_impl + { + template <typename Sequence> + struct apply {}; + }; + + template <> + struct segments_impl<sequence_facade_tag> + { + template <typename Sequence> + struct apply : Sequence::template segments<Sequence> {}; + }; + + template <> + struct segments_impl<iterator_range_tag>; + } + + namespace result_of + { + template <typename Sequence> + struct segments + { + typedef typename traits::tag_of<Sequence>::type tag_type; + + typedef typename + extension::segments_impl<tag_type>::template apply<Sequence>::type + type; + }; + } + + template <typename Sequence> + inline typename + lazy_disable_if< + is_const<Sequence> + , result_of::segments<Sequence> + >::type + segments(Sequence& seq) + { + typedef typename traits::tag_of<Sequence>::type tag_type; + return extension::segments_impl<tag_type>::template apply<Sequence>::call(seq); + } + + template <typename Sequence> + inline typename result_of::segments<Sequence const>::type + segments(Sequence const& seq) + { + typedef typename traits::tag_of<Sequence const>::type tag_type; + return extension::segments_impl<tag_type>::template apply<Sequence const>::call(seq); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/size.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/size.hpp new file mode 100644 index 0000000..0a1c165 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/size.hpp @@ -0,0 +1,88 @@ +/*============================================================================= + 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_SIZE_05052005_0214) +#define FUSION_SIZE_05052005_0214 + +#include <boost/utility/enable_if.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/int.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/support/tag_of.hpp> +#include <boost/fusion/support/is_segmented.hpp> +#include <boost/fusion/sequence/intrinsic/detail/segmented_size.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; + struct boost_tuple_tag; // boost::tuples::tuple tag + struct boost_array_tag; // boost::array tag + struct mpl_sequence_tag; // mpl sequence tag + struct std_pair_tag; // std::pair tag + + namespace extension + { + template <typename Tag> + struct size_impl + { + template<typename Sequence> + struct unsegmented_size : Sequence::size {}; + + template <typename Sequence> + struct apply + : mpl::if_< + traits::is_segmented<Sequence> + , detail::segmented_size<Sequence> + , unsegmented_size<Sequence> + >::type + {}; + }; + + template <> + struct size_impl<sequence_facade_tag> + { + template <typename Sequence> + struct apply : Sequence::template size<Sequence> {}; + }; + + template <> + struct size_impl<boost_tuple_tag>; + + template <> + struct size_impl<boost_array_tag>; + + template <> + struct size_impl<mpl_sequence_tag>; + + template <> + struct size_impl<std_pair_tag>; + } + + namespace result_of + { + template <typename Sequence> + struct size + : extension::size_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence> + + { + typedef typename extension::size_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence>::type size_application; + BOOST_STATIC_CONSTANT(int, value = size_application::value); + }; + } + + template <typename Sequence> + inline typename result_of::size<Sequence>::type + size(Sequence const&) + { + typedef typename result_of::size<Sequence>::type result; + return result(); + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/value_at.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/value_at.hpp new file mode 100644 index 0000000..ce314a8 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/value_at.hpp @@ -0,0 +1,68 @@ +/*============================================================================= + 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_VALUE_AT_05052005_0229) +#define FUSION_VALUE_AT_05052005_0229 + +#include <boost/mpl/int.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/support/tag_of.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; + struct boost_tuple_tag; // boost::tuples::tuple tag + struct boost_array_tag; // boost::array tag + struct mpl_sequence_tag; // mpl sequence tag + struct std_pair_tag; // std::pair tag + + namespace extension + { + template <typename Tag> + struct value_at_impl + { + template <typename Sequence, typename N> + struct apply; + }; + + template <> + struct value_at_impl<sequence_facade_tag> + { + template <typename Sequence, typename N> + struct apply : Sequence::template value_at<Sequence, N> {}; + }; + + template <> + struct value_at_impl<boost_tuple_tag>; + + template <> + struct value_at_impl<boost_array_tag>; + + template <> + struct value_at_impl<mpl_sequence_tag>; + + template <> + struct value_at_impl<std_pair_tag>; + } + + namespace result_of + { + template <typename Sequence, typename N> + struct value_at + : extension::value_at_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence, N> + {}; + + template <typename Sequence, int N> + struct value_at_c + : fusion::result_of::value_at<Sequence, mpl::int_<N> > + {}; + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/value_at_key.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/value_at_key.hpp new file mode 100644 index 0000000..23d34ee --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic/value_at_key.hpp @@ -0,0 +1,66 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2006 Dan Marsden + + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ +#if !defined(FUSION_VALUE_AT_KEY_05052005_0229) +#define FUSION_VALUE_AT_KEY_05052005_0229 + +#include <boost/mpl/int.hpp> +#include <boost/fusion/sequence/intrinsic_fwd.hpp> +#include <boost/fusion/iterator/value_of_data.hpp> +#include <boost/fusion/algorithm/query/find.hpp> +#include <boost/fusion/support/tag_of.hpp> + +namespace boost { namespace fusion +{ + // Special tags: + struct sequence_facade_tag; + struct boost_array_tag; // boost::array tag + struct mpl_sequence_tag; // mpl sequence tag + struct std_pair_tag; // std::pair tag + + namespace extension + { + template <typename Tag> + struct value_at_key_impl + { + template <typename Seq, typename Key> + struct apply + : result_of::value_of_data< + typename result_of::find<Seq, Key>::type + > + {}; + }; + + template <> + struct value_at_key_impl<sequence_facade_tag> + { + template <typename Sequence, typename Key> + struct apply : Sequence::template value_at_key<Sequence, Key> {}; + }; + + template <> + struct value_at_key_impl<boost_array_tag>; + + template <> + struct value_at_key_impl<mpl_sequence_tag>; + + template <> + struct value_at_key_impl<std_pair_tag>; + } + + namespace result_of + { + template <typename Sequence, typename N> + struct value_at_key + : extension::value_at_key_impl<typename detail::tag_of<Sequence>::type>:: + template apply<Sequence, N> + {}; + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/sequence/intrinsic_fwd.hpp b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic_fwd.hpp new file mode 100644 index 0000000..57409a3 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/intrinsic_fwd.hpp @@ -0,0 +1,203 @@ +/*============================================================================= + 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(BOOST_FUSION_SEQUENCE_INTRINSIC_FWD_HPP_INCLUDED) +#define BOOST_FUSION_SEQUENCE_INTRINSIC_FWD_HPP_INCLUDED + +#include <boost/type_traits/is_const.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/fusion/support/is_sequence.hpp> + +namespace boost { namespace fusion +{ + namespace extension + { + template <typename Tag> + struct at_impl; + + template <typename Tag> + struct begin_impl; + + template <typename Tag> + struct empty_impl; + + template <typename Tag> + struct end_impl; + + template <typename Tag> + struct has_key_impl; + + template <typename Tag> + struct segments_impl; + + template <typename Tag> + struct size_impl; + + template <typename Tag> + struct value_at_impl; + + template <typename Tag> + struct at_key_impl; + + template <typename Tag> + struct value_at_key_impl; + } + + namespace result_of + { + template <typename Sequence, typename N> + struct at; + + template <typename Sequence, int N> + struct at_c; + + template <typename Sequence> + struct back; + + template <typename Sequence> + struct begin; + + template <typename Sequence> + struct empty; + + template <typename Sequence> + struct end; + + template <typename Sequence> + struct front; + + template <typename Sequence, typename Key> + struct has_key; + + template <typename Sequence> + struct segments; + + template <typename Sequence> + struct size; + + template <typename Sequence, typename N> + struct value_at; + + template <typename Sequence, int N> + struct value_at_c; + + template <typename Sequence, typename Key> + struct at_key; + + template <typename Sequence, typename N> + struct value_at_key; + } + + template <typename N, typename Sequence> + typename + lazy_disable_if< + is_const<Sequence> + , result_of::at<Sequence, N> + >::type + at(Sequence& seq); + + template <typename N, typename Sequence> + typename result_of::at<Sequence const, N>::type + at(Sequence const& seq); + + template <int N, typename Sequence> + typename + lazy_disable_if< + is_const<Sequence> + , result_of::at_c<Sequence, N> + >::type + at_c(Sequence& seq); + + template <int N, typename Sequence> + typename result_of::at_c<Sequence const, N>::type + at_c(Sequence const& seq); + + template <typename Sequence> + typename result_of::back<Sequence>::type + back(Sequence& seq); + + template <typename Sequence> + typename result_of::back<Sequence const>::type + back(Sequence const& seq); + + template <typename Sequence> + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::begin<Sequence> + >::type const + begin(Sequence& seq); + + template <typename Sequence> + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::begin<Sequence const> + >::type const + begin(Sequence const& seq); + + template <typename Sequence> + typename result_of::empty<Sequence>::type + empty(Sequence const&); + + template <typename Sequence> + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::end<Sequence> + >::type const + end(Sequence& seq); + + template <typename Sequence> + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::end<Sequence const> + >::type const + end(Sequence const& seq); + + template <typename Sequence> + typename result_of::front<Sequence>::type + front(Sequence& seq); + + template <typename Sequence> + typename result_of::front<Sequence const>::type + front(Sequence const& seq); + + template <typename Key, typename Sequence> + typename result_of::has_key<Sequence, Key>::type + has_key(Sequence const& seq); + + template <typename Sequence> + typename + lazy_disable_if< + is_const<Sequence> + , result_of::segments<Sequence> + >::type + segments(Sequence& seq); + + template <typename Sequence> + typename result_of::segments<Sequence const>::type + segments(Sequence const& seq); + + template <typename Sequence> + typename result_of::size<Sequence>::type + size(Sequence const&); + + template <typename Key, typename Sequence> + typename + lazy_disable_if< + is_const<Sequence> + , result_of::at_key<Sequence, Key> + >::type + at_key(Sequence& seq); + + template <typename Key, typename Sequence> + typename result_of::at_key<Sequence const, Key>::type + at_key(Sequence const& seq); +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/sequence/sequence_facade.hpp b/3rdParty/Boost/src/boost/fusion/sequence/sequence_facade.hpp new file mode 100644 index 0000000..fd6b095 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/sequence/sequence_facade.hpp @@ -0,0 +1,29 @@ +/*============================================================================= + 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_SEQUENCE_FACADE_09252006_1044) +#define FUSION_SEQUENCE_FACADE_09252006_1044 + +#include <boost/fusion/support/sequence_base.hpp> +#include <boost/mpl/bool.hpp> + +namespace boost { namespace fusion +{ + struct sequence_facade_tag; + + template <typename Derived, typename Category, typename IsView = mpl::false_> + struct sequence_facade : sequence_base<Derived> + { + typedef fusion_sequence_tag tag; + typedef sequence_facade_tag fusion_tag; + typedef Derived derived_type; + typedef Category category; + typedef IsView is_view; + typedef mpl::false_ is_segmented; + }; +}} + +#endif |