#include <SkTArray.h>

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 (SkSpan< const T > data)

	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)

template<int InitialCapacity>
	TArray (SkSpan< const T > data, 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/10]

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.

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

◆ TArray() [2/10]

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.

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

skia_private::TArray::TArray

TArray()

Definition: SkTArray.h:47

skia_private::TArray::reserve_exact

void reserve_exact(int n)

Definition: SkTArray.h:181

◆ TArray() [3/10]

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.

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

◆ TArray() [4/10]

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/10]

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/10]

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

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

inline

Creates a TArray by copying contents from an SkSpan. The new array will be heap allocated.

Definition at line 84 of file SkTArray.h.

84: TArray(data.begin(), static_cast<int>(data.size())) {}

skia_private::TArray::data

T * data()

Definition: SkTArray.h:419

◆ TArray() [7/10]

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 89 of file SkTArray.h.

89: 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 133 of file SkTArray.h.

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

◆ TArray() [8/10]

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 526 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() [9/10]

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 545 of file SkTArray.h.

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

◆ TArray() [10/10]

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

template<int InitialCapacity>

skia_private::TArray< T, MEM_MOVE >::TArray	(	SkSpan< const T >	data,
		SkAlignedSTStorage< InitialCapacity, T > *	storage
	)

inlineprotected

Definition at line 550 of file SkTArray.h.

            : TArray{storage, static_cast<int>(data.size())} {
        this->copy(data.begin());
    }

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 461 of file SkTArray.h.

461{ return (*this)[i]; }

i

int i

Definition: fl_socket_accessible.cc:18

◆ 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 462 of file SkTArray.h.

462{ 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 480 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 485 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 398 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 401 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 518 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 425 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 419 of file SkTArray.h.

419{ 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 420 of file SkTArray.h.

420{ 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 248 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 199 of file SkTArray.h.

199{ 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 407 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 413 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 493 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 497 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 467 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 472 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 383 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 307 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 514 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 91 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 102 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 501 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 453 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 457 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 321 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 330 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 205 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 214 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 231 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 267 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 280 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 293 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 188 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 170 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 181 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 157 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 144 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 423 of file SkTArray.h.

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

skia_private::TArray::resize_back

void resize_back(int newCount)

Definition: SkTArray.h:343

◆ 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 343 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 430 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 421 of file SkTArray.h.

421{ 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 422 of file SkTArray.h.

422{ 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 358 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

Public Types

Public Member Functions

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ value_type

Constructor & Destructor Documentation

◆ TArray() [1/10]

◆ TArray() [2/10]

◆ TArray() [3/10]

◆ TArray() [4/10]

◆ TArray() [5/10]

◆ TArray() [6/10]

◆ TArray() [7/10]

◆ ~TArray()

◆ TArray() [8/10]

◆ TArray() [9/10]

◆ TArray() [10/10]

Member Function Documentation

◆ at() [1/2]

◆ at() [2/2]

◆ back() [1/2]

◆ back() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ clear()

◆ data() [1/2]

◆ data() [2/2]

◆ emplace_back()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ fromBack() [1/2]

◆ fromBack() [2/2]

◆ front() [1/2]

◆ front() [2/2]

◆ move_back()

◆ move_back_n()

◆ operator!=()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ pop_back()

◆ pop_back_n()

◆ push_back() [1/3]

◆ push_back() [2/3]

◆ push_back() [3/3]

◆ push_back_n() [1/3]

◆ push_back_n() [2/3]

◆ push_back_n() [3/3]

◆ removeShuffle()

◆ reserve()

◆ reserve_exact()

◆ reset() [1/2]

◆ reset() [2/2]

◆ resize()

◆ resize_back()

◆ shrink_to_fit()

◆ size()

◆ size_bytes()

◆ swap()