SkTDStorage Class Reference

#include <SkTDArray.h>

Public Member Functions
	SkTDStorage (int sizeOfT)
	SkTDStorage (const void *src, int size, int sizeOfT)
	SkTDStorage (const SkTDStorage &that)
SkTDStorage &	operator= (const SkTDStorage &that)
	SkTDStorage (SkTDStorage &&that)
SkTDStorage &	operator= (SkTDStorage &&that)
	~SkTDStorage ()
void	reset ()
void	swap (SkTDStorage &that)
bool	empty () const
void	clear ()
int	size () const
void	resize (int newSize)
size_t	size_bytes () const
int	capacity () const
void	reserve (int newCapacity)
void	shrink_to_fit ()
void *	data ()
const void *	data () const
void	erase (int index, int count)
void	removeShuffle (int index)
void *	prepend ()
void	append ()
void	append (int count)
void *	append (const void *src, int count)
void *	insert (int index)
void *	insert (int index, int count, const void *src)
void	pop_back ()

Friends
bool	operator== (const SkTDStorage &a, const SkTDStorage &b)
bool	operator!= (const SkTDStorage &a, const SkTDStorage &b)

Detailed Description

Definition at line 20 of file SkTDArray.h.

Constructor & Destructor Documentation

SkTDStorage() [1/4]

SkTDStorage::SkTDStorage ( int  sizeOfT )

explicit

Definition at line 21 of file SkTDArray.cpp.

: fSizeOfT{sizeOfT} {}

SkTDStorage() [2/4]

SkTDStorage::SkTDStorage	(	const void *	src,
		int	size,
		int	sizeOfT
	)

Definition at line 23 of file SkTDArray.cpp.

        : fSizeOfT{sizeOfT}
        , fCapacity{size}
        , fSize{size} {
    if (size > 0) {
        SkASSERT(src != nullptr);
        size_t storageSize = this->bytes(size);
        fStorage = static_cast<std::byte*>(sk_malloc_throw(storageSize));
        memcpy(fStorage, src, storageSize);
    }
}

SkTDStorage() [3/4]

SkTDStorage::SkTDStorage

(

const SkTDStorage &

that

)

Definition at line 35 of file SkTDArray.cpp.

        : SkTDStorage{that.fStorage, that.fSize, that.fSizeOfT} {}

SkTDStorage() [4/4]

SkTDStorage::SkTDStorage

(

SkTDStorage &&

that

)

Definition at line 52 of file SkTDArray.cpp.

        : fSizeOfT{that.fSizeOfT}
        , fStorage(std::exchange(that.fStorage, nullptr))
        , fCapacity{that.fCapacity}
        , fSize{that.fSize} {}

~SkTDStorage()

SkTDStorage::~SkTDStorage

(

)

Definition at line 66 of file SkTDArray.cpp.

                          {
    sk_free(fStorage);
}

Member Function Documentation

append() [1/3]

void SkTDStorage::append

(

)

Definition at line 167 of file SkTDArray.cpp.

                         {
    if (fSize < fCapacity) {
        fSize++;
    } else {
        this->insert(fSize);
    }
}

append() [2/3]

void * SkTDStorage::append	(	const void *	src,
		int	count
	)

Definition at line 185 of file SkTDArray.cpp.

                                                    {
    return this->insert(fSize, count, src);
}

append() [3/3]

void SkTDStorage::append

(

int

count

)

Definition at line 175 of file SkTDArray.cpp.

                                  {
    SkASSERT(count >= 0);
    // Read as: if (fSize + count <= fCapacity) {...}. This is a UB safe way to avoid the add.
    if (fCapacity - fSize >= count) {
        fSize += count;
    } else {
        this->insert(fSize, count, nullptr);
    }
}

capacity()

int SkTDStorage::capacity ( ) const

inline

Definition at line 46 of file SkTDArray.h.

{ return fCapacity; }

clear()

void SkTDStorage::clear ( )

inline

Definition at line 40 of file SkTDArray.h.

{ fSize = 0; }

data() [1/2]

void * SkTDStorage::data ( )

inline

Definition at line 50 of file SkTDArray.h.

{ return fStorage; }

data() [2/2]

const void * SkTDStorage::data ( ) const

inline

Definition at line 51 of file SkTDArray.h.

{ return fStorage; }

empty()

bool SkTDStorage::empty ( ) const

inline

Definition at line 39 of file SkTDArray.h.

{ return fSize == 0; }

erase()

void SkTDStorage::erase	(	int	index,
		int	count
	)

Definition at line 141 of file SkTDArray.cpp.

                                            {
    SkASSERT(count >= 0);
    SkASSERT(fSize >= count);
    SkASSERT(0 <= index && index <= fSize);
 
    if (count > 0) {
        // Check that the resulting size fits in an int. This will abort if not.
        const int newCount = this->calculateSizeOrDie(-count);
        this->moveTail(index, index + count, fSize);
        this->resize(newCount);
    }
}

insert() [1/2]

void * SkTDStorage::insert

(

int

index

)

Definition at line 189 of file SkTDArray.cpp.

                                   {
    return this->insert(index, /*count=*/1, nullptr);
}

insert() [2/2]

void * SkTDStorage::insert	(	int	index,
		int	count,
		const void *	src
	)

Definition at line 193 of file SkTDArray.cpp.

                                                               {
    SkASSERT(0 <= index && index <= fSize);
    SkASSERT(count >= 0);
 
    if (count > 0) {
        const int oldCount = fSize;
        const int newCount = this->calculateSizeOrDie(count);
        this->resize(newCount);
        this->moveTail(index + count, index, oldCount);
 
        if (src != nullptr) {
            this->copySrc(index, src, count);
        }
    }
 
    return this->address(index);
}

operator=() [1/2]

SkTDStorage & SkTDStorage::operator=

(

const SkTDStorage &

that

)

Definition at line 38 of file SkTDArray.cpp.

                                                           {
    if (this != &that) {
        if (that.fSize <= fCapacity) {
            fSize = that.fSize;
            if (fSize > 0) {
                memcpy(fStorage, that.data(), that.size_bytes());
            }
        } else {
            *this = SkTDStorage{that.data(), that.size(), that.fSizeOfT};
        }
    }
    return *this;
}

operator=() [2/2]

SkTDStorage & SkTDStorage::operator=

(

SkTDStorage &&

that

)

Definition at line 58 of file SkTDArray.cpp.

                                                      {
    if (this != &that) {
        this->~SkTDStorage();
        new (this) SkTDStorage{std::move(that)};
    }
    return *this;
}

pop_back()

void SkTDStorage::pop_back ( )

inline

Definition at line 68 of file SkTDArray.h.

                    {
        SkASSERT(fSize > 0);
        fSize--;
    }

prepend()

void * SkTDStorage::prepend

(

)

Definition at line 163 of file SkTDArray.cpp.

                           {
    return this->insert(/*index=*/0);
}

removeShuffle()

void SkTDStorage::removeShuffle

(

int

index

)

Definition at line 154 of file SkTDArray.cpp.

                                         {
    SkASSERT(fSize > 0);
    SkASSERT(0 <= index && index < fSize);
    // Check that the new count is valid.
    const int newCount = this->calculateSizeOrDie(-1);
    this->moveTail(index, fSize - 1, fSize);
    this->resize(newCount);
}

reserve()

void SkTDStorage::reserve

(

int

newCapacity

)

Definition at line 92 of file SkTDArray.cpp.

                                         {
    SkASSERT(newCapacity >= 0);
    if (newCapacity > fCapacity) {
        // Establish the maximum number of elements that includes a valid count for end. In the
        // largest case end() = &fArray[INT_MAX] which is 1 after the last indexable element.
        static constexpr int kMaxCount = INT_MAX;
 
        // Assume that the array will max out.
        int expandedReserve = kMaxCount;
        if (kMaxCount - newCapacity > 4) {
            // Add 1/4 more than we need. Add 4 to ensure this grows by at least 1. Pin to
            // kMaxCount if no room for 1/4 growth.
            int growth = 4 + ((newCapacity + 4) >> 2);
            // Read this line as: if (count + growth < kMaxCount) { ... }
            // It's rewritten to avoid signed integer overflow.
            if (kMaxCount - newCapacity > growth) {
                expandedReserve = newCapacity + growth;
            }
        }
 
 
        // With a T size of 1, the above allocator produces the progression of 7, 15, ... Since,
        // the sizeof max_align_t is often 16, there is no reason to allocate anything less than
        // 16 bytes. This eliminates a realloc when pushing back bytes to an SkTDArray.
        if (fSizeOfT == 1) {
            // Round up to the multiple of 16.
            expandedReserve = (expandedReserve + 15) & ~15;
        }
 
        fCapacity = expandedReserve;
        size_t newStorageSize = this->bytes(fCapacity);
        fStorage = static_cast<std::byte*>(sk_realloc_throw(fStorage, newStorageSize));
    }
}

reset()

void SkTDStorage::reset

(

)

Definition at line 70 of file SkTDArray.cpp.

                        {
    const int sizeOfT = fSizeOfT;
    this->~SkTDStorage();
    new (this) SkTDStorage{sizeOfT};
}

resize()

void SkTDStorage::resize

(

int

newSize

)

Definition at line 84 of file SkTDArray.cpp.

                                    {
    SkASSERT(newSize >= 0);
    if (newSize > fCapacity) {
        this->reserve(newSize);
    }
    fSize = newSize;
}

shrink_to_fit()

void SkTDStorage::shrink_to_fit

(

)

Definition at line 127 of file SkTDArray.cpp.

                                {
    if (fCapacity != fSize) {
        fCapacity = fSize;
        // Because calling realloc with size of 0 is implementation defined, force to a good state
        // by freeing fStorage.
        if (fCapacity > 0) {
            fStorage = static_cast<std::byte*>(sk_realloc_throw(fStorage, this->bytes(fCapacity)));
        } else {
            sk_free(fStorage);
            fStorage = nullptr;
        }
    }
}

size()

int SkTDStorage::size ( ) const

inline

Definition at line 41 of file SkTDArray.h.

{ return fSize; }

size_bytes()

size_t SkTDStorage::size_bytes ( ) const

inline

Definition at line 43 of file SkTDArray.h.

{ return this->bytes(fSize); }

swap()

void SkTDStorage::swap

(

SkTDStorage &

that

)

Definition at line 76 of file SkTDArray.cpp.

                                        {
    SkASSERT(fSizeOfT == that.fSizeOfT);
    using std::swap;
    swap(fStorage, that.fStorage);
    swap(fCapacity, that.fCapacity);
    swap(fSize, that.fSize);
}

Friends And Related Function Documentation

operator!=

bool operator!= ( const SkTDStorage &  a, const SkTDStorage &  b  )

friend

Definition at line 74 of file SkTDArray.h.

                                                                       {
        return !(a == b);
    }

operator==

bool operator== ( const SkTDStorage &  a, const SkTDStorage &  b  )

friend

Definition at line 211 of file SkTDArray.cpp.

                                                            {
    return a.size() == b.size() && (a.empty() || !memcmp(a.data(), b.data(), a.bytes(a.size())));
}

---

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

• third_party/skia/include/private/base/SkTDArray.h
• third_party/skia/src/base/SkTDArray.cpp