SkSpan< T > Class Template Reference

#include <SkSpan_impl.h>

Public Member Functions
constexpr	SkSpan ()
template<typename Integer , std::enable_if_t< std::is_integral_v< Integer >, bool > = true>
constexpr	SkSpan (T *ptr, Integer size)
template<typename U , typename = std::enable_if_t<std::is_same_v<const U, T>>>
constexpr	SkSpan (const SkSpan< U > &that)
constexpr	SkSpan (const SkSpan &o)=default
template<size_t N>
constexpr	SkSpan (T(&a)[N])
template<typename Container >
constexpr	SkSpan (Container &&c)
	SkSpan (std::initializer_list< T > il SK_CHECK_IL_LIFETIME)
constexpr SkSpan &	operator= (const SkSpan &that)=default
constexpr T &	operator[] (size_t i) const
constexpr T &	front () const
constexpr T &	back () const
constexpr T *	begin () const
constexpr T *	end () const
constexpr auto	rbegin () const
constexpr auto	rend () const
constexpr T *	data () const
constexpr size_t	size () const
constexpr bool	empty () const
constexpr size_t	size_bytes () const
constexpr SkSpan< T >	first (size_t prefixLen) const
constexpr SkSpan< T >	last (size_t postfixLen) const
constexpr SkSpan< T >	subspan (size_t offset) const
constexpr SkSpan< T >	subspan (size_t offset, size_t count) const

Detailed Description

template<typename T>
class SkSpan< T >

SkSpan holds a reference to contiguous data of type T along with a count. SkSpan does not own the data itself but is merely a reference, therefore you must take care with the lifetime of the underlying data.

SkSpan is a count and a pointer into existing array or data type that stores its data in contiguous memory like std::vector. Any container that works with std::size() and std::data() can be used.

SkSpan makes a convenient parameter for a routine to accept array like things. This allows you to write the routine without overloads for all different container types.

Example: void routine(SkSpan<const int> a) { ... }

std::vector v = {1, 2, 3, 4, 5};

routine(a);

A word of caution when working with initializer_list, initializer_lists have a lifetime that is limited to the current statement. The following is correct and safe:

Example: routine({1,2,3,4,5});

The following is undefined, and will result in erratic execution:

Bad Example: initializer_list l = {1, 2, 3, 4, 5}; // The data behind l dies at the ;. routine(l);

Definition at line 65 of file SkSpan_impl.h.

Constructor & Destructor Documentation

SkSpan() [1/7]

template<typename T >

constexpr SkSpan< T >::SkSpan ( )

inlineconstexpr

Definition at line 67 of file SkSpan_impl.h.

: fPtr{nullptr}, fSize{0} {}

SkSpan() [2/7]

template<typename T >

template<typename Integer , std::enable_if_t< std::is_integral_v< Integer >, bool > = true>

constexpr SkSpan< T >::SkSpan ( T *  ptr, Integer  size  )

inlineconstexpr

Definition at line 70 of file SkSpan_impl.h.

                                           : fPtr{ptr}, fSize{SkToSizeT(size)} {
        SkASSERT(ptr || fSize == 0);  // disallow nullptr + a nonzero size
        SkASSERT(fSize < kMaxSize);
    }

SkSpan() [3/7]

template<typename T >

template<typename U , typename = std::enable_if_t<std::is_same_v<const U, T>>>

constexpr SkSpan< T >::SkSpan ( const SkSpan< U > &  that )

inlineconstexpr

Definition at line 75 of file SkSpan_impl.h.

: fPtr(std::data(that)), fSize(std::size(that)) {}

SkSpan() [4/7]

template<typename T >

constexpr SkSpan< T >::SkSpan ( const SkSpan< T > &  o )

constexprdefault

SkSpan() [5/7]

template<typename T >

template<size_t N>

constexpr SkSpan< T >::SkSpan ( T(&)  a[N] )

inlineconstexpr

Definition at line 77 of file SkSpan_impl.h.

: SkSpan(a, N) { }

SkSpan() [6/7]

template<typename T >

template<typename Container >

constexpr SkSpan< T >::SkSpan ( Container &&  c )

inlineconstexpr

Definition at line 79 of file SkSpan_impl.h.

: SkSpan(std::data(c), std::size(c)) { }

SkSpan() [7/7]

template<typename T >

SkSpan< T >::SkSpan ( std::initializer_list< T > il  SK_CHECK_IL_LIFETIME )

inline

Definition at line 80 of file SkSpan_impl.h.

            : SkSpan(std::data(il), std::size(il)) {}

Member Function Documentation

back()

template<typename T >

constexpr T & SkSpan< T >::back ( ) const

inlineconstexpr

Definition at line 89 of file SkSpan_impl.h.

{ sk_collection_not_empty(this->empty()); return fPtr[fSize - 1]; }

begin()

template<typename T >

constexpr T * SkSpan< T >::begin ( ) const

inlineconstexpr

Definition at line 90 of file SkSpan_impl.h.

{ return fPtr; }

data()

template<typename T >

constexpr T * SkSpan< T >::data ( ) const

inlineconstexpr

Definition at line 94 of file SkSpan_impl.h.

{ return this->begin(); }

empty()

template<typename T >

constexpr bool SkSpan< T >::empty ( ) const

inlineconstexpr

Definition at line 96 of file SkSpan_impl.h.

{ return fSize == 0; }

end()

template<typename T >

constexpr T * SkSpan< T >::end ( ) const

inlineconstexpr

Definition at line 91 of file SkSpan_impl.h.

{ return fPtr + fSize; }

first()

template<typename T >

constexpr SkSpan< T > SkSpan< T >::first ( size_t  prefixLen ) const

inlineconstexpr

Definition at line 98 of file SkSpan_impl.h.

                                                      {
        return SkSpan{fPtr, sk_collection_check_length(prefixLen, fSize)};
    }

front()

template<typename T >

constexpr T & SkSpan< T >::front ( ) const

inlineconstexpr

Definition at line 88 of file SkSpan_impl.h.

{ sk_collection_not_empty(this->empty()); return fPtr[0]; }

last()

template<typename T >

constexpr SkSpan< T > SkSpan< T >::last ( size_t  postfixLen ) const

inlineconstexpr

Definition at line 101 of file SkSpan_impl.h.

                                                      {
        return SkSpan{fPtr + (this->size() - postfixLen),
                      sk_collection_check_length(postfixLen, fSize)};
    }

operator=()

template<typename T >

constexpr SkSpan & SkSpan< T >::operator= ( const SkSpan< T > &  that )

constexprdefault

operator[]()

template<typename T >

constexpr T & SkSpan< T >::operator[] ( size_t  i ) const

inlineconstexpr

Definition at line 85 of file SkSpan_impl.h.

                                              {
        return fPtr[sk_collection_check_bounds(i, this->size())];
    }

rbegin()

template<typename T >

constexpr auto SkSpan< T >::rbegin ( ) const

inlineconstexpr

Definition at line 92 of file SkSpan_impl.h.

{ return std::make_reverse_iterator(this->end()); }

rend()

template<typename T >

constexpr auto SkSpan< T >::rend ( ) const

inlineconstexpr

Definition at line 93 of file SkSpan_impl.h.

{ return std::make_reverse_iterator(this->begin()); }

size()

template<typename T >

constexpr size_t SkSpan< T >::size ( ) const

inlineconstexpr

Definition at line 95 of file SkSpan_impl.h.

{ return fSize; }

size_bytes()

template<typename T >

constexpr size_t SkSpan< T >::size_bytes ( ) const

inlineconstexpr

Definition at line 97 of file SkSpan_impl.h.

{ return fSize * sizeof(T); }

subspan() [1/2]

template<typename T >

constexpr SkSpan< T > SkSpan< T >::subspan ( size_t  offset ) const

inlineconstexpr

Definition at line 105 of file SkSpan_impl.h.

                                                     {
        return this->subspan(offset, this->size() - offset);
    }

subspan() [2/2]

template<typename T >

constexpr SkSpan< T > SkSpan< T >::subspan ( size_t  offset, size_t  count  ) const

inlineconstexpr

Definition at line 108 of file SkSpan_impl.h.

                                                                   {
        const size_t safeOffset = sk_collection_check_length(offset, fSize);
 
        // Should read offset + count > size(), but that could overflow. We know that safeOffset
        // is <= size, therefore the subtraction will not overflow.
        if (count > this->size() - safeOffset) SK_UNLIKELY {
            // The count is too large.
            SkUNREACHABLE;
        }
        return SkSpan{fPtr + safeOffset, count};
    }

---

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

• third_party/skia/include/private/base/SkSpan_impl.h