SkDataTable Class Reference

#include <SkDataTable.h>

Inheritance diagram for SkDataTable:

Public Types
typedef void(*	FreeProc) (void *context)

Public Member Functions
bool	isEmpty () const
int	count () const
size_t	atSize (int index) const
const void *	at (int index, size_t *size=nullptr) const
template<typename T >
const T *	atT (int index, size_t *size=nullptr) const
const char *	atStr (int index) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< SkDataTable >	MakeEmpty ()
static sk_sp< SkDataTable >	MakeCopyArrays (const void *const *ptrs, const size_t sizes[], int count)
static sk_sp< SkDataTable >	MakeCopyArray (const void *array, size_t elemSize, int count)
static sk_sp< SkDataTable >	MakeArrayProc (const void *array, size_t elemSize, int count, FreeProc proc, void *context)

Private Member Functions
	~SkDataTable () override

Friends
class	SkDataTableBuilder

Detailed Description

Like SkData, SkDataTable holds an immutable data buffer. The data buffer is organized into a table of entries, each with a length, so the entries are not required to all be the same size.

Definition at line 23 of file SkDataTable.h.

Member Typedef Documentation

FreeProc

typedef void(* SkDataTable::FreeProc) (void *context)

Definition at line 66 of file SkDataTable.h.

Member Function Documentation

at()

const void * SkDataTable::at	(	int	index,
		size_t *	size = nullptr
	)		const

Return a pointer to the data of the index'th entry in the table. The caller must ensure that index is valid for this table.

Parameters

size	If non-null, this returns the byte size of this entry. This will be the same value that atSize(index) would return.

Definition at line 67 of file SkDataTable.cpp.

                                                         {
    SkASSERT((unsigned)index < (unsigned)fCount);
 
    if (fElemSize) {
        if (size) {
            *size = fElemSize;
        }
        return fU.fElems + index * fElemSize;
    } else {
        if (size) {
            *size = fU.fDir[index].fSize;
        }
        return fU.fDir[index].fPtr;
    }
}

atSize()

size_t SkDataTable::atSize

(

int

index

)

const

Return the size of the index'th entry in the table. The caller must ensure that index is valid for this table.

Definition at line 57 of file SkDataTable.cpp.

                                          {
    SkASSERT((unsigned)index < (unsigned)fCount);
 
    if (fElemSize) {
        return fElemSize;
    } else {
        return fU.fDir[index].fSize;
    }
}

atStr()

const char * SkDataTable::atStr ( int  index ) const

inline

Returns the index'th entry as a c-string, and assumes that the trailing null byte had been copied into the table as well.

Definition at line 59 of file SkDataTable.h.

                                       {
        size_t size;
        const char* str = this->atT<const char>(index, &size);
        SkASSERT(strlen(str) + 1 == size);
        return str;
    }

atT()

template<typename T >

const T * SkDataTable::atT ( int  index, size_t *  size = nullptr  ) const

inline

Definition at line 51 of file SkDataTable.h.

                                                          {
        return reinterpret_cast<const T*>(this->at(index, size));
    }

count()

int SkDataTable::count ( ) const

inline

Return the number of entries in the table. 0 for an empty table

Definition at line 33 of file SkDataTable.h.

{ return fCount; }

isEmpty()

bool SkDataTable::isEmpty ( ) const

inline

Returns true if the table is empty (i.e. has no entries).

Definition at line 28 of file SkDataTable.h.

{ return 0 == fCount; }

MakeArrayProc()

sk_sp< SkDataTable > SkDataTable::MakeArrayProc ( const void *  array, size_t  elemSize, int  count, FreeProc  proc, void *  context  )

static

Definition at line 130 of file SkDataTable.cpp.

                                                                        {
    if (count <= 0) {
        return SkDataTable::MakeEmpty();
    }
    return sk_sp<SkDataTable>(new SkDataTable(array, elemSize, count, proc, ctx));
}

MakeCopyArray()

sk_sp< SkDataTable > SkDataTable::MakeCopyArray ( const void *  array, size_t  elemSize, int  count  )

static

Return a new table that contains a copy of the data in array.

Parameters

array	contiguous array of data for all elements to be copied.
elemSize	byte-length for a given element.
count	the number of entries to be copied out of array. The number of bytes that will be copied is count * elemSize.

Definition at line 118 of file SkDataTable.cpp.

                                                                                           {
    if (count <= 0) {
        return SkDataTable::MakeEmpty();
    }
 
    size_t bufferSize = elemSize * count;
    void* buffer = sk_malloc_throw(bufferSize);
    memcpy(buffer, array, bufferSize);
 
    return sk_sp<SkDataTable>(new SkDataTable(buffer, elemSize, count, malloc_freeproc, buffer));
}

MakeCopyArrays()

sk_sp< SkDataTable > SkDataTable::MakeCopyArrays ( const void *const *  ptrs, const size_t  sizes[], int  count  )

static

Return a new DataTable that contains a copy of the data stored in each "array".

Parameters

ptrs	array of points to each element to be copied into the table.
sizes	array of byte-lengths for each entry in the corresponding ptrs[] array.
count	the number of array elements in ptrs[] and sizes[] to copy.

Definition at line 92 of file SkDataTable.cpp.

                                                                                {
    if (count <= 0) {
        return SkDataTable::MakeEmpty();
    }
 
    size_t dataSize = 0;
    for (int i = 0; i < count; ++i) {
        dataSize += sizes[i];
    }
 
    size_t bufferSize = count * sizeof(Dir) + dataSize;
    void* buffer = sk_malloc_throw(bufferSize);
 
    Dir* dir = (Dir*)buffer;
    char* elem = (char*)(dir + count);
    for (int i = 0; i < count; ++i) {
        dir[i].fPtr = elem;
        dir[i].fSize = sizes[i];
        memcpy(elem, ptrs[i], sizes[i]);
        elem += sizes[i];
    }
 
    return sk_sp<SkDataTable>(new SkDataTable(dir, count, malloc_freeproc, buffer));
}

MakeEmpty()

sk_sp< SkDataTable > SkDataTable::MakeEmpty ( )

static

Definition at line 85 of file SkDataTable.cpp.

                                          {
    static SkDataTable* singleton;
    static SkOnce once;
    once([]{ singleton = new SkDataTable(); });
    return sk_ref_sp(singleton);
}

~SkDataTable()

SkDataTable::~SkDataTable ( )

overrideprivate

Definition at line 51 of file SkDataTable.cpp.

                          {
    if (fFreeProc) {
        fFreeProc(fFreeProcContext);
    }
}

Friends And Related Symbol Documentation

SkDataTableBuilder

friend class SkDataTableBuilder

friend

Definition at line 117 of file SkDataTable.h.

Member Data Documentation

fDir

const Dir* SkDataTable::fDir

Definition at line 104 of file SkDataTable.h.

fElems

const char* SkDataTable::fElems

Definition at line 105 of file SkDataTable.h.

---

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

• third_party/skia/include/core/SkDataTable.h
• third_party/skia/src/core/SkDataTable.cpp