JUCE: EnumerateIterator< Iter, Index > Class Template Reference

JUCE

- Main Page
- Related Pages
- Topics
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Loading...
Searching...
No Matches
Public Member Functions | List of all members
EnumerateIterator< Iter, Index > Class Template Reference
juce_core » containers

An iterator that wraps some other iterator, keeping track of the relative position of that iterator based on calls to arithmetic operators such as operator++(), operator--(), operator+(), and operator-(). More...

`#include <juce_Enumerate.h>`

## Public Member Functions
constexpr | EnumerateIterator ()=default
| Default constructor.
constexpr | EnumerateIterator (Iter iter)
| Wraps the provided iterator, and sets the internal count to 0.
constexpr | EnumerateIterator (Iter iter, Index ind)
| Wraps the provided iterator, and sets the internal count to the provided value.
template<typename OtherIter , typename OtherInd >
constexpr bool | operator== (const EnumerateIterator< OtherIter, OtherInd > &other) const
| Two EnumerateIterators are considered equal if the wrapped iterators are equal.
template<typename OtherIter , typename OtherInd >
constexpr bool | operator!= (const EnumerateIterator< OtherIter, OtherInd > &other) const
constexpr Enumerated< Index, decltype(*std::declval< Iter >())> | operator* () const
| Dereferencing the iterator produces an Enumerated instance by value.
constexpr EnumerateIterator & | operator++ ()
| Increments the iterator and the index.
constexpr EnumerateIterator | operator++ (int)
| Increments the iterator and the index.
template<typename T = Iter, std::enable_if_t< detail::canPreDecrement< T >, int > = 0>
constexpr EnumerateIterator & | operator-- ()
| Decrements the iterator and the index.
template<typename T = Iter, std::enable_if_t< detail::canPreDecrement< T >, int > = 0>
constexpr EnumerateIterator | operator-- (int)
| Decrements the iterator and the index.
template<typename I , std::enable_if_t< detail::canAddAssign< Iter &, I >, int > = 0>
constexpr EnumerateIterator & | operator+= (I diff)
| Adds an integral value to both the iterator and the index.
template<typename I , std::enable_if_t< detail::canSubAssign< Iter &, I >, int > = 0>
constexpr EnumerateIterator & | operator-= (I diff)
| Subtracts an integral value from both the iterator and the index.
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canSub< Iter, OtherIter >, int > = 0>
constexpr auto | operator- (const EnumerateIterator< OtherIter, OtherInd > &other) const
| Subtracts another enumerate iterator from this one, producing the same result as subtracting the two wrapped iterators.
template<typename I , std::enable_if_t< detail::canAdd< EnumerateIterator, I >, int > = 0>
constexpr auto | operator[] (I diff) const
| Indexes into this iterator, equivalent to adding an integral value to this iterator and then dereferencing the result.
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canLessThan< Iter, OtherIter >, int > = 0>
constexpr bool | operator< (const EnumerateIterator< OtherIter, OtherInd > &other) const
| Returns the result of comparing the two wrapped iterators.
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canLessThanEqual< Iter, OtherIter >, int > = 0>
constexpr bool | operator<= (const EnumerateIterator< OtherIter, OtherInd > &other) const
| Returns the result of comparing the two wrapped iterators.
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canGreaterThan< Iter, OtherIter >, int > = 0>
constexpr bool | operator> (const EnumerateIterator< OtherIter, OtherInd > &other) const
| Returns the result of comparing the two wrapped iterators.
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canGreaterThanEqual< Iter, OtherIter >, int > = 0>
constexpr bool | operator>= (const EnumerateIterator< OtherIter, OtherInd > &other) const
| Returns the result of comparing the two wrapped iterators.

## Detailed Description

template<typename Iter, typename Index = ptrdiff_t>
class EnumerateIterator< Iter, Index >

An iterator that wraps some other iterator, keeping track of the relative position of that iterator based on calls to arithmetic operators such as operator++(), operator--(), operator+(), and operator-().

You should never need to construct an instance of this type yourself. Instead, use the enumerate() function to construct a range that can be enumerated.

See also
  enumerate()

## Constructor & Destructor Documentation

## ◆ EnumerateIterator() [1/3]

template<typename Iter , typename Index = ptrdiff_t>

constexpr EnumerateIterator< Iter, Index >::EnumerateIterator | ( |  | ) |
| constexprdefault

Default constructor.

## ◆ EnumerateIterator() [2/3]

template<typename Iter , typename Index = ptrdiff_t>

constexpr EnumerateIterator< Iter, Index >::EnumerateIterator | ( | Iter | iter | ) |
| explicitconstexpr

Wraps the provided iterator, and sets the internal count to 0.

## ◆ EnumerateIterator() [3/3]

template<typename Iter , typename Index = ptrdiff_t>

constexpr EnumerateIterator< Iter, Index >::EnumerateIterator | ( | Iter | iter,
|  | Index | ind
| ) |  |
| constexpr

Wraps the provided iterator, and sets the internal count to the provided value.

## Member Function Documentation

## ◆ operator==()

template<typename Iter , typename Index = ptrdiff_t>
template<typename OtherIter , typename OtherInd >

constexpr bool EnumerateIterator< Iter, Index >::operator== | ( | const EnumerateIterator< OtherIter, OtherInd > & | other | ) | const
| constexpr

Two EnumerateIterators are considered equal if the wrapped iterators are equal.

Referenced by EnumerateIterator< Iter, Index >::operator!=().

## ◆ operator!=()

template<typename Iter , typename Index = ptrdiff_t>
template<typename OtherIter , typename OtherInd >

constexpr bool EnumerateIterator< Iter, Index >::operator!= | ( | const EnumerateIterator< OtherIter, OtherInd > & | other | ) | const
| constexpr

See also
  operator==()

References EnumerateIterator< Iter, Index >::operator==().

## ◆ operator*()

template<typename Iter , typename Index = ptrdiff_t>

constexpr Enumerated< Index, decltype(*std::declval< Iter >())> EnumerateIterator< Iter, Index >::operator* | ( |  | ) | const
| constexpr

Dereferencing the iterator produces an Enumerated instance by value.

This type holds a copy of the iterator's current index, along with the result of dereferencing the wrapped iterator (normally a reference type).

## ◆ operator++() [1/2]

template<typename Iter , typename Index = ptrdiff_t>

constexpr EnumerateIterator & EnumerateIterator< Iter, Index >::operator++ | ( |  | ) |
| constexpr

Increments the iterator and the index.

Referenced by EnumerateIterator< Iter, Index >::operator++().

## ◆ operator++() [2/2]

template<typename Iter , typename Index = ptrdiff_t>

constexpr EnumerateIterator EnumerateIterator< Iter, Index >::operator++ | ( | int |  | ) |
| constexpr

Increments the iterator and the index.

References EnumerateIterator< Iter, Index >::operator++().

## ◆ operator--() [1/2]

template<typename Iter , typename Index = ptrdiff_t>
template<typename T = Iter, std::enable_if_t< detail::canPreDecrement< T >, int > = 0>

constexpr EnumerateIterator & EnumerateIterator< Iter, Index >::operator-- | ( |  | ) |
| constexpr

Decrements the iterator and the index.

Only participates in overload resolution if the iterator can be pre-decremented.

Referenced by EnumerateIterator< Iter, Index >::operator--().

## ◆ operator--() [2/2]

template<typename Iter , typename Index = ptrdiff_t>
template<typename T = Iter, std::enable_if_t< detail::canPreDecrement< T >, int > = 0>

constexpr EnumerateIterator EnumerateIterator< Iter, Index >::operator-- | ( | int |  | ) |
| constexpr

Decrements the iterator and the index.

Only participates in overload resolution if the iterator can be pre-decremented.

References EnumerateIterator< Iter, Index >::operator--().

## ◆ operator+=()

template<typename Iter , typename Index = ptrdiff_t>
template<typename I , std::enable_if_t< detail::canAddAssign< Iter &, I >, int > = 0>

constexpr EnumerateIterator & EnumerateIterator< Iter, Index >::operator+= | ( | I | diff | ) |
| constexpr

Adds an integral value to both the iterator and the index.

Only participates in overload resolution if the iterator can be add-assigned.

## ◆ operator-=()

template<typename Iter , typename Index = ptrdiff_t>
template<typename I , std::enable_if_t< detail::canSubAssign< Iter &, I >, int > = 0>

constexpr EnumerateIterator & EnumerateIterator< Iter, Index >::operator-= | ( | I | diff | ) |
| constexpr

Subtracts an integral value from both the iterator and the index.

Only participates in overload resolution if the iterator can be sub-assigned.

## ◆ operator-()

template<typename Iter , typename Index = ptrdiff_t>
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canSub< Iter, OtherIter >, int > = 0>

constexpr auto EnumerateIterator< Iter, Index >::operator- | ( | const EnumerateIterator< OtherIter, OtherInd > & | other | ) | const
| constexpr

Subtracts another enumerate iterator from this one, producing the same result as subtracting the two wrapped iterators.

For random-access iterators, this will normally return the distance between the two iterators. Only participates in overload resolution if the wrapped iterators can be subtracted.

## ◆ operator[]()

template<typename Iter , typename Index = ptrdiff_t>
template<typename I , std::enable_if_t< detail::canAdd< EnumerateIterator, I >, int > = 0>

constexpr auto EnumerateIterator< Iter, Index >::operator[] | ( | I | diff | ) | const
| constexpr

Indexes into this iterator, equivalent to adding an integral value to this iterator and then dereferencing the result.

Only participates in overload resolution if the wrapped iterator allows addition of integral values.

## ◆ operator<()

template<typename Iter , typename Index = ptrdiff_t>
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canLessThan< Iter, OtherIter >, int > = 0>

constexpr bool EnumerateIterator< Iter, Index >::operator< | ( | const EnumerateIterator< OtherIter, OtherInd > & | other | ) | const
| constexpr

Returns the result of comparing the two wrapped iterators.

Only participates in overload resolution if the wrapped iterators are comparable.

## ◆ operator<=()

template<typename Iter , typename Index = ptrdiff_t>
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canLessThanEqual< Iter, OtherIter >, int > = 0>

constexpr bool EnumerateIterator< Iter, Index >::operator<= | ( | const EnumerateIterator< OtherIter, OtherInd > & | other | ) | const
| constexpr

Returns the result of comparing the two wrapped iterators.

Only participates in overload resolution if the wrapped iterators are comparable.

## ◆ operator>()

template<typename Iter , typename Index = ptrdiff_t>
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canGreaterThan< Iter, OtherIter >, int > = 0>

constexpr bool EnumerateIterator< Iter, Index >::operator> | ( | const EnumerateIterator< OtherIter, OtherInd > & | other | ) | const
| constexpr

Returns the result of comparing the two wrapped iterators.

Only participates in overload resolution if the wrapped iterators are comparable.

## ◆ operator>=()

template<typename Iter , typename Index = ptrdiff_t>
template<typename OtherIter , typename OtherInd , std::enable_if_t< detail::canGreaterThanEqual< Iter, OtherIter >, int > = 0>

constexpr bool EnumerateIterator< Iter, Index >::operator>= | ( | const EnumerateIterator< OtherIter, OtherInd > & | other | ) | const
| constexpr

Returns the result of comparing the two wrapped iterators.

Only participates in overload resolution if the wrapped iterators are comparable.

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

- juce_Enumerate.h