Views that adapt a range for an algorithm without copying it.
A view wraps one or several ranges and presents them as one: eve::algo::views::zip walks several ranges in step and hands the callable a tuple, eve::algo::views::convert reads a range as another type, eve::algo::views::reverse walks it backwards, eve::algo::views::map applies a function on the way in and on the way out, and eve::algo::views::iota is a range of consecutive values. A view is itself a range an algorithm or another view accepts.
Classes | |
| struct | eve::algo::views::backward_iterator< I > |
| An adapter over a relaxed_iterator that replaces going forward with going backward. For semantic of reverse you should use eve::algo::views::reverse this is just a helper to do backward algorithms. Should be created by a call to eve::algo::views::backward. More... | |
| struct | eve::algo::views::backward_range< R > |
| An adapter over a relaxed_range that replaces going forward with going backward. For semantic of reverse you should use eve::algo::views::reverse this is just a helper to do backward algorithms. Should be created by a call to eve::algo::views::backward. More... | |
| struct | eve::algo::views::converting_iterator< I, T > |
| An adapter over a relaxed_iterator that converts it's values to T. Should be created via convert. More... | |
| struct | eve::algo::views::converting_range< R, T > |
| An adapter over a relaxed_range that converts it's values to T. Should be created via convert. More... | |
| struct | eve::algo::views::iota_with_step_iterator< T, N > |
| An iterator for all values from base to offset. Should be created with iota_with_step or iota. Not OK to compare two iterators generated from a different base. More... | |
| struct | eve::algo::views::map_iterator< I, LoadOp, StoreOp > |
| An iterator for map, map_convert. Should be created with one of those functions. If one of the operations is not available, it's eve::algo::nothing_t. More... | |
| struct | eve::algo::views::map_range< R, LoadOp, StoreOp > |
| A range for map, map_covnert. Should be created via one of those functions. If the store operation is not available, it's eve::algo::nothing_t. More... | |
| struct | eve::algo::views::reverse_iterator< I > |
| An adapter over a relaxed_iterator that allows to iterate in the reverse order. Should be created by a call to eve::algo::views::reverse. More... | |
| struct | eve::algo::views::reverse_range< R > |
| An adapter over a relaxed_range that allows to iterate in the reverse order. Should be created by a call to eve::algo::views::reverse. NOTE: at this point convert(reverse) will not do anything smart. More... | |
| struct | eve::algo::views::zip_range< Rngs > |
| A relaxed_range on top of multiple relaxed_range. All individual components have to have the same size. Should probably never be created directly, instead use zip. More... | |
| struct | eve::algo::views::zip_iterator< Is > |
| A relaxed_iterator on top of multiple relaxed_iterator. If all of the components are iterator they have to have the same cardinal and the zip_iterator will model iterator. Should probably never be created directly, use zip. More... | |
| struct | backward_iterator |
| a shorthand for eve::algo::views::backward_iterator More... | |
| struct | backward_range |
| a shorthand for eve::algo::views::backward_range More... | |
| struct | converting_iterator |
| a shorthand for eve::algo::views::converting_iterator More... | |
| struct | converting_range |
| a shorthand for eve::algo::views::converting_range More... | |
| struct | iota_with_step_iterator |
| a shorthand for eve::algo::views::iota_with_step_iterator More... | |
| struct | reverse_iterator |
| a shorthand for eve::algo::views::reverse_iterator More... | |
| struct | reverse_range |
| a shorthand for eve::algo::views::reverse_range More... | |
| struct | zip_iterator |
| a shorthand for eve::algo::views::zip_iterator More... | |
| struct | zip_range |
| a shorthand for eve::algo::views::zip_range More... | |
Variables | |
| struct eve::algo::views::backward_ | eve::algo::views::backward |
| Takes an iterator or a range and returns an adapter for backward iteration. For semantic of reverse you should use eve::algo::views::reverse this is just a helper to do backward algorithms. | |
| struct eve::algo::views::convert_ | eve::algo::views::convert |
| Takes an iterator or a range and returns an adapter that has a provided value type. | |
| struct { | |
| } | eve::algo::views::iota_with_step |
| A function to generate an iota with a step i.e. a general arithmetic sequence. To generate an iterator pass T base, T step. For a range pass a range size as ptrdiff_t as a 3rd parameter. | |
| struct { | |
| } | eve::algo::views::iota |
| A function to generate an iota iterator/view like [0.5, 2.5, 4.5, ...]. \((0.5 + 2(n-1))_{n \in \N}\) To generate an iterator base + (n-1) step pass T base and T step. For a range pass a range size as ptrdiff_t as a 2nd parameter. | |
| struct { | |
| } | eve::algo::views::map_convert |
| Given a relaxed iterator/range and 2 operations return relaxed iterator/range that applies the first operation before load and the second operation before store. | |
| struct { | |
| } | eve::algo::views::map |
| Given a relaxed iterator/range and an operation return relaxed iterator/range that has no store and applies provided operation on read/load. | |
| struct eve::algo::views::reverse_ | eve::algo::views::reverse |
| Takes an iterator or a range and returns an adapter for reverse iteration. | |
| constexpr auto | eve::algo::views::zip = function_with_traits<zip_> |
| Given relaxed_iterors and relaxed ranges, zips them together (creates a single object). If at least one component is a relaxed_range - result is a zip_range, otherwise it's zip_iterator. All range compinents have to have the same length. NOTE: uses range_ref inside, so never owns/copies any elements. | |
| struct eve::algo::views::backward_ eve::algo::views::backward |
Takes an iterator or a range and returns an adapter for backward iteration. For semantic of reverse you should use eve::algo::views::reverse this is just a helper to do backward algorithms.
Required header: #include <eve/module/algo/algo/views/backward.hpp>
Has a shorthand eve::views::backward in <eve/views/backward.hpp>.
| struct eve::algo::views::convert_ eve::algo::views::convert |
Takes an iterator or a range and returns an adapter that has a provided value type.
Behaviour for a specific iterator/range can be customized via tagged dispatch:
Required header: #include <eve/module/algo/algo/views/convert.hpp>
Has a shorthand eve::views::convert in <eve/views/convert.hpp>.
| struct { ... } eve::algo::views::iota |
A function to generate an iota iterator/view like [0.5, 2.5, 4.5, ...]. \((0.5 + 2(n-1))_{n \in \N}\) To generate an iterator base + (n-1) step pass T base and T step. For a range pass a range size as ptrdiff_t as a 2nd parameter.
Required header: #include <eve/module/algo/algo/views/iota.hpp>
Has a shorthand eve::views::iota_with_step in <eve/views/iota.hpp>.
| struct { ... } eve::algo::views::iota_with_step |
A function to generate an iota with a step i.e. a general arithmetic sequence. To generate an iterator pass T base, T step. For a range pass a range size as ptrdiff_t as a 3rd parameter.
Example: iota_with_step(0.1, 0.2, 4) is a range [0.1, 0.3, 0.5, 0.7]
Required header: #include <eve/module/algo/algo/views/iota.hpp>
Has a shorthand eve::views::iota_with_step in <eve/views/iota.hpp>.
| struct { ... } eve::algo::views::map |
Given a relaxed iterator/range and an operation return relaxed iterator/range that has no store and applies provided operation on read/load.
operation has to be a template and accept scalar and all width wides for the value type of the underlying iterator/range.
Required header: #include <eve/module/algo/algo/views/map.hpp>
Has a shorthand eve::views::map in <eve/views/map.hpp>
| struct { ... } eve::algo::views::map_convert |
Given a relaxed iterator/range and 2 operations return relaxed iterator/range that applies the first operation before load and the second operation before store.
operations has to be a template and accept scalar and all width wides for the value type of the underlying iterator/range.
store operation, for conviniece accepts the as<underlying_type> as a second parameter. (this allows to define load/store ops without knowing the underlying iterator).
Required header: #include <eve/module/algo/algo/views/map.hpp>
Has a shorthand eve::views::map_convert in <eve/views/map.hpp>
| struct eve::algo::views::reverse_ eve::algo::views::reverse |
Takes an iterator or a range and returns an adapter for reverse iteration.
Required header: #include <eve/module/algo/algo/views/reverse.hpp>
Has a shorthand eve::views::reverse in <eve/views/reverse.hpp>.
|
inlineconstexpr |
Given relaxed_iterors and relaxed ranges, zips them together (creates a single object). If at least one component is a relaxed_range - result is a zip_range, otherwise it's zip_iterator. All range compinents have to have the same length. NOTE: uses range_ref inside, so never owns/copies any elements.
Supports zip[eve::algo::force_type<T>], zip[eve::algo::common_type<T>], zip[common_with_types<Ts...>] traits. force_type<T> will convert every component to the type T. common_type and common_with_types will compute the common type (maybe including extra provided), and convert to that.
Required header: #include <eve/module/algo/algo/views/zip.hpp>
Has a shorthand eve::views::zip in <eve/views/zip.hpp>.
