[/==============================================================================
    Copyright (C) 2001-2007 Joel de Guzman, Dan Marsden, Tobias Schwinger

    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)
===============================================================================/]
[section View]

Views are sequences that do not actually contain data, but instead impart
an alternative presentation over the data from one or more underlying
sequences. Views are proxies. They provide an efficient yet purely
functional way to work on potentially expensive sequence operations. Views
are inherently lazy. Their elements are only computed on demand only when
the elements of the underlying sequence(s) are actually accessed. Views'
lazy nature make them very cheap to copy and be passed around by value.

[heading Header]

    #include <boost/fusion/view.hpp>
    #include <boost/fusion/include/view.hpp>

[section single_view]

`single_view` is a view into a value as a single element sequence.

[heading Header]

    #include <boost/fusion/view/single_view.hpp>
    #include <boost/fusion/include/single_view.hpp>

[heading Synopsis]

    template <typename T>
    struct single_view;

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`T`]                  [Any type]                  []]
]

[heading Model of]

* __forward_sequence__

[variablelist Notation
    [[`S`]              [A `single_view` type]]
    [[`s`, `s2`]        [Instances of `single_view`]]
    [[`x`]              [An instance of `T`]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __forward_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`S(x)`]               [Creates a `single_view` from `x`.]]
    [[`S(s)`]               [Copy constructs a `single_view` from another `single_view`, `s`.]]
    [[`s = s2`]             [Assigns to a `single_view`, `s`, from another `single_view`, `s2`.]]
]

[heading Example]

    single_view<int> view(3);
    std::cout << view << std::endl;

[endsect]

[section filter_view]

[heading Description]

`filter_view` is a view into a subset of its underlying sequence's elements
satisfying a given predicate (an __mpl__ metafunction). The `filter_view`
presents only those elements for which its predicate evaluates to
`mpl::true_`.

[heading Header]

    #include <boost/fusion/view/filter_view.hpp>
    #include <boost/fusion/include/filter_view.hpp>

[heading Synopsis]

    template <typename Sequence, typename Pred>
    struct filter_view;

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`Sequence`]           [A __forward_sequence__]    []]
    [[`Pred`]               [Unary Metafunction
                             returning an `mpl::bool_`] []]
]

[heading Model of]

* __forward_sequence__
* __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.

[variablelist Notation
    [[`F`]              [A `filter_view` type]]
    [[`f`, `f2`]        [Instances of `filter_view`]]
    [[`s`]              [A __forward_sequence__]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in the implemented models.

[table
    [[Expression]           [Semantics]]
    [[`F(s)`]               [Creates a `filter_view` given a sequence, `s`.]]
    [[`F(f)`]               [Copy constructs a `filter_view` from another `filter_view`, `f`.]]
    [[`f = f2`]             [Assigns to a `filter_view`, `f`, from another `filter_view`, `f2`.]]
]

[heading Example]

    using boost::mpl::_;
    using boost::mpl::not_;
    using boost::is_class;

    typedef __vector__<std::string, char, long, bool, double> vector_type;

    vector_type v("a-string", '@', 987654, true, 6.6);
    filter_view<vector_type const, not_<is_class<_> > > view(v);
    std::cout << view << std::endl;

[endsect]

[section iterator_range]

[heading Description]

`iterator_range` presents a sub-range of its underlying sequence delimited
by a pair of iterators.

[heading Header]

    #include <boost/fusion/view/iterator_range.hpp>
    #include <boost/fusion/include/iterator_range.hpp>

[heading Synopsis]

    template <typename First, typename Last>
    struct iterator_range;

[heading Template parameters]

[table
    [[Parameter]            [Description]               [Default]]
    [[`First`]              [A fusion __iterator__]     []]
    [[`Last`]               [A fusion __iterator__]     []]
]

[heading Model of]

* __forward_sequence__, __bidirectional_sequence__ or
__random_access_sequence__ depending on the traversal characteristics (see
__traversal_concept__) of its underlying sequence.
* __associative_sequence__ if `First` and `Last` implement the __associative_iterator__ model.

[variablelist Notation
    [[`IR`]             [An `iterator_range` type]]
    [[`f`]              [An instance of `First`]]
    [[`l`]              [An instance of `Last`]]
    [[`ir`, `ir2`]      [Instances of `iterator_range`]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in the implemented models.

[table
    [[Expression]           [Semantics]]
    [[`IR(f, l)`]           [Creates an `iterator_range` given iterators, `f` and `l`.]]
    [[`IR(ir)`]             [Copy constructs an `iterator_range` from another `iterator_range`, `ir`.]]
    [[`ir = ir2`]           [Assigns to a `iterator_range`, `ir`, from another `iterator_range`, `ir2`.]]
]

[heading Example]

    char const* s = "Ruby";
    typedef __vector__<int, char, double, char const*> vector_type;
    vector_type vec(1, 'x', 3.3, s);

    typedef __result_of_begin__<vector_type>::type A;
    typedef __result_of_end__<vector_type>::type B;
    typedef __result_of_next__<A>::type C;
    typedef __result_of_prior__<B>::type D;

    C c(vec);
    D d(vec);

    iterator_range<C, D> range(c, d);
    std::cout << range << std::endl;

[endsect]

[section joint_view]

[heading Description]

`joint_view` presents a view which is a concatenation of two sequences.

[heading Header]

    #include <boost/fusion/view/joint_view.hpp>
    #include <boost/fusion/include/joint_view.hpp>

[heading Synopsis]

    template <typename Sequence1, typename Sequence2>
    struct joint_view;

[heading Template parameters]

[table
    [[Parameter]            [Description]                   [Default]]
    [[`Sequence1`]          [A __forward_sequence__]        []]
    [[`Sequence2`]          [A __forward_sequence__]        []]
]

[heading Model of]

* __forward_sequence__
* __associative_sequence__ if `Sequence1` and `Sequence2` implement the __associative_sequence__ model.

[variablelist Notation
    [[`JV`]             [A `joint_view` type]]
    [[`s1`]             [An instance of `Sequence1`]]
    [[`s2`]             [An instance of `Sequence2`]]
    [[`jv`, `jv2`]      [Instances of `joint_view`]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in the implemented models.

[table
    [[Expression]           [Semantics]]
    [[`JV(s1, s2)`]         [Creates a `joint_view` given sequences, `s1` and `s2`.]]
    [[`JV(jv)`]             [Copy constructs a `joint_view` from another `joint_view`, `jv`.]]
    [[`jv = jv2`]           [Assigns to a `joint_view`, `jv`, from another `joint_view`, `jv2`.]]
]

[heading Example]

    __vector__<int, char> v1(3, 'x');
    __vector__<std::string, int> v2("hello", 123);
    joint_view<
        __vector__<int, char>
      , __vector__<std::string, int>
    > view(v1, v2);
    std::cout << view << std::endl;

[endsect]

[section zip_view]

[heading Description]

`zip_view` presents a view which iterates over a collection of __sequence__(s) in parallel. A `zip_view`
is constructed from a __sequence__ of references to the component __sequence__s.

[heading Header]

    #include <boost/fusion/view/zip_view.hpp>
    #include <boost/fusion/include/zip_view.hpp>

[heading Synopsis]

    template <typename Sequences>
    struct zip_view;

[heading Template parameters]

[table
    [[Parameter]            [Description]                   [Default]]
    [[`Sequences`]          [A __forward_sequence__ of references to other Fusion __sequence__s]        []]
]

[heading Model of]

* __forward_sequence__, __bidirectional_sequence__ or
__random_access_sequence__ depending on the traversal characteristics (see
__traversal_concept__) of its underlying sequence.

[variablelist Notation
    [[`ZV`]             [A `zip_view` type]]
    [[`s`]             [An instance of `Sequences`]]
    [[`zv1`, `zv2`]             [Instances of `ZV`]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __forward_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`ZV(s)`]              [Creates a `zip_view` given a sequence of references to the component __sequence__s.]]
    [[`ZV(zv1)`]             [Copy constructs a `zip_view` from another `zip_view`, `zv`.]]
    [[`zv1 = zv2`]           [Assigns to a `zip_view`, `zv`, from another `zip_view`, `zv2`.]]
]

[heading Example]
    typedef __vector__<int,int> vec1;
    typedef __vector__<char,char> vec2;
    vec1 v1(1,2);
    vec2 v2('a','b');
    typedef __vector__<vec1&, vec2&> sequences;
    std::cout << zip_view<sequences>(sequences(v1, v2)) << std::endl; // ((1 a) (2 b))

[endsect]

[section transform_view]

The unary version of `transform_view` presents a view of its underlying
sequence given a unary function object or function pointer. The binary
version of `transform_view` presents a view of 2 underlying sequences,
given a binary function object or function pointer. The `transform_view`
inherits the traversal characteristics (see __traversal_concept__)  of
its underlying sequence or sequences.

[heading Header]

    #include <boost/fusion/view/transform_view.hpp>
    #include <boost/fusion/include/transform_view.hpp>

[heading Synopsis]

[*Unary Version]

    template <typename Sequence, typename F1>
    struct transform_view;

[*Binary Version]

    template <typename Sequence1, typename Sequence2, typename F2>
    struct transform_view;

[heading Template parameters]

[table
    [[Parameter]            [Description]                           [Default]]
    [[`Sequence`]           [A __forward_sequence__]                []]
    [[`Sequence1`]          [A __forward_sequence__]                []]
    [[`Sequence2`]          [A __forward_sequence__]                []]
    [[`F1`]                  [A unary function object or function pointer. `__boost_result_of_call__<F1(E)>::type` is the return type of an instance of `F1` when called with a value of each element type `E` in the input sequence.]                   []]
    [[`F2`]                  [A binary function object or function pointer. `__boost_result_of_call__<F2(E1, E2)>::type` is the return type of an instance of `F2` when called with a value of each corresponding pair of element type `E1` and `E2` in the input sequences.]                   []]
]

[heading Model of]

* __forward_sequence__, __bidirectional_sequence__ or
__random_access_sequence__ depending on the traversal characteristics (see
__traversal_concept__) of its underlying sequence.

[variablelist Notation
    [[`TV`]             [A `transform_view` type]]
    [[`BTV`]            [A binary `transform_view` type]]
    [[`UTV`]            [A unary `transform_view` type]]
    [[`f1`]              [An instance of `F1`]]
    [[`f2`]              [An instance of `F2`]]
    [[`s`]              [An instance of `Sequence`]]
    [[`s1`]             [An instance of `Sequence1`]]
    [[`s2`]             [An instance of `Sequence2`]]
    [[`tv`, `tv2`]      [Instances of `transform_view`]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __forward_sequence__, __bidirectional_sequence__ or
__random_access_sequence__ depending on the traversal characteristics (see
__traversal_concept__) of its underlying sequence or sequences.

[table
    [[Expression]           [Semantics]]
    [[`UTV(s, f1)`]          [Creates a unary `transform_view` given sequence,
                             `s` and unary function object or function pointer, `f1`.]]
    [[`BTV(s1, s2, f2)`]     [Creates a binary `transform_view` given sequences, `s1` and `s2`
                             and binary function object or function pointer, `f2`.]]
    [[`TV(tv)`]             [Copy constructs a `transform_view` from another `transform_view`, `tv`.]]
    [[`tv = tv2`]           [Assigns to a `transform_view`, `tv`, from another `transform_view`, `tv2`.]]
]

[heading Example]

    struct square
    {
        template<typename Sig>
        struct result;

        template<typename U>
        struct result<square(U)>
        : remove_reference<U>
        {};

        template <typename T>
        T operator()(T x) const
        {
            return x * x;
        }
    };

    typedef __vector__<int, short, double> vector_type;
    vector_type vec(2, 5, 3.3);

    transform_view<vector_type, square> transform(vec, square());
    std::cout << transform << std::endl;

[endsect]

[section reverse_view]

`reverse_view` presents a reversed view of underlying sequence. The first
element will be its last and the last element will be its first.

[heading Header]

    #include <boost/fusion/view/reverse_view.hpp>
    #include <boost/fusion/include/reverse_view.hpp>

[heading Synopsis]

    template <typename Sequence>
    struct reverse_view;

[heading Template parameters]

[table
    [[Parameter]            [Description]                           [Default]]
    [[`Sequence`]           [A __bidirectional_sequence__]          []]
]

[heading Model of]

* A model of __bidirectional_sequence__ if `Sequence` is a __bidirectional_sequence__
else, __random_access_sequence__ if `Sequence` is a __random_access_sequence__.
* __associative_sequence__ if `Sequence` implements the __associative_sequence__ model.

[variablelist Notation
    [[`RV`]             [A `reverse_view` type]]
    [[`s`]              [An instance of `Sequence`]]
    [[`rv`, `rv2`]      [Instances of `reverse_view`]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in the implemented models.

[table
    [[Expression]           [Semantics]]
    [[`RV(s)`]              [Creates a unary `reverse_view` given sequence, `s`.]]
    [[`RV(rv)`]             [Copy constructs a `reverse_view` from another `reverse_view`, `rv`.]]
    [[`rv = rv2`]           [Assigns to a `reverse_view`, `rv`, from another `reverse_view`, `rv2`.]]
]

[heading Example]

    typedef __vector__<int, short, double> vector_type;
    vector_type vec(2, 5, 3.3);

    reverse_view<vector_type> reverse(vec);
    std::cout << reverse << std::endl;

[endsect]

[section nview]

[heading Description]

`nview` presents a view which iterates over a given __sequence__ in a specified order. 
An `nview` is constructed from an arbitrary __sequence__ and a list of indicies specifying
the elements to iterate over.

[heading Header]

    #include <boost/fusion/view/nview.hpp>
    #include <boost/fusion/include/nview.hpp>

[heading Synopsis]

    template <typename Sequence, typename Indicies>
    struct nview;

    template <typename Sequence, int I1, int I2 = -1, ...>
    typename result_of::nview<Sequence, I1, I2, ...>::type
    as_nview(Sequence& s);

[heading Template parameters]

[table
    [[Parameter]            [Description]                   [Default]]
    [[`Sequence`]           [An arbitrary Fusion __forward_sequence__]
                                                            []]
    [[`Indicies`]           [A `mpl::vector_c<int, ...>` holding the indicies defining 
                             the required iteration order.] []]
    [[`I1`, `I2`, `I3`...]  [A list of integers specifying the required 
                             iteration order.]              [`INT_MAX` for `I2`, `I3`...]]
]

[heading Model of]

* __random_access_sequence__ (see __traversal_concept__) 

[variablelist Notation
    [[`NV`]            [A `nview` type]]
    [[`s`]             [An instance of `Sequences`]]
    [[`nv1`, `nv2`]    [Instances of `NV`]]
]

[heading Expression Semantics]

Semantics of an expression is defined only where it differs from, or is not
defined in __random_access_sequence__.

[table
    [[Expression]           [Semantics]]
    [[`NV(s)`]              [Creates an `nview` given a sequence and a list of indicies.]]
    [[`NV(nv1)`]            [Copy constructs an `nview` from another `nview`, `nv1`.]]
    [[`nv1 = nv2`]          [Assigns to an `nview`, `nv1`, from another `nview`, `nv2`.]]
]

The `nview` internally stores a Fusion __vector__ of references to the elements
of the original Fusion __sequence__

[heading Example]
    typedef __vector__<int, char, double> vec;
    typedef mpl::vector_c<int, 2, 1, 0, 2, 0> indicies;

    vec v1(1, 'c', 2.0);

    std::cout << nview<vec, indicies>(v1) << std::endl; // (2.0 c 1 2.0 1)
    std::cout << as_nview<2, 1, 1, 0>(v1) << std::endl; // (2.0 c c 1)

[endsect]


[section repetitive_view]

[heading Description]

`repetitive_view` presents a view which iterates over a given
__sequence__ repeatedly.  Because a `repetitive_view`
has infinite length, it can only be used when some external
condition determines the end.  Thus, initializing a fixed
length sequence with a `repetitive_view` is okay, but
printing a `repetitive_view` to `std::cout` is not.

[heading Header]

    #include <boost/fusion/view/repetitive_view.hpp>
    #include <boost/fusion/include/repetitive_view.hpp>

[heading Synopsis]

    template <typename Sequence>
    struct repetitive_view;

[heading Template parameters]

[table
    [[Parameter]            [Description]                   [Default]]
    [[`Sequence`]           [An arbitrary Fusion __forward_sequence__]
                                                            []]
]

[variablelist Notation
    [[`RV`]            [A `repetitive_view` type]]
    [[`s`]             [An instance of `Sequences`]]
    [[`rv`, `rv1`, `rv2`]    [Instances of `RV`]]
]

[heading Expression Semantics]

[table
    [[Expression]           [Return Type]          [Semantics]]
    [[`RV(s)`]              []                     [Creates an `repetitive_view` given the underlying sequence.]]
    [[`RV(rv1)`]            []                     [Copy constructs an `repetitive_view` from another `repetitive_view`, `rv1`.]]
    [[`rv1 = rv2`]          []                     [Assigns to a `repetitive_view`, `rv1`, from another `repetitive_view`, `rv2`.]]
    [[`__begin__(rv)`]      [__forward_iterator__] []]
    [[`__end__(rv)`]       [__forward_iterator__] [Creates an unreachable iterator (since the sequnce is infinite)]]
]

[heading Result Type Expressions]

[table
    [[Expression]]
    [[`__result_of_begin__<RV>::type`]]
    [[`__result_of_end__<RV>::type`]]
]

[heading Example]
    typedef __vector__<int, char, double> vec1;
    typedef __vector__<int, char, double, int, char> vec2;

    vec1 v1(1, 'c', 2.0);
    vec2 v2(repetitive_view<vec1>(v1));

    std::cout << v2 << std::endl; // 1, 'c', 2.0, 1, 'c'

[endsect]

[endsect]
