Subject: [Boost-commit] svn:boost r57268 - sandbox/SOC/2009/fusion/boost/fusion/view/ext_
From: mr.chr.schmidt_at_[hidden]
Date: 2009-10-31 20:08:24
Author: cschmidt
Date: 2009-10-31 20:08:23 EDT (Sat, 31 Oct 2009)
New Revision: 57268
URL: http://svn.boost.org/trac/boost/changeset/57268
Log:
proto fixes
Added:
sandbox/SOC/2009/fusion/boost/fusion/view/ext_/
sandbox/SOC/2009/fusion/boost/fusion/view/ext_/multiple_view.hpp (contents, props changed)
sandbox/SOC/2009/fusion/boost/fusion/view/ext_/segmented_iterator.hpp (contents, props changed)
sandbox/SOC/2009/fusion/boost/fusion/view/ext_/segmented_iterator_range.hpp (contents, props changed)
Added: sandbox/SOC/2009/fusion/boost/fusion/view/ext_/multiple_view.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/boost/fusion/view/ext_/multiple_view.hpp 2009-10-31 20:08:23 EDT (Sat, 31 Oct 2009)
@@ -0,0 +1,187 @@
+/*=============================================================================
+ Copyright (c) 2001-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)
+==============================================================================*/
+#ifndef FUSION_MULTIPLE_VIEW_05052005_0335
+#define FUSION_MULTIPLE_VIEW_05052005_0335
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+#include <boost/fusion/support/sequence_base.hpp>
+#include <boost/fusion/support/iterator_base.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+
+namespace boost { namespace fusion
+{
+ struct multiple_view_tag;
+ struct forward_traversal_tag;
+ struct fusion_sequence_tag;
+
+ template<typename Size, typename T>
+ struct multiple_view
+ : sequence_base<multiple_view<Size, T> >
+ {
+ typedef multiple_view_tag fusion_tag;
+ typedef fusion_sequence_tag tag; // this gets picked up by MPL
+ typedef forward_traversal_tag category;
+ typedef mpl::true_ is_view;
+ typedef mpl::int_<Size::value> size;
+ typedef T value_type;
+
+ multiple_view()
+ : val()
+ {}
+
+ explicit multiple_view(typename detail::call_param<T>::type val)
+ : val(val)
+ {}
+
+ value_type val;
+ };
+
+ template<typename Size, typename T>
+ inline multiple_view<Size, typename detail::as_fusion_element<T>::type>
+ make_multiple_view(T const& v)
+ {
+ return multiple_view<Size, typename detail::as_fusion_element<T>::type>(v);
+ }
+
+ struct multiple_view_iterator_tag;
+ struct forward_traversal_tag;
+
+ template<typename Index, typename MultipleView>
+ struct multiple_view_iterator
+ : iterator_base<multiple_view_iterator<Index, MultipleView> >
+ {
+ typedef multiple_view_iterator_tag fusion_tag;
+ typedef forward_traversal_tag category;
+ typedef typename MultipleView::value_type value_type;
+ typedef MultipleView multiple_view_type;
+ typedef Index index;
+
+ explicit multiple_view_iterator(multiple_view_type const &view_)
+ : view(view_)
+ {}
+
+ multiple_view_type view;
+ };
+
+ namespace extension
+ {
+ template <typename Tag>
+ struct next_impl;
+
+ template <>
+ struct next_impl<multiple_view_iterator_tag>
+ {
+ template <typename Iterator>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Iterator>::type it;
+
+ typedef multiple_view_iterator<
+ typename mpl::next<typename it::index>::type
+ , typename it::multiple_view_type
+ > type;
+
+ static type
+ call(Iterator where)
+ {
+ return type(where.view);
+ }
+ };
+ };
+
+ template <typename Tag>
+ struct end_impl;
+
+ template <>
+ struct end_impl<multiple_view_tag>
+ {
+ template <typename Sequence>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Sequence>::type seq;
+
+ typedef multiple_view_iterator<
+ typename seq::size
+ , seq
+ > type;
+
+ static type
+ call(Sequence seq)
+ {
+ return type(seq);
+ }
+ };
+ };
+
+ template <typename Tag>
+ struct deref_impl;
+
+ template <>
+ struct deref_impl<multiple_view_iterator_tag>
+ {
+ template <typename Iterator>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Iterator>::type it;
+ typedef typename it::value_type type;
+
+ static type
+ call(Iterator i)
+ {
+ return i.view.val;
+ }
+ };
+ };
+
+ template <typename Tag>
+ struct begin_impl;
+
+ template <>
+ struct begin_impl<multiple_view_tag>
+ {
+ template <typename Sequence>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Sequence>::type seq;
+
+ typedef multiple_view_iterator<
+ mpl::int_<0>
+ , seq
+ > type;
+
+ static type
+ call(Sequence seq)
+ {
+ return type(seq);
+ }
+ };
+ };
+
+ template <typename Tag>
+ struct value_of_impl;
+
+ template <>
+ struct value_of_impl<multiple_view_iterator_tag>
+ {
+ template <typename Iterator>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Iterator>::type it;
+
+ typedef typename it::multiple_view_type multiple_view_type;
+ typedef typename multiple_view_type::value_type type;
+ };
+ };
+ }
+}}
+
+#endif
+
+
Added: sandbox/SOC/2009/fusion/boost/fusion/view/ext_/segmented_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/boost/fusion/view/ext_/segmented_iterator.hpp 2009-10-31 20:08:23 EDT (Sat, 31 Oct 2009)
@@ -0,0 +1,459 @@
+/*=============================================================================
+ Copyright (c) 2006 Eric Niebler
+
+ Use, modification and distribution is subject to 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 FUSION_SEGMENTED_ITERATOR_EAN_05032006_1027
+#define FUSION_SEGMENTED_ITERATOR_EAN_05032006_1027
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/support/tag_of.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/view/filter_view.hpp>
+#include <boost/fusion/container/list/cons.hpp> // for nil
+#include <boost/fusion/container/generation/make_cons.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/sequence/intrinsic/ext_/segments.hpp>
+#include <boost/fusion/support/ext_/is_segmented.hpp>
+
+namespace boost { namespace fusion
+{
+ struct fusion_sequence_tag;
+
+ namespace detail
+ {
+ using mpl::_;
+ using mpl::not_;
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<typename Sequence>
+ struct is_empty
+ : result_of::equal_to<
+ typename result_of::begin<Sequence>::type
+ , typename result_of::end<Sequence>::type
+ >
+ {};
+
+ template<typename Sequence>
+ struct is_empty<Sequence &>
+ : is_empty<Sequence>
+ {};
+
+ ////////////////////////////////////////////////////////////////////////////
+ struct not_is_empty_pred
+ {
+ template<typename Sequence>
+ struct apply
+ : not_<is_empty<Sequence> >
+ {};
+ };
+
+ struct segmented_range_tag;
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<typename Sequence, typename Iterator, bool IsSegmented>
+ struct segmented_range
+ : sequence_base<segmented_range<Sequence, Iterator, IsSegmented> >
+ {
+ BOOST_MPL_ASSERT_NOT((is_reference<Sequence>));
+ typedef mpl::bool_<IsSegmented> is_segmented;
+ typedef segmented_range_tag fusion_tag;
+ typedef fusion_sequence_tag tag; // this gets picked up by MPL
+ typedef mpl::true_ is_view;
+ typedef Iterator iterator_type;
+
+ // If this is a range of segments, skip over the empty ones
+ typedef typename mpl::if_<
+ is_segmented
+ , filter_view<Sequence, not_is_empty_pred>
+ , Sequence
+ >::type sequence_non_ref_type;
+
+ typedef typename mpl::if_<
+ traits::is_view<sequence_non_ref_type>
+ , sequence_non_ref_type
+ , sequence_non_ref_type &
+ >::type sequence_type;
+
+ typedef typename traits::category_of<sequence_non_ref_type>::type category;
+
+ explicit segmented_range(Sequence &sequence_)
+ : sequence(sequence_type(sequence_))
+ , where_(fusion::begin(sequence))
+ {}
+
+ segmented_range(sequence_type sequence_, iterator_type const &wh)
+ : sequence(sequence_)
+ , where_(wh)
+ {}
+
+ sequence_type sequence;
+ iterator_type where_;
+ };
+ }
+
+ namespace extension
+ {
+ template<>
+ struct is_segmented_impl<detail::segmented_range_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ : Sequence::is_segmented
+ {};
+ };
+
+ template<>
+ struct size_impl<detail::segmented_range_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Sequence>::type seq;
+
+ typedef
+ result_of::distance<
+ typename seq::iterator_type
+ , typename result_of::end<typename seq::sequence_non_ref_type>::type
+ >
+ type;
+ };
+ };
+
+ template<>
+ struct segments_impl<detail::segmented_range_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ {
+ typedef Sequence &type;
+ static type call(Sequence &seq)
+ {
+ return seq;
+ }
+ };
+ };
+
+ template<>
+ struct begin_impl<detail::segmented_range_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Sequence>::type seq;
+
+ typedef typename seq::iterator_type type;
+
+ static type call(Sequence seq)
+ {
+ return seq.where_;
+ }
+ };
+ };
+
+ template<>
+ struct end_impl<detail::segmented_range_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Sequence>::type seq;
+
+ typedef typename seq::sequence_non_ref_type sequence;
+ typedef typename result_of::end<sequence>::type type;
+
+ static type call(Sequence seq)
+ {
+ return fusion::end(seq.sequence);
+ }
+ };
+ };
+ }
+
+ namespace detail
+ {
+ ///////////////////////////////////////////////////////////////////////
+ template<typename Range>
+ struct range_next;
+
+ template<typename Sequence, typename Iterator, bool IsSegmented>
+ struct range_next<segmented_range<Sequence, Iterator, IsSegmented> >
+ {
+ typedef typename result_of::next<Iterator>::type iterator_type;
+ typedef segmented_range<Sequence, iterator_type, IsSegmented> type;
+
+ static type call(segmented_range<Sequence, Iterator, IsSegmented> const &rng)
+ {
+ return type(rng.sequence, fusion::next(rng.where_));
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////
+ template<typename Cons>
+ struct is_range_next_empty
+ : is_empty<typename range_next<typename Cons::car_type>::type>
+ {};
+
+ template<>
+ struct is_range_next_empty<nil>
+ : mpl::true_
+ {};
+
+ ///////////////////////////////////////////////////////////////////////
+ template<typename Sequence, bool IsSegmented = traits::is_segmented<Sequence>::value>
+ struct as_segmented_range
+ {
+ typedef typename result_of::segments<Sequence>::type segments;
+ typedef typename remove_reference<segments>::type sequence;
+ typedef typename result_of::begin<filter_view<sequence, not_is_empty_pred> >::type begin;
+ typedef segmented_range<sequence, begin, true> type;
+
+ static type call(Sequence &seq)
+ {
+ segments segs(fusion::segments(seq));
+ return type(segs);
+ }
+ };
+
+ template<typename Sequence>
+ struct as_segmented_range<Sequence, false>
+ {
+ typedef typename remove_reference<Sequence>::type sequence;
+ typedef typename result_of::begin<sequence>::type begin;
+ typedef segmented_range<sequence, begin, false> type;
+
+ static type call(Sequence &seq)
+ {
+ return type(seq);
+ }
+ };
+
+ template<typename Sequence, typename Iterator, bool IsSegmented>
+ struct as_segmented_range<segmented_range<Sequence, Iterator, IsSegmented>, IsSegmented>
+ {
+ typedef segmented_range<Sequence, Iterator, IsSegmented> type;
+ static type &call(type &seq)
+ {
+ return seq;
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////
+ template<
+ typename Sequence
+ , typename State = nil
+ , bool IsSegmented = traits::is_segmented<Sequence>::value
+ >
+ struct push_segments
+ {
+ typedef typename as_segmented_range<Sequence>::type range;
+ typedef typename result_of::begin<range>::type begin;
+ typedef typename result_of::deref<begin>::type next_ref;
+ typedef typename remove_reference<next_ref>::type next;
+ typedef push_segments<next, cons<range, State> > push;
+ typedef typename push::type type;
+
+ static type call(Sequence &seq, State const &state)
+ {
+ range rng(as_segmented_range<Sequence>::call(seq));
+ next_ref nxt(*fusion::begin(rng));
+ return push::call(nxt, fusion::make_cons(rng, state));
+ }
+ };
+
+ template<typename Sequence, typename State>
+ struct push_segments<Sequence, State, false>
+ {
+ typedef typename as_segmented_range<Sequence>::type range;
+ typedef cons<range, State> type;
+
+ static type call(Sequence &seq, State const &state)
+ {
+ range rng(as_segmented_range<Sequence>::call(seq));
+ return fusion::make_cons(rng, state);
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////
+ template<typename State, bool IsEmpty = is_range_next_empty<State>::value>
+ struct pop_segments
+ {
+ typedef range_next<typename State::car_type> next;
+ typedef push_segments<typename next::type, typename State::cdr_type> push;
+ typedef typename push::type type;
+
+ static type call(State const &state)
+ {
+ typename next::type rng(next::call(state.car));
+ return push::call(rng, state.cdr);
+ }
+ };
+
+ template<typename State>
+ struct pop_segments<State, true>
+ {
+ typedef pop_segments<typename State::cdr_type> pop;
+ typedef typename pop::type type;
+
+ static type call(State const &state)
+ {
+ return pop::call(state.cdr);
+ }
+ };
+
+ template<>
+ struct pop_segments<nil, true>
+ {
+ typedef nil type;
+
+ static type call(nil const &)
+ {
+ return nil();
+ }
+ };
+ } // namespace detail
+
+ struct segmented_iterator_tag;
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<typename Cons>
+ struct segmented_iterator
+ : fusion::iterator_base<segmented_iterator<Cons> >
+ {
+ typedef segmented_iterator_tag fusion_tag;
+ typedef fusion::forward_traversal_tag category;
+
+ typedef Cons cons_type;
+ typedef typename Cons::car_type car_type;
+ typedef typename Cons::cdr_type cdr_type;
+
+ explicit segmented_iterator(Cons const &c)
+ : cons_(c)
+ {}
+
+ cons_type const &cons() const { return this->cons_; };
+ car_type const &car() const { return this->cons_.car; };
+ cdr_type const &cdr() const { return this->cons_.cdr; };
+
+ private:
+ Cons cons_;
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ template<typename Sequence>
+ struct segmented_begin
+ {
+ typedef typename detail::push_segments<Sequence> push;
+ typedef segmented_iterator<typename push::type> type;
+
+ static type call(Sequence &seq)
+ {
+ return type(push::call(seq, nil()));
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ template<typename Sequence>
+ struct segmented_end
+ {
+ typedef segmented_iterator<nil> type;
+
+ static type call(Sequence &)
+ {
+ return type(nil());
+ }
+ };
+
+ namespace extension
+ {
+ template<>
+ struct equal_to_impl<segmented_iterator_tag>
+ {
+ template<typename It1, typename It2>
+ struct apply
+ : is_same<
+ typename detail::remove_reference<It1>::type::cons_type
+ , typename detail::remove_reference<It2>::type::cons_type
+ >
+ {};
+ };
+
+ template<>
+ struct value_of_impl<segmented_iterator_tag>
+ {
+ template<typename Iterator>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Iterator>::type it;
+
+ typedef typename result_of::begin<typename it::car_type>::type begin;
+ typedef typename result_of::value_of<begin>::type type;
+ };
+ };
+
+ template<>
+ struct deref_impl<segmented_iterator_tag>
+ {
+ template<typename Iterator>
+ struct apply
+ {
+ typedef typename detail::remove_reference<Iterator>::type it;
+ typedef typename result_of::begin<typename it::car_type>::type begin;
+ typedef typename result_of::deref<begin>::type type;
+
+ static type call(Iterator it)
+ {
+ return *fusion::begin(it.car());
+ }
+ };
+ };
+
+ // discards the old head, expands the right child of the new head
+ // and pushes the result to the head of the list.
+
+ template<>
+ struct next_impl<segmented_iterator_tag>
+ {
+ template<
+ typename Iterator
+ , bool IsSegmentDone = detail::is_range_next_empty<typename detail::remove_reference<Iterator>::type>::value
+ >
+ struct apply
+ {
+ typedef typename detail::remove_reference<Iterator>::type it;
+ typedef typename it::cdr_type cdr_type;
+ typedef detail::range_next<typename it::car_type> next;
+ typedef segmented_iterator<cons<typename next::type, cdr_type> > type;
+
+ static type call(Iterator it)
+ {
+ return type(fusion::make_cons(next::call(it.car()), it.cdr()));
+ }
+ };
+
+ template<typename Iterator>
+ struct apply<Iterator, true> // segment done, move to next segment
+ {
+ typedef typename detail::remove_reference<Iterator>::type it;
+ typedef typename it::cdr_type cdr_type;
+ typedef typename detail::pop_segments<cdr_type> pop;
+ typedef segmented_iterator<typename pop::type> type;
+
+ static type call(Iterator it)
+ {
+ return type(pop::call(it.cdr()));
+ }
+ };
+ };
+ }
+}} // namespace boost::fusion
+
+#endif
Added: sandbox/SOC/2009/fusion/boost/fusion/view/ext_/segmented_iterator_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/fusion/boost/fusion/view/ext_/segmented_iterator_range.hpp 2009-10-31 20:08:23 EDT (Sat, 31 Oct 2009)
@@ -0,0 +1,537 @@
+/*=============================================================================
+ Copyright (c) 2006 Eric Niebler
+
+ Use, modification and distribution is subject to 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 FUSION_SEGMENTED_ITERATOR_RANGE_EAN_05032006_1027
+#define FUSION_SEGMENTED_ITERATOR_RANGE_EAN_05032006_1027
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/minus.hpp>
+#include <boost/mpl/next_prior.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/iterator/mpl/convert_iterator.hpp>
+#include <boost/fusion/container/list/cons.hpp>
+#include <boost/fusion/view/joint_view.hpp>
+#include <boost/fusion/view/single_view.hpp>
+#include <boost/fusion/view/transform_view.hpp>
+#include <boost/fusion/view/iterator_range.hpp>
+#include <boost/fusion/view/ext_/multiple_view.hpp>
+#include <boost/fusion/view/ext_/segmented_iterator.hpp>
+#include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
+
+namespace boost { namespace fusion
+{
+ namespace detail
+ {
+ ////////////////////////////////////////////////////////////////////////////
+ template<typename Cons, typename State = nil>
+ struct reverse_cons;
+
+ template<typename Car, typename Cdr, typename State>
+ struct reverse_cons<cons<Car, Cdr>, State>
+ {
+ typedef reverse_cons<Cdr, cons<Car, State> > reverse;
+ typedef typename reverse::type type;
+
+ static type call(cons<Car, Cdr> const &cons, State const &state = State())
+ {
+ return reverse::call(cons.cdr, fusion::make_cons(cons.car, state));
+ }
+ };
+
+ template<typename State>
+ struct reverse_cons<nil, State>
+ {
+ typedef State type;
+
+ static State const &call(nil const &, State const &state = State())
+ {
+ return state;
+ }
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+ // tags
+ struct full_view {};
+ struct left_view {};
+ struct right_view {};
+ struct center_view {};
+
+ template<typename Tag>
+ struct segmented_view_tag;
+
+ ////////////////////////////////////////////////////////////////////////////
+ // a segmented view of that includes all elements either to the
+ // right or the left of a segmented iterator.
+ template<typename Tag, typename Cons1, typename Cons2 = void_>
+ struct segmented_view
+ : sequence_base<segmented_view<Tag, Cons1, Cons2> >
+ {
+ typedef segmented_view_tag<Tag> fusion_tag;
+ typedef fusion_sequence_tag tag; // this gets picked up by MPL
+ typedef mpl::true_ is_view;
+ typedef forward_traversal_tag category;
+
+ explicit segmented_view(Cons1 const &cons)
+ : cons(cons)
+ {}
+
+ typedef Cons1 cons_type;
+ cons_type const &cons;
+ };
+
+ // a segmented view that contains all the elements in between
+ // two segmented iterators
+ template<typename Cons1, typename Cons2>
+ struct segmented_view<center_view, Cons1, Cons2>
+ : sequence_base<segmented_view<center_view, Cons1, Cons2> >
+ {
+ typedef segmented_view_tag<center_view> fusion_tag;
+ typedef fusion_sequence_tag tag; // this gets picked up by MPL
+ typedef mpl::true_ is_view;
+ typedef forward_traversal_tag category;
+
+ segmented_view(Cons1 const &lcons, Cons2 const &rcons)
+ : left_cons(lcons)
+ , right_cons(rcons)
+ {}
+
+ typedef Cons1 left_cons_type;
+ typedef Cons2 right_cons_type;
+
+ left_cons_type const &left_cons;
+ right_cons_type const &right_cons;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Used to transform a sequence of segments. The first segment is
+ // bounded by RightCons, and the last segment is bounded by LeftCons
+ // and all the others are passed through unchanged.
+ template<typename RightCons, typename LeftCons = RightCons>
+ struct segments_transform
+ {
+ explicit segments_transform(RightCons const &cons_)
+ : right_cons(cons_)
+ , left_cons(cons_)
+ {}
+
+ segments_transform(RightCons const &right_cons_, LeftCons const &left_cons_)
+ : right_cons(right_cons_)
+ , left_cons(left_cons_)
+ {}
+
+ template<typename First, typename Second>
+ struct result_;
+
+ template<typename Second>
+ struct result_<right_view, Second>
+ {
+ typedef segmented_view<right_view, RightCons> type;
+ };
+
+ template<typename Second>
+ struct result_<left_view, Second>
+ {
+ typedef segmented_view<left_view, LeftCons> type;
+ };
+
+ template<typename Second>
+ struct result_<full_view, Second>
+ {
+ typedef Second type;
+ };
+
+ template<typename Sig>
+ struct result;
+
+ template<typename This, typename First, typename Second>
+ struct result<This(First, Second)>
+ : result_<
+ typename remove_cv<typename remove_reference<First>::type>::type
+ , typename remove_cv<typename remove_reference<Second>::type>::type
+ >
+ {};
+
+ template<typename Second>
+ segmented_view<right_view, RightCons> operator ()(right_view, Second &second) const
+ {
+ return segmented_view<right_view, RightCons>(this->right_cons);
+ }
+
+ template<typename Second>
+ segmented_view<left_view, LeftCons> operator ()(left_view, Second &second) const
+ {
+ return segmented_view<left_view, LeftCons>(this->left_cons);
+ }
+
+ template<typename Second>
+ Second &operator ()(full_view, Second &second) const
+ {
+ return second;
+ }
+
+ private:
+ RightCons const &right_cons;
+ LeftCons const &left_cons;
+ };
+
+ } // namespace detail
+
+ namespace extension
+ {
+ ////////////////////////////////////////////////////////////////////////////
+ template<typename Tag>
+ struct is_segmented_impl<detail::segmented_view_tag<Tag> >
+ {
+ template<typename Sequence>
+ struct apply
+ : mpl::true_
+ {};
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<>
+ struct segments_impl<detail::segmented_view_tag<detail::right_view> >
+ {
+ template<
+ typename Sequence
+ , typename Cdr = typename Sequence::cons_type::cdr_type
+ >
+ struct apply
+ {
+ typedef typename Sequence::cons_type::car_type segmented_range;
+ typedef typename result_of::size<segmented_range>::type size;
+ typedef typename mpl::prior<size>::type size_minus_1;
+ typedef detail::segments_transform<Cdr> tfx;
+ typedef joint_view<
+ single_view<detail::right_view> const
+ , multiple_view<size_minus_1, detail::full_view> const
+ > mask;
+ typedef transform_view<mask const, segmented_range const, tfx> type;
+
+ static type call(Sequence &seq)
+ {
+ return type(
+ mask(
+ make_single_view(detail::right_view())
+ , make_multiple_view<size_minus_1>(detail::full_view())
+ )
+ , seq.cons.car
+ , tfx(seq.cons.cdr)
+ );
+ }
+ };
+
+ template<typename Sequence>
+ struct apply<Sequence, nil>
+ {
+ typedef typename Sequence::cons_type::car_type segmented_range;
+ typedef typename segmented_range::iterator_type begin;
+ typedef typename segmented_range::sequence_non_ref_type sequence_type;
+ typedef typename result_of::end<sequence_type>::type end;
+ typedef iterator_range<begin, end> range;
+ typedef single_view<range> type;
+
+ static type call(Sequence &seq)
+ {
+ return type(range(seq.cons.car.where_, fusion::end(seq.cons.car.sequence)));
+ }
+ };
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<>
+ struct segments_impl<detail::segmented_view_tag<detail::left_view> >
+ {
+ template<
+ typename Sequence
+ , typename Cdr = typename Sequence::cons_type::cdr_type
+ >
+ struct apply
+ {
+ typedef typename Sequence::cons_type::car_type right_segmented_range;
+ typedef typename right_segmented_range::sequence_type sequence_type;
+ typedef typename right_segmented_range::iterator_type iterator_type;
+
+ typedef iterator_range<
+ typename result_of::begin<sequence_type>::type
+ , typename result_of::next<iterator_type>::type
+ > segmented_range;
+
+ typedef detail::segments_transform<Cdr> tfx;
+ typedef typename result_of::size<segmented_range>::type size;
+ typedef typename mpl::prior<size>::type size_minus_1;
+ typedef joint_view<
+ multiple_view<size_minus_1, detail::full_view> const
+ , single_view<detail::left_view> const
+ > mask;
+ typedef transform_view<mask const, segmented_range const, tfx> type;
+
+ static type call(Sequence &seq)
+ {
+ return type(
+ mask(
+ make_multiple_view<size_minus_1>(detail::full_view())
+ , make_single_view(detail::left_view())
+ )
+ , segmented_range(fusion::begin(seq.cons.car.sequence), fusion::next(seq.cons.car.where_))
+ , tfx(seq.cons.cdr)
+ );
+ }
+ };
+
+ template<typename Sequence>
+ struct apply<Sequence, nil>
+ {
+ typedef typename Sequence::cons_type::car_type segmented_range;
+ typedef typename segmented_range::sequence_non_ref_type sequence_type;
+ typedef typename result_of::begin<sequence_type>::type begin;
+ typedef typename segmented_range::iterator_type end;
+ typedef iterator_range<begin, end> range;
+ typedef single_view<range> type;
+
+ static type call(Sequence &seq)
+ {
+ return type(range(fusion::begin(seq.cons.car.sequence), seq.cons.car.where_));
+ }
+ };
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<>
+ struct segments_impl<detail::segmented_view_tag<detail::center_view> >
+ {
+ template<typename Sequence>
+ struct apply
+ {
+ typedef typename Sequence::right_cons_type right_cons_type;
+ typedef typename Sequence::left_cons_type left_cons_type;
+ typedef typename right_cons_type::car_type right_segmented_range;
+ typedef typename left_cons_type::car_type left_segmented_range;
+
+ typedef iterator_range<
+ typename result_of::begin<left_segmented_range>::type
+ , typename result_of::next<typename result_of::begin<right_segmented_range>::type>::type
+ > segmented_range;
+
+ typedef typename mpl::minus<
+ typename result_of::size<segmented_range>::type
+ , mpl::int_<2>
+ >::type size_minus_2;
+
+ BOOST_MPL_ASSERT_RELATION(0, <=, size_minus_2::value);
+
+ typedef detail::segments_transform<
+ typename left_cons_type::cdr_type
+ , typename right_cons_type::cdr_type
+ > tfx;
+
+ typedef joint_view<
+ multiple_view<size_minus_2, detail::full_view> const
+ , single_view<detail::left_view> const
+ > left_mask;
+
+ typedef joint_view<
+ single_view<detail::right_view> const
+ , left_mask const
+ > mask;
+
+ typedef transform_view<mask const, segmented_range const, tfx> type;
+
+ static type call(Sequence &seq)
+ {
+ left_mask lmask(
+ make_multiple_view<size_minus_2>(detail::full_view())
+ , make_single_view(detail::left_view())
+ );
+ return type(
+ mask(make_single_view(detail::right_view()), lmask)
+ , segmented_range(fusion::begin(seq.left_cons.car), fusion::next(fusion::begin(seq.right_cons.car)))
+ , tfx(seq.left_cons.cdr, seq.right_cons.cdr)
+ );
+ }
+ };
+ };
+ }
+
+ // specialize iterator_range for use with segmented iterators, so that
+ // it presents a segmented view of the range.
+ template<typename First, typename Last>
+ struct iterator_range;
+
+ template<typename First, typename Last>
+ struct iterator_range<segmented_iterator<First>, segmented_iterator<Last> >
+ : sequence_base<iterator_range<segmented_iterator<First>, segmented_iterator<Last> > >
+ {
+ typedef typename convert_iterator<segmented_iterator<First> >::type begin_type;
+ typedef typename convert_iterator<segmented_iterator<Last> >::type end_type;
+ typedef typename detail::reverse_cons<First>::type begin_cons_type;
+ typedef typename detail::reverse_cons<Last>::type end_cons_type;
+ typedef iterator_range_tag fusion_tag;
+ typedef fusion_sequence_tag tag; // this gets picked up by MPL
+ typedef typename traits::category_of<begin_type>::type category;
+ typedef typename result_of::distance<begin_type, end_type>::type size;
+ typedef mpl::true_ is_view;
+
+ iterator_range(segmented_iterator<First> const& first_, segmented_iterator<Last> const& last_)
+ : first(convert_iterator<segmented_iterator<First> >::call(first_))
+ , last(convert_iterator<segmented_iterator<Last> >::call(last_))
+ , first_cons(detail::reverse_cons<First>::call(first_.cons()))
+ , last_cons(detail::reverse_cons<Last>::call(last_.cons()))
+ {}
+
+ begin_type first;
+ end_type last;
+
+ begin_cons_type first_cons;
+ end_cons_type last_cons;
+ };
+
+ namespace detail
+ {
+
+ template<typename Cons1, typename Cons2>
+ struct same_segment
+ : mpl::false_
+ {};
+
+ template<typename Car1, typename Cdr1, typename Car2, typename Cdr2>
+ struct same_segment<cons<Car1, Cdr1>, cons<Car2, Cdr2> >
+ : mpl::and_<
+ traits::is_segmented<Car1>
+ , is_same<Car1, Car2>
+ >
+ {};
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<typename Cons1, typename Cons2>
+ struct segments_gen;
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<typename Cons1, typename Cons2, bool SameSegment>
+ struct segments_gen2
+ {
+ typedef segments_gen<typename Cons1::cdr_type, typename Cons2::cdr_type> gen;
+ typedef typename gen::type type;
+
+ static type call(Cons1 const &cons1, Cons2 const &cons2)
+ {
+ return gen::call(cons1.cdr, cons2.cdr);
+ }
+ };
+
+ template<typename Cons1, typename Cons2>
+ struct segments_gen2<Cons1, Cons2, false>
+ {
+ typedef segmented_view<center_view, Cons1, Cons2> view;
+ typedef typename result_of::segments<view>::type type;
+
+ static type call(Cons1 const &cons1, Cons2 const &cons2)
+ {
+ view v(cons1, cons2);
+ return fusion::segments(v);
+ }
+ };
+
+ template<typename Car1, typename Car2>
+ struct segments_gen2<cons<Car1>, cons<Car2>, false>
+ {
+ typedef iterator_range<
+ typename Car1::iterator_type
+ , typename Car2::iterator_type
+ > range;
+
+ typedef single_view<range> type;
+
+ static type call(cons<Car1> const &cons1, cons<Car2> const &cons2)
+ {
+ return type(range(cons1.car.where_, cons2.car.where_));
+ }
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+ template<typename Cons1, typename Cons2>
+ struct segments_gen
+ : segments_gen2<Cons1, Cons2, same_segment<Cons1, Cons2>::value>
+ {};
+
+ template<typename Car, typename Cdr>
+ struct segments_gen<cons<Car, Cdr>, nil>
+ {
+ typedef segmented_view<right_view, cons<Car, Cdr> > view;
+ typedef typename result_of::segments<view>::type type;
+
+ static type call(cons<Car, Cdr> const &cons, nil const &)
+ {
+ view v(cons);
+ return fusion::segments(v);
+ }
+ };
+
+ template<>
+ struct segments_gen<nil, nil>
+ {
+ typedef nil type;
+
+ static type call(nil const &, nil const &)
+ {
+ return nil();
+ }
+ };
+ } // namespace detail
+
+ 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>
+ {
+ template<typename Iterator>
+ struct is_segmented_iterator : mpl::false_ {};
+
+ template<typename Cons>
+ struct is_segmented_iterator<segmented_iterator<Cons> > : mpl::true_ {};
+
+ template<typename Sequence>
+ struct apply
+ : mpl::and_<
+ is_segmented_iterator<typename Sequence::begin_type>
+ , is_segmented_iterator<typename Sequence::end_type>
+ >
+ {};
+ };
+
+ template<typename Sequence>
+ struct segments_impl;
+
+ template<>
+ struct segments_impl<iterator_range_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ {
+ typedef typename Sequence::begin_cons_type begin_cons;
+ typedef typename Sequence::end_cons_type end_cons;
+
+ typedef detail::segments_gen<begin_cons, end_cons> gen;
+ typedef typename gen::type type;
+
+ static type call(Sequence &sequence)
+ {
+ return gen::call(sequence.first_cons, sequence.last_cons);
+ }
+ };
+ };
+ }
+
+}}
+
+#endif