Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/fusion/view/iterator_range')
9 files changed, 908 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/at_impl.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/at_impl.hpp new file mode 100644 index 0000000..1b42523 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/at_impl.hpp @@ -0,0 +1,44 @@ +/*============================================================================= + Copyright (c) 2007 Tobias Schwinger + + 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_ITERATOR_RANGE_AT_IMPL_HPP_INCLUDED) +#define BOOST_FUSION_ITERATOR_RANGE_AT_IMPL_HPP_INCLUDED + +#include <boost/fusion/iterator/advance.hpp> +#include <boost/fusion/iterator/deref.hpp> + +namespace boost { namespace fusion +{ + struct iterator_range_tag; + + namespace extension + { + template <typename Tag> + struct at_impl; + + template <> + struct at_impl<iterator_range_tag> + { + template <typename Seq, typename N> + struct apply + { + typedef typename Seq::begin_type begin_type; + typedef typename result_of::advance<begin_type,N>::type pos; + typedef typename result_of::deref<pos>::type type; + + static type + call(Seq& s) + { + return * fusion::advance<N>(s.first); + } + }; + }; + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/begin_impl.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/begin_impl.hpp new file mode 100644 index 0000000..2902e73 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/begin_impl.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_BEGIN_IMPL_05062005_1226) +#define FUSION_BEGIN_IMPL_05062005_1226 + +namespace boost { namespace fusion +{ + struct iterator_range_tag; + + namespace extension + { + template <typename Tag> + struct begin_impl; + + template <> + struct begin_impl<iterator_range_tag> + { + template <typename Sequence> + struct apply + { + typedef typename Sequence::begin_type type; + + static type + call(Sequence& s) + { + return s.first; + } + }; + }; + } +}} + +#endif + + diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/end_impl.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/end_impl.hpp new file mode 100644 index 0000000..3147afe --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/end_impl.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_END_IMPL_05062005_1226) +#define FUSION_END_IMPL_05062005_1226 + +namespace boost { namespace fusion +{ + struct iterator_range_tag; + + namespace extension + { + template <typename Tag> + struct end_impl; + + template <> + struct end_impl<iterator_range_tag> + { + template <typename Sequence> + struct apply + { + typedef typename Sequence::end_type type; + + static type + call(Sequence& s) + { + return s.last; + } + }; + }; + } +}} + +#endif + + diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp new file mode 100644 index 0000000..032225d --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp @@ -0,0 +1,66 @@ +/*============================================================================= + 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_ITERATOR_RANGE_IS_SEGMENTED_HPP_INCLUDED) +#define BOOST_FUSION_ITERATOR_RANGE_IS_SEGMENTED_HPP_INCLUDED + +#include <boost/mpl/assert.hpp> +#include <boost/mpl/bool.hpp> + +namespace boost { namespace fusion +{ + struct iterator_range_tag; + + template <typename Context> + struct segmented_iterator; + + namespace extension + { + template <typename Tag> + struct is_segmented_impl; + + // An iterator_range of segmented_iterators is segmented + template <> + struct is_segmented_impl<iterator_range_tag> + { + private: + template <typename Iterator> + struct is_segmented_iterator + : mpl::false_ + {}; + + template <typename Iterator> + struct is_segmented_iterator<Iterator &> + : is_segmented_iterator<Iterator> + {}; + + template <typename Iterator> + struct is_segmented_iterator<Iterator const> + : is_segmented_iterator<Iterator> + {}; + + template <typename Context> + struct is_segmented_iterator<segmented_iterator<Context> > + : mpl::true_ + {}; + + public: + template <typename Sequence> + struct apply + : is_segmented_iterator<typename Sequence::begin_type> + { + BOOST_MPL_ASSERT_RELATION( + is_segmented_iterator<typename Sequence::begin_type>::value + , == + , is_segmented_iterator<typename Sequence::end_type>::value); + }; + }; + } +}} + +#endif + + diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp new file mode 100644 index 0000000..9bf459c --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp @@ -0,0 +1,532 @@ +/*============================================================================= + 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_ITERATOR_RANGE_HPP_INCLUDED) +#define BOOST_FUSION_SEGMENTED_ITERATOR_RANGE_HPP_INCLUDED + +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/fusion/support/tag_of.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/sequence/intrinsic/end.hpp> +#include <boost/fusion/iterator/next.hpp> +#include <boost/fusion/iterator/deref.hpp> +#include <boost/fusion/sequence/intrinsic/segments.hpp> +#include <boost/fusion/algorithm/transformation/push_back.hpp> +#include <boost/fusion/algorithm/transformation/push_front.hpp> +#include <boost/fusion/iterator/equal_to.hpp> +#include <boost/fusion/container/list/detail/reverse_cons.hpp> +#include <boost/fusion/iterator/detail/segment_sequence.hpp> +#include <boost/fusion/support/is_sequence.hpp> +#include <boost/utility/enable_if.hpp> + +// Invariants: +// - Each segmented iterator has a stack +// - Each value in the stack is an iterator range +// - The range at the top of the stack points to values +// - All other ranges point to ranges +// - The front of each range in the stack (besides the +// topmost) is the range above it + +namespace boost { namespace fusion +{ + template <typename First, typename Last> + struct iterator_range; + + namespace result_of + { + template <typename Sequence, typename T> + struct push_back; + + template <typename Sequence, typename T> + struct push_front; + } + + template <typename Sequence, typename T> + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::push_back<Sequence const, T> + >::type + push_back(Sequence const& seq, T const& x); + + template <typename Sequence, typename T> + typename + lazy_enable_if< + traits::is_sequence<Sequence> + , result_of::push_front<Sequence const, T> + >::type + push_front(Sequence const& seq, T const& x); +}} + +namespace boost { namespace fusion { namespace detail +{ + //auto make_segment_sequence_front(stack_begin) + //{ + // switch (size(stack_begin)) + // { + // case 1: + // return nil; + // case 2: + // // car(cdr(stack_begin)) is a range over values. + // assert(end(front(car(stack_begin))) == end(car(cdr(stack_begin)))); + // return iterator_range(begin(car(cdr(stack_begin))), end(front(car(stack_begin)))); + // default: + // // car(cdr(stack_begin)) is a range over segments. We replace the + // // front with a view that is restricted. + // assert(end(segments(front(car(stack_begin)))) == end(car(cdr(stack_begin)))); + // return segment_sequence( + // push_front( + // // The following could be a segment_sequence. It then gets wrapped + // // in a single_view, and push_front puts it in a join_view with the + // // following iterator_range. + // iterator_range(next(begin(car(cdr(stack_begin)))), end(segments(front(car(stack_begin))))), + // make_segment_sequence_front(cdr(stack_begin)))); + // } + //} + + template <typename Stack, std::size_t Size = Stack::size::value> + struct make_segment_sequence_front + { + // assert(end(segments(front(car(stack_begin)))) == end(car(cdr(stack_begin)))); + BOOST_MPL_ASSERT(( + result_of::equal_to< + typename result_of::end< + typename remove_reference< + typename add_const< + typename result_of::segments< + typename remove_reference< + typename add_const< + typename result_of::deref< + typename Stack::car_type::begin_type + >::type + >::type + >::type + >::type + >::type + >::type + >::type + , typename Stack::cdr_type::car_type::end_type + >)); + + typedef + iterator_range< + typename result_of::next< + typename Stack::cdr_type::car_type::begin_type + >::type + , typename result_of::end< + typename remove_reference< + typename add_const< + typename result_of::segments< + typename remove_reference< + typename add_const< + typename result_of::deref< + typename Stack::car_type::begin_type + >::type + >::type + >::type + >::type + >::type + >::type + >::type + > + rest_type; + + typedef + make_segment_sequence_front<typename Stack::cdr_type> + recurse; + + typedef + segment_sequence< + typename result_of::push_front< + rest_type const + , typename recurse::type + >::type + > + type; + + static type call(Stack const& stack) + { + //return segment_sequence( + // push_front( + // iterator_range(next(begin(car(cdr(stack_begin)))), end(segments(front(car(stack_begin))))), + // make_segment_sequence_front(cdr(stack_begin)))); + return type( + fusion::push_front( + rest_type(fusion::next(stack.cdr.car.first), fusion::end(fusion::segments(*stack.car.first))) + , recurse::call(stack.cdr))); + } + }; + + template <typename Stack> + struct make_segment_sequence_front<Stack, 2> + { + // assert(end(front(car(stack_begin))) == end(car(cdr(stack_begin)))); + BOOST_MPL_ASSERT(( + result_of::equal_to< + typename result_of::end< + typename remove_reference< + typename add_const< + typename result_of::deref< + typename Stack::car_type::begin_type + >::type + >::type + >::type + >::type + , typename Stack::cdr_type::car_type::end_type + >)); + + typedef + iterator_range< + typename Stack::cdr_type::car_type::begin_type + , typename result_of::end< + typename remove_reference< + typename add_const< + typename result_of::deref< + typename Stack::car_type::begin_type + >::type + >::type + >::type + >::type + > + type; + + static type call(Stack const& stack) + { + // return iterator_range(begin(car(cdr(stack_begin))), end(front(car(stack_begin)))); + return type(stack.cdr.car.first, fusion::end(*stack.car.first)); + } + }; + + template <typename Stack> + struct make_segment_sequence_front<Stack, 1> + { + typedef typename Stack::cdr_type type; // nil + + static type call(Stack const &stack) + { + return stack.cdr; + } + }; + + //auto make_segment_sequence_back(stack_end) + //{ + // switch (size(stack_end)) + // { + // case 1: + // return nil; + // case 2: + // // car(cdr(stack_back)) is a range over values. + // assert(end(front(car(stack_end))) == end(car(cdr(stack_end)))); + // return iterator_range(begin(front(car(stack_end))), begin(car(cdr(stack_end)))); + // default: + // // car(cdr(stack_begin)) is a range over segments. We replace the + // // back with a view that is restricted. + // assert(end(segments(front(car(stack_end)))) == end(car(cdr(stack_end)))); + // return segment_sequence( + // push_back( + // iterator_range(begin(segments(front(car(stack_end)))), begin(car(cdr(stack_end)))), + // make_segment_sequence_back(cdr(stack_end)))); + // } + //} + + template <typename Stack, std::size_t Size = Stack::size::value> + struct make_segment_sequence_back + { + // assert(end(segments(front(car(stack_begin)))) == end(car(cdr(stack_begin)))); + BOOST_MPL_ASSERT(( + result_of::equal_to< + typename result_of::end< + typename remove_reference< + typename add_const< + typename result_of::segments< + typename remove_reference< + typename add_const< + typename result_of::deref< + typename Stack::car_type::begin_type + >::type + >::type + >::type + >::type + >::type + >::type + >::type + , typename Stack::cdr_type::car_type::end_type + >)); + + typedef + iterator_range< + typename result_of::begin< + typename remove_reference< + typename add_const< + typename result_of::segments< + typename remove_reference< + typename add_const< + typename result_of::deref< + typename Stack::car_type::begin_type + >::type + >::type + >::type + >::type + >::type + >::type + >::type + , typename Stack::cdr_type::car_type::begin_type + > + rest_type; + + typedef + make_segment_sequence_back<typename Stack::cdr_type> + recurse; + + typedef + segment_sequence< + typename result_of::push_back< + rest_type const + , typename recurse::type + >::type + > + type; + + static type call(Stack const& stack) + { + // return segment_sequence( + // push_back( + // iterator_range(begin(segments(front(car(stack_end)))), begin(car(cdr(stack_end)))), + // make_segment_sequence_back(cdr(stack_end)))); + return type( + fusion::push_back( + rest_type(fusion::begin(fusion::segments(*stack.car.first)), stack.cdr.car.first) + , recurse::call(stack.cdr))); + } + }; + + template <typename Stack> + struct make_segment_sequence_back<Stack, 2> + { + // assert(end(front(car(stack_end))) == end(car(cdr(stack_end)))); + BOOST_MPL_ASSERT(( + result_of::equal_to< + typename result_of::end< + typename remove_reference< + typename add_const< + typename result_of::deref< + typename Stack::car_type::begin_type + >::type + >::type + >::type + >::type + , typename Stack::cdr_type::car_type::end_type + >)); + + typedef + iterator_range< + typename result_of::begin< + typename remove_reference< + typename add_const< + typename result_of::deref< + typename Stack::car_type::begin_type + >::type + >::type + >::type + >::type + , typename Stack::cdr_type::car_type::begin_type + > + type; + + static type call(Stack const& stack) + { + // return iterator_range(begin(front(car(stack_end))), begin(car(cdr(stack_end)))); + return type(fusion::begin(*stack.car.first), stack.cdr.car.first); + } + }; + + template <typename Stack> + struct make_segment_sequence_back<Stack, 1> + { + typedef typename Stack::cdr_type type; // nil + + static type call(Stack const& stack) + { + return stack.cdr; + } + }; + + //auto make_segmented_range_reduce(stack_begin, stack_end) + //{ + // if (size(stack_begin) == 1 && size(stack_end) == 1) + // { + // return segment_sequence( + // single_view( + // iterator_range(begin(car(stack_begin)), begin(car(stack_end))))); + // } + // else + // { + // // We are in the case where both begin_stack and/or end_stack have + // // more than one element. Throw away any part of the tree where + // // begin and end refer to the same segment. + // if (begin(car(stack_begin)) == begin(car(stack_end))) + // { + // return make_segmented_range_reduce(cdr(stack_begin), cdr(stack_end)); + // } + // else + // { + // // We are in the case where begin_stack and end_stack (a) have + // // more than one element each, and (b) they point to different + // // segments. We must construct a segmented sequence. + // return segment_sequence( + // push_back( + // push_front( + // iterator_range( + // fusion::next(begin(car(stack_begin))), + // begin(car(stack_end))), // a range of (possibly segmented) ranges. + // make_segment_sequence_front(stack_begin)), // should be a (possibly segmented) range. + // make_segment_sequence_back(stack_end))); // should be a (possibly segmented) range. + // } + // } + //} + + template < + typename StackBegin + , typename StackEnd + , int StackBeginSize = StackBegin::size::value + , int StackEndSize = StackEnd::size::value> + struct make_segmented_range_reduce; + + template < + typename StackBegin + , typename StackEnd + , bool SameSegment = + result_of::equal_to< + typename StackBegin::car_type::begin_type + , typename StackEnd::car_type::begin_type + >::type::value> + struct make_segmented_range_reduce2 + { + typedef + iterator_range< + typename result_of::next< + typename StackBegin::car_type::begin_type + >::type + , typename StackEnd::car_type::begin_type + > + rest_type; + + typedef + segment_sequence< + typename result_of::push_back< + typename result_of::push_front< + rest_type const + , typename make_segment_sequence_front<StackBegin>::type + >::type const + , typename make_segment_sequence_back<StackEnd>::type + >::type + > + type; + + static type call(StackBegin stack_begin, StackEnd stack_end) + { + //return segment_sequence( + // push_back( + // push_front( + // iterator_range( + // fusion::next(begin(car(stack_begin))), + // begin(car(stack_end))), // a range of (possibly segmented) ranges. + // make_segment_sequence_front(stack_begin)), // should be a (possibly segmented) range. + // make_segment_sequence_back(stack_end))); // should be a (possibly segmented) range. + return type( + fusion::push_back( + fusion::push_front( + rest_type(fusion::next(stack_begin.car.first), stack_end.car.first) + , make_segment_sequence_front<StackBegin>::call(stack_begin)) + , make_segment_sequence_back<StackEnd>::call(stack_end))); + } + }; + + template <typename StackBegin, typename StackEnd> + struct make_segmented_range_reduce2<StackBegin, StackEnd, true> + { + typedef + make_segmented_range_reduce< + typename StackBegin::cdr_type + , typename StackEnd::cdr_type + > + impl; + + typedef + typename impl::type + type; + + static type call(StackBegin stack_begin, StackEnd stack_end) + { + return impl::call(stack_begin.cdr, stack_end.cdr); + } + }; + + template <typename StackBegin, typename StackEnd, int StackBeginSize, int StackEndSize> + struct make_segmented_range_reduce + : make_segmented_range_reduce2<StackBegin, StackEnd> + {}; + + template <typename StackBegin, typename StackEnd> + struct make_segmented_range_reduce<StackBegin, StackEnd, 1, 1> + { + typedef + iterator_range< + typename StackBegin::car_type::begin_type + , typename StackEnd::car_type::begin_type + > + range_type; + + typedef + single_view<range_type> + segment_type; + + typedef + segment_sequence<segment_type> + type; + + static type call(StackBegin stack_begin, StackEnd stack_end) + { + //return segment_sequence( + // single_view( + // iterator_range(begin(car(stack_begin)), begin(car(stack_end))))); + return type(segment_type(range_type(stack_begin.car.first, stack_end.car.first))); + } + }; + + //auto make_segmented_range(begin, end) + //{ + // return make_segmented_range_reduce(reverse(begin.context), reverse(end.context)); + //} + + template <typename Begin, typename End> + struct make_segmented_range + { + typedef reverse_cons<typename Begin::context_type> reverse_begin_cons; + typedef reverse_cons<typename End::context_type> reverse_end_cons; + + typedef + make_segmented_range_reduce< + typename reverse_begin_cons::type + , typename reverse_end_cons::type + > + impl; + + typedef typename impl::type type; + + static type call(Begin const& begin, End const& end) + { + return impl::call( + reverse_begin_cons::call(begin.context) + , reverse_end_cons::call(end.context)); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/segments_impl.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/segments_impl.hpp new file mode 100644 index 0000000..ede4968 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/segments_impl.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) +==============================================================================*/ +#if !defined(BOOST_FUSION_ITERATOR_RANGE_SEGMENTS_HPP_INCLUDED) +#define BOOST_FUSION_ITERATOR_RANGE_SEGMENTS_HPP_INCLUDED + +#include <boost/mpl/assert.hpp> +#include <boost/fusion/sequence/intrinsic/segments.hpp> +#include <boost/fusion/support/is_segmented.hpp> +#include <boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp> + +namespace boost { namespace fusion +{ + struct iterator_range_tag; + + namespace extension + { + template <typename Tag> + struct segments_impl; + + template <> + struct segments_impl<iterator_range_tag> + { + template <typename Sequence> + struct apply + { + typedef + detail::make_segmented_range< + typename Sequence::begin_type + , typename Sequence::end_type + > + impl; + + BOOST_MPL_ASSERT((traits::is_segmented<typename impl::type>)); + + typedef + typename result_of::segments<typename impl::type>::type + type; + + static type call(Sequence & seq) + { + return fusion::segments(impl::call(seq.first, seq.last)); + } + }; + }; + } +}} + +#endif diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/size_impl.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/size_impl.hpp new file mode 100644 index 0000000..90951b2 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/size_impl.hpp @@ -0,0 +1,37 @@ +/*============================================================================= + 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_ITERATOR_RANGE_SIZE_IMPL_HPP_INCLUDED) +#define BOOST_FUSION_ITERATOR_RANGE_SIZE_IMPL_HPP_INCLUDED + +#include <boost/fusion/iterator/distance.hpp> + +namespace boost { namespace fusion +{ + struct iterator_range_tag; + + namespace extension + { + template <typename Tag> + struct size_impl; + + template <> + struct size_impl<iterator_range_tag> + { + template <typename Seq> + struct apply + : result_of::distance< + typename Seq::begin_type, + typename Seq::end_type + > + {}; + }; + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/value_at_impl.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/value_at_impl.hpp new file mode 100644 index 0000000..b6fe888 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/detail/value_at_impl.hpp @@ -0,0 +1,38 @@ +/*============================================================================= + Copyright (c) 2007 Tobias Schwinger + + 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_ITERATOR_RANGE_VALUE_AT_IMPL_HPP_INCLUDED) +#define BOOST_FUSION_ITERATOR_RANGE_VALUE_AT_IMPL_HPP_INCLUDED + +#include <boost/fusion/iterator/advance.hpp> +#include <boost/fusion/iterator/value_of.hpp> + +namespace boost { namespace fusion +{ + struct iterator_range_tag; + + namespace extension + { + template <typename Tag> + struct value_at_impl; + + template <> + struct value_at_impl<iterator_range_tag> + { + template <typename Seq, typename N> + struct apply + { + typedef typename Seq::begin_type begin_type; + typedef typename result_of::advance<begin_type,N>::type pos; + typedef typename result_of::value_of<pos>::type type; + }; + }; + } +}} + +#endif + diff --git a/3rdParty/Boost/src/boost/fusion/view/iterator_range/iterator_range.hpp b/3rdParty/Boost/src/boost/fusion/view/iterator_range/iterator_range.hpp new file mode 100644 index 0000000..4f517c8 --- /dev/null +++ b/3rdParty/Boost/src/boost/fusion/view/iterator_range/iterator_range.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_ITERATOR_RANGE_05062005_1224) +#define FUSION_ITERATOR_RANGE_05062005_1224 + +#include <boost/fusion/support/detail/access.hpp> +#include <boost/fusion/support/sequence_base.hpp> +#include <boost/fusion/support/category_of.hpp> +#include <boost/fusion/iterator/distance.hpp> +#include <boost/fusion/iterator/mpl/convert_iterator.hpp> +#include <boost/fusion/view/iterator_range/detail/begin_impl.hpp> +#include <boost/fusion/view/iterator_range/detail/end_impl.hpp> +#include <boost/fusion/view/iterator_range/detail/at_impl.hpp> +#include <boost/fusion/view/iterator_range/detail/size_impl.hpp> +#include <boost/fusion/view/iterator_range/detail/value_at_impl.hpp> +#include <boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp> +#include <boost/fusion/view/iterator_range/detail/segments_impl.hpp> +#include <boost/fusion/adapted/mpl/mpl_iterator.hpp> +#include <boost/config.hpp> + +#if defined (BOOST_MSVC) +# pragma warning(push) +# pragma warning (disable: 4512) // assignment operator could not be generated. +#endif + +namespace boost { namespace fusion +{ + struct iterator_range_tag; + struct fusion_sequence_tag; + + template <typename First, typename Last> + struct iterator_range : sequence_base<iterator_range<First, Last> > + { + typedef typename convert_iterator<First>::type begin_type; + typedef typename convert_iterator<Last>::type end_type; + typedef iterator_range_tag fusion_tag; + typedef fusion_sequence_tag tag; // this gets picked up by MPL + typedef mpl::true_ is_view; + + typedef typename traits::category_of<begin_type>::type category; + + iterator_range(First const& in_first, Last const& in_last) + : first(convert_iterator<First>::call(in_first)) + , last(convert_iterator<Last>::call(in_last)) {} + + begin_type first; + end_type last; + }; +}} + +#if defined (BOOST_MSVC) +# pragma warning(pop) +#endif + +#endif + + |