Lumiera  0.pre.03
»edit your freedom«
IterStateWrapper< T, ST > Class Template Reference

#include "lib/iter-adapter.hpp"

Description

template<typename T, class ST = T>
class lib::IterStateWrapper< T, ST >

Another Lumiera Forward Iterator building block, based on incorporating a state type right into the iterator.

Contrast this to IterAdapter, which refers to a managing container behind the scenes. Here, all of the state is assumed to live in the custom type embedded into this iterator, accessed and manipulated through a set of free functions, picked up through ADL.

Assumptions when building iterators based on IterStateWrapper
There is a custom state representation type ST.
  • default constructible
  • this default state represents the bottom (invalid) state.
  • copyable, because iterators are passed by value
  • this type needs to provide an iteration control API with the following operations
    1. checkPoint establishes if the given state element represents a valid state
    2. iterNext evolves this state by one step (sideeffect)
    3. yield realises the given state, yielding an element of result type T&
Template Parameters
Tnominal result type (maybe const, but without reference). The resulting iterator will yield a reference to this type T
STtype of the »state core«, defaults to T. The resulting iterator will hold an instance of ST, which thus needs to be copyable and default constructible to the extent this is required for the iterator as such.
See also
IterableDecorator for variation of the same concept
iter-explorer-test.hpp
iter-adaptor-test.cpp

Definition at line 342 of file iter-adapter.hpp.

Public Types

typedef T * pointer
 
typedef T & reference
 
typedef T value_type
 

Public Member Functions

 IterStateWrapper (ST &&initialState)
 
 IterStateWrapper (ST const &initialState)
 
bool empty () const
 
 ENABLE_USE_IN_STD_RANGE_FOR_LOOPS (IterStateWrapper)
 
bool isValid () const
 
 operator bool () const
 
reference operator* () const
 
IterStateWrapperoperator++ ()
 
pointer operator-> () const
 

Friends

template<class T1 , class T2 , class STX >
bool operator== (IterStateWrapper< T1, STX > const &, IterStateWrapper< T2, STX > const &)
 comparison is allowed to access state implementation core
 

Protected Member Functions

void __throw_if_empty () const
 
ST & stateCore ()
 allow derived classes to access state representation
 

Private Attributes

ST core_
 
+ Inheritance diagram for IterStateWrapper< T, ST >:
+ Collaboration diagram for IterStateWrapper< T, ST >:

The documentation for this class was generated from the following file: