SkDescriptor Class Reference

#include <SkDescriptor.h>

Inheritance diagram for SkDescriptor:

Classes
struct	Entry

Public Member Functions
void	operator delete (void *p)
void *	operator new (size_t)
void *	operator new (size_t, void *p)
void	flatten (SkWriteBuffer &buffer) const
uint32_t	getLength () const
void *	addEntry (uint32_t tag, size_t length, const void *data=nullptr)
void	computeChecksum ()
bool	isValid () const
const void *	findEntry (uint32_t tag, uint32_t *length) const
std::unique_ptr< SkDescriptor >	copy () const
bool	operator== (const SkDescriptor &other) const
bool	operator!= (const SkDescriptor &other) const
uint32_t	getChecksum () const
uint32_t	getCount () const
SkString	dumpRec () const

Static Public Member Functions
static size_t	ComputeOverhead (int entryCount)
static std::unique_ptr< SkDescriptor >	Alloc (size_t length)

Friends
class	SkDescriptorTestHelper
class	SkAutoDescriptor

Detailed Description

Definition at line 24 of file SkDescriptor.h.

Member Function Documentation

addEntry()

void * SkDescriptor::addEntry	(	uint32_t	tag,
		size_t	length,
		const void *	data = nullptr
	)

Definition at line 35 of file SkDescriptor.cpp.

                                                                          {
    SkASSERT(tag);
    SkASSERT(SkAlign4(length) == length);
    SkASSERT(this->findEntry(tag, nullptr) == nullptr);
 
    Entry* entry = (Entry*)((char*)this + fLength);
    entry->fTag = tag;
    entry->fLen = SkToU32(length);
    if (data) {
        memcpy(entry + 1, data, length);
    }
 
    fCount += 1;
    fLength = SkToU32(fLength + sizeof(Entry) + length);
    return (entry + 1);  // return its data
}

Alloc()

std::unique_ptr< SkDescriptor > SkDescriptor::Alloc ( size_t  length )

static

Definition at line 20 of file SkDescriptor.cpp.

                                                             {
    SkASSERT(length >= sizeof(SkDescriptor) && SkAlign4(length) == length);
    void* allocation = ::operator new(length);
    return std::unique_ptr<SkDescriptor>(new (allocation) SkDescriptor{});
}

computeChecksum()

void SkDescriptor::computeChecksum

(

)

Definition at line 52 of file SkDescriptor.cpp.

                                   {
    fChecksum = SkDescriptor::ComputeChecksum(this);
}

ComputeOverhead()

static size_t SkDescriptor::ComputeOverhead ( int  entryCount )

inlinestatic

Definition at line 26 of file SkDescriptor.h.

                                                  {
        SkASSERT(entryCount >= 0);
        return sizeof(SkDescriptor) + entryCount * sizeof(Entry);
    }

copy()

std::unique_ptr< SkDescriptor > SkDescriptor::copy

(

)

const

Definition at line 72 of file SkDescriptor.cpp.

                                                     {
    std::unique_ptr<SkDescriptor> desc = SkDescriptor::Alloc(fLength);
    memcpy(desc.get(), this, fLength);
    return desc;
}

dumpRec()

SkString SkDescriptor::dumpRec

(

)

const

Definition at line 93 of file SkDescriptor.cpp.

                                     {
    const SkScalerContextRec* rec = static_cast<const SkScalerContextRec*>(
            this->findEntry(kRec_SkDescriptorTag, nullptr));
 
    SkString result;
    result.appendf("    Checksum: %x\n", fChecksum);
    if (rec != nullptr) {
        result.append(rec->dump());
    }
    return result;
}

findEntry()

const void * SkDescriptor::findEntry	(	uint32_t	tag,
		uint32_t *	length
	)		const

Definition at line 56 of file SkDescriptor.cpp.

                                                                        {
    const Entry* entry = (const Entry*)(this + 1);
    int count = fCount;
 
    while (--count >= 0) {
        if (entry->fTag == tag) {
            if (length) {
                *length = entry->fLen;
            }
            return entry + 1;
        }
        entry = (const Entry*)((const char*)(entry + 1) + entry->fLen);
    }
    return nullptr;
}

flatten()

void SkDescriptor::flatten

(

SkWriteBuffer &

buffer

)

const

Definition at line 31 of file SkDescriptor.cpp.

                                                      {
    buffer.writePad32(static_cast<const void*>(this), this->fLength);
}

getChecksum()

uint32_t SkDescriptor::getChecksum ( ) const

inline

Definition at line 63 of file SkDescriptor.h.

{ return fChecksum; }

getCount()

uint32_t SkDescriptor::getCount ( ) const

inline

Definition at line 70 of file SkDescriptor.h.

{ return fCount; }

getLength()

uint32_t SkDescriptor::getLength ( ) const

inline

Definition at line 41 of file SkDescriptor.h.

{ return fLength; }

isValid()

bool SkDescriptor::isValid

(

)

const

Definition at line 111 of file SkDescriptor.cpp.

                                 {
    uint32_t count = fCount;
    size_t lengthRemaining = this->fLength;
    if (lengthRemaining < sizeof(SkDescriptor)) {
        return false;
    }
    lengthRemaining -= sizeof(SkDescriptor);
    size_t offset = sizeof(SkDescriptor);
 
    while (lengthRemaining > 0 && count > 0) {
        if (lengthRemaining < sizeof(Entry)) {
            return false;
        }
        lengthRemaining -= sizeof(Entry);
 
        const Entry* entry = (const Entry*)(reinterpret_cast<const char*>(this) + offset);
 
        if (lengthRemaining < entry->fLen) {
            return false;
        }
        lengthRemaining -= entry->fLen;
 
        // rec tags are always a known size.
        if (entry->fTag == kRec_SkDescriptorTag && entry->fLen != sizeof(SkScalerContextRec)) {
            return false;
        }
 
        offset += sizeof(Entry) + entry->fLen;
        count--;
    }
    return lengthRemaining == 0 && count == 0;
}

operator delete()

void SkDescriptor::operator delete

(

void *

p

)

Definition at line 26 of file SkDescriptor.cpp.

{ ::operator delete(p); }

operator new() [1/2]

void * SkDescriptor::operator new

(

size_t

)

Definition at line 27 of file SkDescriptor.cpp.

                                       {
    SK_ABORT("Descriptors are created with placement new.");
}

operator new() [2/2]

void * SkDescriptor::operator new ( size_t  , void *  p  )

inline

Definition at line 37 of file SkDescriptor.h.

{ return p; }

operator!=()

bool SkDescriptor::operator!= ( const SkDescriptor &  other ) const

inline

Definition at line 61 of file SkDescriptor.h.

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

operator==()

bool SkDescriptor::operator==

(

const SkDescriptor &

other

)

const

Definition at line 78 of file SkDescriptor.cpp.

                                                             {
    // the first value we should look at is the checksum, so this loop
    // should terminate early if they descriptors are different.
    // NOTE: if we wrote a sentinel value at the end of each, we could
    //       remove the aa < stop test in the loop...
    const uint32_t* aa = (const uint32_t*)this;
    const uint32_t* bb = (const uint32_t*)&other;
    const uint32_t* stop = (const uint32_t*)((const char*)aa + fLength);
    do {
        if (*aa++ != *bb++)
            return false;
    } while (aa < stop);
    return true;
}

Friends And Related Symbol Documentation

SkAutoDescriptor

friend class SkAutoDescriptor

friend

Definition at line 77 of file SkDescriptor.h.

SkDescriptorTestHelper

friend class SkDescriptorTestHelper

friend

Definition at line 76 of file SkDescriptor.h.

---

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

• third_party/skia/src/core/SkDescriptor.h
• third_party/skia/src/core/SkDescriptor.cpp