SkEnumerate< Iter, C > Class Template Reference

#include <SkEnumerate.h>

Public Member Functions
constexpr	SkEnumerate (Iter begin, Iter end)
constexpr	SkEnumerate (C &&c)
constexpr	SkEnumerate (const SkEnumerate &that)=default
constexpr SkEnumerate &	operator= (const SkEnumerate &that)
constexpr Iterator	begin () const
constexpr Iterator	end () const
constexpr bool	empty () const
constexpr size_t	size () const
constexpr ptrdiff_t	ssize () const
constexpr SkEnumerate	first (size_t n)
constexpr SkEnumerate	last (size_t n)
constexpr SkEnumerate	subspan (size_t offset, size_t count)

Detailed Description

template<typename Iter, typename C = std::monostate>
class SkEnumerate< Iter, C >

Definition at line 17 of file SkEnumerate.h.

Constructor & Destructor Documentation

SkEnumerate() [1/3]

template<typename Iter , typename C = std::monostate>

constexpr SkEnumerate< Iter, C >::SkEnumerate ( Iter  begin, Iter  end  )

inlineconstexpr

Definition at line 55 of file SkEnumerate.h.

: SkEnumerate{0, begin, end} {}

SkEnumerate() [2/3]

template<typename Iter , typename C = std::monostate>

constexpr SkEnumerate< Iter, C >::SkEnumerate ( C &&  c )

inlineexplicitconstexpr

Definition at line 56 of file SkEnumerate.h.

            : fCollection{std::move(c)}
            , fBeginIndex{0}
            , fBegin{std::begin(fCollection)}
            , fEnd{std::end(fCollection)} { }

SkEnumerate() [3/3]

template<typename Iter , typename C = std::monostate>

constexpr SkEnumerate< Iter, C >::SkEnumerate ( const SkEnumerate< Iter, C > &  that )

constexprdefault

Member Function Documentation

begin()

template<typename Iter , typename C = std::monostate>

constexpr Iterator SkEnumerate< Iter, C >::begin ( ) const

inlineconstexpr

Definition at line 67 of file SkEnumerate.h.

{ return Iterator{fBeginIndex, fBegin}; }

empty()

template<typename Iter , typename C = std::monostate>

constexpr bool SkEnumerate< Iter, C >::empty ( ) const

inlineconstexpr

Definition at line 69 of file SkEnumerate.h.

{ return fBegin == fEnd; }

end()

template<typename Iter , typename C = std::monostate>

constexpr Iterator SkEnumerate< Iter, C >::end ( ) const

inlineconstexpr

Definition at line 68 of file SkEnumerate.h.

{ return Iterator{fBeginIndex + this->ssize(), fEnd}; }

first()

template<typename Iter , typename C = std::monostate>

constexpr SkEnumerate SkEnumerate< Iter, C >::first ( size_t  n )

inlineconstexpr

Definition at line 72 of file SkEnumerate.h.

                                          {
        SkASSERT(n <= this->size());
        ptrdiff_t deltaEnd = this->ssize() - n;
        return SkEnumerate{fBeginIndex, fBegin, std::prev(fEnd, deltaEnd)};
    }

last()

template<typename Iter , typename C = std::monostate>

constexpr SkEnumerate SkEnumerate< Iter, C >::last ( size_t  n )

inlineconstexpr

Definition at line 77 of file SkEnumerate.h.

                                         {
        SkASSERT(n <= this->size());
        ptrdiff_t deltaBegin = this->ssize() - n;
        return SkEnumerate{fBeginIndex + deltaBegin, std::next(fBegin, deltaBegin), fEnd};
    }

operator=()

template<typename Iter , typename C = std::monostate>

constexpr SkEnumerate & SkEnumerate< Iter, C >::operator= ( const SkEnumerate< Iter, C > &  that )

inlineconstexpr

Definition at line 62 of file SkEnumerate.h.

                                                              {
        fBegin = that.fBegin;
        fEnd = that.fEnd;
        return *this;
    }

size()

template<typename Iter , typename C = std::monostate>

constexpr size_t SkEnumerate< Iter, C >::size ( ) const

inlineconstexpr

Definition at line 70 of file SkEnumerate.h.

{ return std::distance(fBegin,  fEnd); }

ssize()

template<typename Iter , typename C = std::monostate>

constexpr ptrdiff_t SkEnumerate< Iter, C >::ssize ( ) const

inlineconstexpr

Definition at line 71 of file SkEnumerate.h.

{ return std::distance(fBegin,  fEnd); }

subspan()

template<typename Iter , typename C = std::monostate>

constexpr SkEnumerate SkEnumerate< Iter, C >::subspan ( size_t  offset, size_t  count  )

inlineconstexpr

Definition at line 82 of file SkEnumerate.h.

                                                               {
        SkASSERT(offset < this->size());
        SkASSERT(count <= this->size() - offset);
        auto newBegin = std::next(fBegin, offset);
        return SkEnumerate(fBeginIndex + offset, newBegin, std::next(newBegin, count));
    }

---

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

• third_party/skia/src/core/SkEnumerate.h