skia_private::TArray< T, MEM_MOVE > Class Template Reference

#include <SkTArray.h>

Inheritance diagram for skia_private::TArray< T, MEM_MOVE >:

Public Types
using	value_type = T

Public Member Functions
	TArray ()
	TArray (int reserveCount)
	TArray (const TArray &that)
	TArray (TArray &&that)
	TArray (const T *array, int count)
	TArray (std::initializer_list< T > data)
TArray &	operator= (const TArray &that)
TArray &	operator= (TArray &&that)
	~TArray ()
void	reset (int n)
void	reset (const T *array, int count)
void	reserve (int n)
void	reserve_exact (int n)
void	removeShuffle (int n)
bool	empty () const
T &	push_back ()
T &	push_back (const T &t)
T &	push_back (T &&t)
template<typename... Args>
T &	emplace_back (Args &&... args)
T *	push_back_n (int n)
T *	push_back_n (int n, const T &t)
T *	push_back_n (int n, const T t[])
T *	move_back_n (int n, T *t)
void	pop_back ()
void	pop_back_n (int n)
void	resize_back (int newCount)
void	swap (TArray &that)
void	move_back (TArray &that)
T *	begin ()
const T *	begin () const
T *	end ()
const T *	end () const
T *	data ()
const T *	data () const
int	size () const
size_t	size_bytes () const
void	resize (size_t count)
void	clear ()
void	shrink_to_fit ()
T &	operator[] (int i)
const T &	operator[] (int i) const
T &	at (int i)
const T &	at (int i) const
T &	front ()
const T &	front () const
T &	back ()
const T &	back () const
T &	fromBack (int i)
const T &	fromBack (int i) const
bool	operator== (const TArray< T, MEM_MOVE > &right) const
bool	operator!= (const TArray< T, MEM_MOVE > &right) const
int	capacity () const

Protected Member Functions
template<int InitialCapacity>
	TArray (SkAlignedSTStorage< InitialCapacity, T > *storage, int size=0)
template<int InitialCapacity>
	TArray (const T *array, int size, SkAlignedSTStorage< InitialCapacity, T > *storage)

Detailed Description

template<typename T, bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>
class skia_private::TArray< T, MEM_MOVE >

TArray<T> implements a typical, mostly std::vector-like array. Each T will be default-initialized on allocation, and ~T will be called on destruction.

MEM_MOVE controls the behavior when a T needs to be moved (e.g. when the array is resized)

• true: T will be bit-copied via memcpy.
• false: T will be moved via move-constructors.

Definition at line 40 of file SkTArray.h.

Member Typedef Documentation

value_type

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

using skia_private::TArray< T, MEM_MOVE >::value_type = T

Definition at line 42 of file SkTArray.h.

Constructor & Destructor Documentation

TArray() [1/8]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

skia_private::TArray< T, MEM_MOVE >::TArray ( )

inline

Creates an empty array with no initial storage

Definition at line 47 of file SkTArray.h.

: fOwnMemory(true), fCapacity{0} {}

TArray() [2/8]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

skia_private::TArray< T, MEM_MOVE >::TArray ( int  reserveCount )

inlineexplicit

Creates an empty array that will preallocate space for reserveCount elements.

Definition at line 52 of file SkTArray.h.

: TArray() { this->reserve_exact(reserveCount); }

TArray() [3/8]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

skia_private::TArray< T, MEM_MOVE >::TArray ( const TArray< T, MEM_MOVE > &  that )

inline

Copies one array to another. The new array will be heap allocated.

Definition at line 57 of file SkTArray.h.

: TArray(that.fData, that.fSize) {}

TArray() [4/8]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

skia_private::TArray< T, MEM_MOVE >::TArray ( TArray< T, MEM_MOVE > &&  that )

inline

Definition at line 59 of file SkTArray.h.

                          {
        if (that.fOwnMemory) {
            this->setData(that);
            that.setData({});
        } else {
            this->initData(that.fSize);
            that.move(fData);
        }
        this->changeSize(that.fSize);
        that.changeSize(0);
    }

TArray() [5/8]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

skia_private::TArray< T, MEM_MOVE >::TArray ( const T *  array, int  count  )

inline

Creates a TArray by copying contents of a standard C array. The new array will be heap allocated. Be careful not to use this constructor when you really want the (void*, int) version.

Definition at line 76 of file SkTArray.h.

                                      {
        this->initData(count);
        this->copy(array);
    }

TArray() [6/8]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

skia_private::TArray< T, MEM_MOVE >::TArray ( std::initializer_list< T >  data )

inline

Creates a TArray by copying contents of an initializer list.

Definition at line 84 of file SkTArray.h.

: TArray(data.begin(), data.size()) {}

~TArray()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

skia_private::TArray< T, MEM_MOVE >::~TArray ( )

inline

Definition at line 128 of file SkTArray.h.

              {
        this->destroyAll();
        this->unpoison();
        if (fOwnMemory) {
            sk_free(fData);
        }
    }

TArray() [7/8]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

template<int InitialCapacity>

skia_private::TArray< T, MEM_MOVE >::TArray ( SkAlignedSTStorage< InitialCapacity, T > *  storage, int  size = 0  )

inlineprotected

Definition at line 521 of file SkTArray.h.

                                                                          {
        static_assert(InitialCapacity >= 0);
        SkASSERT(size >= 0);
        SkASSERT(storage->get() != nullptr);
        if (size > InitialCapacity) {
            this->initData(size);
        } else {
            this->setDataFromBytes(*storage);
            this->changeSize(size);
 
            // setDataFromBytes always sets fOwnMemory to true, but we are actually using static
            // storage here, which shouldn't ever be freed.
            fOwnMemory = false;
        }
    }

TArray() [8/8]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

template<int InitialCapacity>

skia_private::TArray< T, MEM_MOVE >::TArray ( const T *  array, int  size, SkAlignedSTStorage< InitialCapacity, T > *  storage  )

inlineprotected

Definition at line 540 of file SkTArray.h.

            : TArray{storage, size} {
        this->copy(array);
    }

Member Function Documentation

at() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T & skia_private::TArray< T, MEM_MOVE >::at ( int  i )

inline

Definition at line 456 of file SkTArray.h.

{ return (*this)[i]; }

at() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

const T & skia_private::TArray< T, MEM_MOVE >::at ( int  i ) const

inline

Definition at line 457 of file SkTArray.h.

{ return (*this)[i]; }

back() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T & skia_private::TArray< T, MEM_MOVE >::back ( )

inline

equivalent to operator[](size() - 1)

Definition at line 475 of file SkTArray.h.

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

back() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

const T & skia_private::TArray< T, MEM_MOVE >::back ( ) const

inline

Definition at line 480 of file SkTArray.h.

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

begin() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T * skia_private::TArray< T, MEM_MOVE >::begin ( )

inline

Definition at line 393 of file SkTArray.h.

               {
        return fData;
    }

begin() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

const T * skia_private::TArray< T, MEM_MOVE >::begin ( ) const

inline

Definition at line 396 of file SkTArray.h.

                           {
        return fData;
    }

capacity()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

int skia_private::TArray< T, MEM_MOVE >::capacity ( ) const

inline

Definition at line 513 of file SkTArray.h.

                         {
        return fCapacity;
    }

clear()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::clear ( )

inline

Definition at line 420 of file SkTArray.h.

                 {
        this->destroyAll();
        this->changeSize(0);
    }

data() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T * skia_private::TArray< T, MEM_MOVE >::data ( )

inline

Definition at line 414 of file SkTArray.h.

{ return fData; }

data() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

const T * skia_private::TArray< T, MEM_MOVE >::data ( ) const

inline

Definition at line 415 of file SkTArray.h.

{ return fData; }

emplace_back()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

template<typename... Args>

T & skia_private::TArray< T, MEM_MOVE >::emplace_back ( Args &&...  args )

inline

Constructs a new T at the back of this array, returning it by reference.

Definition at line 243 of file SkTArray.h.

                                                                {
        this->unpoison();
        T* newT;
        if (this->capacity() > fSize) SK_LIKELY {
            // Emplace the new element in directly.
            newT = new (fData + fSize) T(std::forward<Args>(args)...);
        } else {
            newT = this->growAndConstructAtEnd(std::forward<Args>(args)...);
        }
 
        this->changeSize(fSize + 1);
        return *newT;
    }

empty()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

bool skia_private::TArray< T, MEM_MOVE >::empty ( ) const

inline

Definition at line 194 of file SkTArray.h.

{ return fSize == 0; }

end() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T * skia_private::TArray< T, MEM_MOVE >::end ( )

inline

Definition at line 402 of file SkTArray.h.

             {
        if (fData == nullptr) {
            SkASSERT(fSize == 0);
        }
        return fData + fSize;
    }

end() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

const T * skia_private::TArray< T, MEM_MOVE >::end ( ) const

inline

Definition at line 408 of file SkTArray.h.

                         {
        if (fData == nullptr) {
            SkASSERT(fSize == 0);
        }
        return fData + fSize;
    }

fromBack() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T & skia_private::TArray< T, MEM_MOVE >::fromBack ( int  i )

inline

equivalent to operator[](size()-1-i)

Definition at line 488 of file SkTArray.h.

                       {
        return (*this)[fSize - i - 1];
    }

fromBack() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

const T & skia_private::TArray< T, MEM_MOVE >::fromBack ( int  i ) const

inline

Definition at line 492 of file SkTArray.h.

                                   {
        return (*this)[fSize - i - 1];
    }

front() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T & skia_private::TArray< T, MEM_MOVE >::front ( )

inline

equivalent to operator[](0)

Definition at line 462 of file SkTArray.h.

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

front() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

const T & skia_private::TArray< T, MEM_MOVE >::front ( ) const

inline

Definition at line 467 of file SkTArray.h.

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

move_back()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::move_back ( TArray< T, MEM_MOVE > &  that )

inline

Moves all elements of that to the end of this array, leaving that empty. This is a no-op if that is empty or equal to this array.

Definition at line 378 of file SkTArray.h.

                                 {
        if (that.empty() || &that == this) {
            return;
        }
        void* dst = this->push_back_raw(that.size());
        // After move() returns, the contents of `dst` will have either been in-place initialized
        // using a the move constructor (per-item from `that`'s elements), or will have been
        // mem-copied into when MEM_MOVE is true (now valid objects).
        that.move(dst);
        // All items in `that` have either been destroyed (when MEM_MOVE is false) or should be
        // considered invalid (when MEM_MOVE is true). Reset fSize to 0 directly to skip any further
        // per-item destruction.
        that.changeSize(0);
    }

move_back_n()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T * skia_private::TArray< T, MEM_MOVE >::move_back_n ( int  n, T *  t  )

inline

Version of above that uses the move constructor to set n items.

Definition at line 302 of file SkTArray.h.

                                {
        SkASSERT(n >= 0);
        this->checkRealloc(n, kGrowing);
        T* end = this->end();
        this->changeSize(fSize + n);
        for (int i = 0; i < n; ++i) {
            new (end + i) T(std::move(t[i]));
        }
        return end;
    }

operator!=()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

bool skia_private::TArray< T, MEM_MOVE >::operator!= ( const TArray< T, MEM_MOVE > &  right ) const

inline

Definition at line 509 of file SkTArray.h.

                                                            {
        return !(*this == right);
    }

operator=() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

TArray & skia_private::TArray< T, MEM_MOVE >::operator= ( const TArray< T, MEM_MOVE > &  that )

inline

Definition at line 86 of file SkTArray.h.

                                          {
        if (this == &that) {
            return *this;
        }
        this->clear();
        this->checkRealloc(that.size(), kExactFit);
        this->changeSize(that.fSize);
        this->copy(that.fData);
        return *this;
    }

operator=() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

TArray & skia_private::TArray< T, MEM_MOVE >::operator= ( TArray< T, MEM_MOVE > &&  that )

inline

Definition at line 97 of file SkTArray.h.

                                     {
        if (this != &that) {
            this->clear();
            this->unpoison();
            that.unpoison();
            if (that.fOwnMemory) {
                // The storage is on the heap, so move the data pointer.
                if (fOwnMemory) {
                    sk_free(fData);
                }
 
                fData = std::exchange(that.fData, nullptr);
 
                // Can't use exchange with bitfields.
                fCapacity = that.fCapacity;
                that.fCapacity = 0;
 
                fOwnMemory = true;
 
                this->changeSize(that.fSize);
            } else {
                // The data is stored inline in that, so move it element-by-element.
                this->checkRealloc(that.size(), kExactFit);
                this->changeSize(that.fSize);
                that.move(fData);
            }
            that.changeSize(0);
        }
        return *this;
    }

operator==()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

bool skia_private::TArray< T, MEM_MOVE >::operator== ( const TArray< T, MEM_MOVE > &  right ) const

inline

Definition at line 496 of file SkTArray.h.

                                                            {
        int leftCount = this->size();
        if (leftCount != right.size()) {
            return false;
        }
        for (int index = 0; index < leftCount; ++index) {
            if (fData[index] != right.fData[index]) {
                return false;
            }
        }
        return true;
    }

operator[]() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T & skia_private::TArray< T, MEM_MOVE >::operator[] ( int  i )

inline

Get the i^th element.

Definition at line 448 of file SkTArray.h.

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

operator[]() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

const T & skia_private::TArray< T, MEM_MOVE >::operator[] ( int  i ) const

inline

Definition at line 452 of file SkTArray.h.

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

pop_back()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::pop_back ( )

inline

Removes the last element. Not safe to call when size() == 0.

Definition at line 316 of file SkTArray.h.

                    {
        sk_collection_not_empty(this->empty());
        fData[fSize - 1].~T();
        this->changeSize(fSize - 1);
    }

pop_back_n()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::pop_back_n ( int  n )

inline

Removes the last n elements. Not safe to call when size() < n.

Definition at line 325 of file SkTArray.h.

                           {
        SkASSERT(n >= 0);
        SkASSERT(this->size() >= n);
        int i = fSize;
        while (i-- > fSize - n) {
            (*this)[i].~T();
        }
        this->changeSize(fSize - n);
    }

push_back() [1/3]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T & skia_private::TArray< T, MEM_MOVE >::push_back ( )

inline

Adds one new default-initialized T value and returns it by reference. Note that the reference only remains valid until the next call that adds or removes elements.

Definition at line 200 of file SkTArray.h.

                   {
        void* newT = this->push_back_raw(1);
        return *new (newT) T;
    }

push_back() [2/3]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T & skia_private::TArray< T, MEM_MOVE >::push_back ( const T &  t )

inline

Adds one new T value which is copy-constructed, returning it by reference. As always, the reference only remains valid until the next call that adds or removes elements.

Definition at line 209 of file SkTArray.h.

                             {
        this->unpoison();
        T* newT;
        if (this->capacity() > fSize) SK_LIKELY {
            // Copy over the element directly.
            newT = new (fData + fSize) T(t);
        } else {
            newT = this->growAndConstructAtEnd(t);
        }
 
        this->changeSize(fSize + 1);
        return *newT;
    }

push_back() [3/3]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T & skia_private::TArray< T, MEM_MOVE >::push_back ( T &&  t )

inline

Adds one new T value which is copy-constructed, returning it by reference.

Definition at line 226 of file SkTArray.h.

                        {
        this->unpoison();
        T* newT;
        if (this->capacity() > fSize) SK_LIKELY {
            // Move over the element directly.
            newT = new (fData + fSize) T(std::move(t));
        } else {
            newT = this->growAndConstructAtEnd(std::move(t));
        }
 
        this->changeSize(fSize + 1);
        return *newT;
    }

push_back_n() [1/3]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T * skia_private::TArray< T, MEM_MOVE >::push_back_n ( int  n )

inline

Allocates n more default-initialized T values, and returns the address of the start of that new range. Note: this address is only valid until the next API call made on the array that might add or remove elements.

Definition at line 262 of file SkTArray.h.

                          {
        SkASSERT(n >= 0);
        T* newTs = TCast(this->push_back_raw(n));
        for (int i = 0; i < n; ++i) {
            new (&newTs[i]) T;
        }
        return newTs;
    }

push_back_n() [2/3]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T * skia_private::TArray< T, MEM_MOVE >::push_back_n ( int  n, const T &  t  )

inline

Version of above that uses a copy constructor to initialize all n items to the same T.

Definition at line 275 of file SkTArray.h.

                                      {
        SkASSERT(n >= 0);
        T* newTs = TCast(this->push_back_raw(n));
        for (int i = 0; i < n; ++i) {
            new (&newTs[i]) T(t);
        }
        return static_cast<T*>(newTs);
    }

push_back_n() [3/3]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

T * skia_private::TArray< T, MEM_MOVE >::push_back_n ( int  n, const T  t[]  )

inline

Version of above that uses a copy constructor to initialize the n items to separate T values.

Definition at line 288 of file SkTArray.h.

                                       {
        SkASSERT(n >= 0);
        this->checkRealloc(n, kGrowing);
        T* end = this->end();
        this->changeSize(fSize + n);
        for (int i = 0; i < n; ++i) {
            new (end + i) T(t[i]);
        }
        return end;
    }

removeShuffle()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::removeShuffle ( int  n )

inline

Definition at line 183 of file SkTArray.h.

                              {
        SkASSERT(n < this->size());
        int newCount = fSize - 1;
        fData[n].~T();
        if (n != newCount) {
            this->move(n, newCount);
        }
        this->changeSize(newCount);
    }

reserve()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::reserve ( int  n )

inline

Ensures there is enough reserved space for at least n elements. This is guaranteed at least until the array size grows above n and subsequently shrinks below n, any version of reset() is called, or reserve() is called again.

Definition at line 165 of file SkTArray.h.

                        {
        SkASSERT(n >= 0);
        if (n > this->size()) {
            this->checkRealloc(n - this->size(), kGrowing);
        }
    }

reserve_exact()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::reserve_exact ( int  n )

inline

Ensures there is enough reserved space for exactly n elements. The same capacity guarantees as above apply.

Definition at line 176 of file SkTArray.h.

                              {
        SkASSERT(n >= 0);
        if (n > this->size()) {
            this->checkRealloc(n - this->size(), kExactFit);
        }
    }

reset() [1/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::reset ( const T *  array, int  count  )

inline

Resets to a copy of a C array and resets any reserve count.

Definition at line 152 of file SkTArray.h.

                                          {
        SkASSERT(count >= 0);
        this->clear();
        this->checkRealloc(count, kExactFit);
        this->changeSize(count);
        this->copy(array);
    }

reset() [2/2]

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::reset ( int  n )

inline

Resets to size() = n newly constructed T objects and resets any reserve count.

Definition at line 139 of file SkTArray.h.

                      {
        SkASSERT(n >= 0);
        this->clear();
        this->checkRealloc(n, kExactFit);
        this->changeSize(n);
        for (int i = 0; i < this->size(); ++i) {
            new (fData + i) T;
        }
    }

resize()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::resize ( size_t  count )

inline

Definition at line 418 of file SkTArray.h.

{ this->resize_back((int)count); }

resize_back()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::resize_back ( int  newCount )

inline

Pushes or pops from the back to resize. Pushes will be default initialized.

Definition at line 338 of file SkTArray.h.

                                   {
        SkASSERT(newCount >= 0);
        if (newCount > this->size()) {
            if (this->empty()) {
                // When the container is completely empty, grow to exactly the requested size.
                this->checkRealloc(newCount, kExactFit);
            }
            this->push_back_n(newCount - fSize);
        } else if (newCount < this->size()) {
            this->pop_back_n(fSize - newCount);
        }
    }

shrink_to_fit()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::shrink_to_fit ( )

inline

Definition at line 425 of file SkTArray.h.

                         {
        if (!fOwnMemory || fSize == fCapacity) {
            return;
        }
        this->unpoison();
        if (fSize == 0) {
            sk_free(fData);
            fData = nullptr;
            fCapacity = 0;
        } else {
            SkSpan<std::byte> allocation = Allocate(fSize);
            this->move(TCast(allocation.data()));
            if (fOwnMemory) {
                sk_free(fData);
            }
            // Poison is applied in `setDataFromBytes`.
            this->setDataFromBytes(allocation);
        }
    }

size()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

int skia_private::TArray< T, MEM_MOVE >::size ( ) const

inline

Definition at line 416 of file SkTArray.h.

{ return fSize; }

size_bytes()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

size_t skia_private::TArray< T, MEM_MOVE >::size_bytes ( ) const

inline

Definition at line 417 of file SkTArray.h.

{ return Bytes(fSize); }

swap()

template<typename T , bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>

void skia_private::TArray< T, MEM_MOVE >::swap ( TArray< T, MEM_MOVE > &  that )

inline

Swaps the contents of this array with that array. Does a pointer swap if possible, otherwise copies the T values.

Definition at line 353 of file SkTArray.h.

                            {
        using std::swap;
        if (this == &that) {
            return;
        }
        if (fOwnMemory && that.fOwnMemory) {
            swap(fData, that.fData);
            swap(fSize, that.fSize);
 
            // Can't use swap because fCapacity is a bit field.
            auto allocCount = fCapacity;
            fCapacity = that.fCapacity;
            that.fCapacity = allocCount;
        } else {
            // This could be more optimal...
            TArray copy(std::move(that));
            that = std::move(*this);
            *this = std::move(copy);
        }
    }

---

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

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