SkReadBuffer Class Reference

#include <SkReadBuffer.h>

Public Member Functions
	SkReadBuffer ()=default
	SkReadBuffer (const void *data, size_t size)
void	setMemory (const void *, size_t)
bool	isVersionLT (SkPicturePriv::Version targetVersion) const
uint32_t	getVersion () const
void	setVersion (int version)
size_t	size () const
size_t	offset () const
bool	eof ()
const void *	skip (size_t size)
const void *	skip (size_t count, size_t size)
size_t	available () const
template<typename T >
const T *	skipT ()
template<typename T >
const T *	skipT (size_t count)
bool	readBool ()
SkColor	readColor ()
int32_t	readInt ()
SkScalar	readScalar ()
uint32_t	readUInt ()
int32_t	read32 ()
template<typename T >
T	read32LE (T max)
uint8_t	peekByte ()
void	readString (SkString *string)
void	readColor4f (SkColor4f *color)
void	readPoint (SkPoint *point)
SkPoint	readPoint ()
void	readPoint3 (SkPoint3 *point)
void	read (SkM44 *)
void	readMatrix (SkMatrix *matrix)
void	readIRect (SkIRect *rect)
void	readRect (SkRect *rect)
SkRect	readRect ()
void	readRRect (SkRRect *rrect)
void	readRegion (SkRegion *region)
void	readPath (SkPath *path)
SkPaint	readPaint ()
SkFlattenable *	readRawFlattenable ()
SkFlattenable *	readFlattenable (SkFlattenable::Type)
template<typename T >
sk_sp< T >	readFlattenable ()
sk_sp< SkColorFilter >	readColorFilter ()
sk_sp< SkImageFilter >	readImageFilter ()
sk_sp< SkBlender >	readBlender ()
sk_sp< SkMaskFilter >	readMaskFilter ()
sk_sp< SkPathEffect >	readPathEffect ()
sk_sp< SkShader >	readShader ()
bool	readPad32 (void *buffer, size_t bytes)
bool	readByteArray (void *value, size_t size)
bool	readColorArray (SkColor *colors, size_t size)
bool	readColor4fArray (SkColor4f *colors, size_t size)
bool	readIntArray (int32_t *values, size_t size)
bool	readPointArray (SkPoint *points, size_t size)
bool	readScalarArray (SkScalar *values, size_t size)
const void *	skipByteArray (size_t *size)
sk_sp< SkData >	readByteArrayAsData ()
uint32_t	getArrayCount ()
sk_sp< SkImage >	readImage ()
sk_sp< SkTypeface >	readTypeface ()
void	setTypefaceArray (sk_sp< SkTypeface > array[], int count)
void	setFactoryPlayback (SkFlattenable::Factory array[], int count)
void	setDeserialProcs (const SkDeserialProcs &procs)
const SkDeserialProcs &	getDeserialProcs () const
bool	allowSkSL () const
void	setAllowSkSL (bool allow)
bool	validate (bool isValid)
template<typename T >
bool	validateCanReadN (size_t n)
bool	isValid () const
bool	validateIndex (int index, int count)
int32_t	checkInt (int min, int max)
template<typename T >
T	checkRange (T min, T max)
SkLegacyFQ	checkFilterQuality ()
SkSamplingOptions	readSampling ()

Detailed Description

Definition at line 52 of file SkReadBuffer.h.

Constructor & Destructor Documentation

SkReadBuffer() [1/2]

SkReadBuffer::SkReadBuffer ( )

default

SkReadBuffer() [2/2]

SkReadBuffer::SkReadBuffer ( const void *  data, size_t  size  )

inline

Definition at line 55 of file SkReadBuffer.h.

                                                {
        this->setMemory(data, size);
    }

Member Function Documentation

allowSkSL()

bool SkReadBuffer::allowSkSL ( ) const

inline

Definition at line 184 of file SkReadBuffer.h.

{ return fAllowSkSL; }

available()

size_t SkReadBuffer::available ( ) const

inline

Definition at line 82 of file SkReadBuffer.h.

{ return fStop - fCurr; }

checkFilterQuality()

SkLegacyFQ SkReadBuffer::checkFilterQuality

(

)

Definition at line 563 of file SkReadBuffer.cpp.

                                            {
    return this->checkRange<SkLegacyFQ>(kNone_SkLegacyFQ, kLast_SkLegacyFQ);
}

checkInt()

int32_t SkReadBuffer::checkInt	(	int	min,
		int	max
	)

Definition at line 553 of file SkReadBuffer.cpp.

                                                       {
    SkASSERT(min <= max);
    int32_t value = this->read32();
    if (value < min || value > max) {
        this->validate(false);
        value = min;
    }
    return value;
}

checkRange()

template<typename T >

T SkReadBuffer::checkRange ( T  min, T  max  )

inline

Definition at line 219 of file SkReadBuffer.h.

                                                     {
        return static_cast<T>(this->checkInt(static_cast<int32_t>(min),
                                             static_cast<int32_t>(max)));
    }

eof()

bool SkReadBuffer::eof ( )

inline

Definition at line 79 of file SkReadBuffer.h.

{ return fCurr >= fStop; }

getArrayCount()

uint32_t SkReadBuffer::getArrayCount

(

)

Definition at line 330 of file SkReadBuffer.cpp.

                                     {
    const size_t inc = sizeof(uint32_t);
    if (!this->validate(IsPtrAlign4(fCurr) && this->isAvailable(inc))) {
        return 0;
    }
    return *((const uint32_t*)fCurr);
}

getDeserialProcs()

const SkDeserialProcs & SkReadBuffer::getDeserialProcs ( ) const

inline

Definition at line 182 of file SkReadBuffer.h.

{ return fProcs; }

getVersion()

uint32_t SkReadBuffer::getVersion ( ) const

inline

Definition at line 69 of file SkReadBuffer.h.

{ return fVersion; }

isValid()

bool SkReadBuffer::isValid ( ) const

inline

Definition at line 208 of file SkReadBuffer.h.

{ return !fError; }

isVersionLT()

bool SkReadBuffer::isVersionLT ( SkPicturePriv::Version  targetVersion ) const

inline

Returns true IFF the version is older than the specified version.

Definition at line 64 of file SkReadBuffer.h.

                                                               {
        SkASSERT(targetVersion > 0);
        return fVersion > 0 && fVersion < targetVersion;
    }

offset()

size_t SkReadBuffer::offset ( ) const

inline

Definition at line 78 of file SkReadBuffer.h.

{ return fCurr - fBase; }

peekByte()

uint8_t SkReadBuffer::peekByte

(

)

Definition at line 130 of file SkReadBuffer.cpp.

                               {
    if (this->available() <= 0) {
        fError = true;
        return 0;
    }
    return *((const uint8_t*)fCurr);
}

read()

void SkReadBuffer::read

(

SkM44 *

matrix

)

Definition at line 184 of file SkReadBuffer.cpp.

                                     {
    if (this->isValid()) {
        if (const float* m = (const float*)this->skip(sizeof(float) * 16)) {
            *matrix = SkM44::ColMajor(m);
        }
    }
    if (!this->isValid()) {
        *matrix = SkM44();
    }
}

read32()

int32_t SkReadBuffer::read32

(

)

Definition at line 126 of file SkReadBuffer.cpp.

                             {
    return this->readInt();
}

read32LE()

template<typename T >

T SkReadBuffer::read32LE ( T  max )

inline

Definition at line 99 of file SkReadBuffer.h.

                                            {
        uint32_t value = this->readUInt();
        if (!this->validate(value <= static_cast<uint32_t>(max))) {
            value = 0;
        }
        return static_cast<T>(value);
    }

readBlender()

sk_sp< SkBlender > SkReadBuffer::readBlender ( )

inline

Definition at line 138 of file SkReadBuffer.h.

{ return this->readFlattenable<SkBlenderBase>(); }

readBool()

bool SkReadBuffer::readBool

(

)

Definition at line 91 of file SkReadBuffer.cpp.

                            {
    uint32_t value = this->readUInt();
    // Boolean value should be either 0 or 1
    this->validate(!(value & ~1));
    return value != 0;
}

readByteArray()

bool SkReadBuffer::readByteArray	(	void *	value,
		size_t	size
	)

Definition at line 284 of file SkReadBuffer.cpp.

                                                         {
    return this->readArray(value, size, sizeof(uint8_t));
}

readByteArrayAsData()

sk_sp< SkData > SkReadBuffer::readByteArrayAsData

(

)

Definition at line 317 of file SkReadBuffer.cpp.

                                                {
    size_t numBytes = this->getArrayCount();
    if (!this->validate(this->isAvailable(numBytes))) {
        return nullptr;
    }
 
    SkAutoMalloc buffer(numBytes);
    if (!this->readByteArray(buffer.get(), numBytes)) {
        return nullptr;
    }
    return SkData::MakeFromMalloc(buffer.release(), numBytes);
}

readColor()

SkColor SkReadBuffer::readColor

(

)

Definition at line 98 of file SkReadBuffer.cpp.

                                {
    return this->readUInt();
}

readColor4f()

void SkReadBuffer::readColor4f

(

SkColor4f *

color

)

Definition at line 169 of file SkReadBuffer.cpp.

                                               {
    if (!this->readPad32(color, sizeof(SkColor4f))) {
        *color = {0, 0, 0, 0};
    }
}

readColor4fArray()

bool SkReadBuffer::readColor4fArray	(	SkColor4f *	colors,
		size_t	size
	)

Definition at line 292 of file SkReadBuffer.cpp.

                                                                  {
    return this->readArray(colors, size, sizeof(SkColor4f));
}

readColorArray()

bool SkReadBuffer::readColorArray	(	SkColor *	colors,
		size_t	size
	)

Definition at line 288 of file SkReadBuffer.cpp.

                                                              {
    return this->readArray(colors, size, sizeof(SkColor));
}

readColorFilter()

sk_sp< SkColorFilter > SkReadBuffer::readColorFilter ( )

inline

Definition at line 136 of file SkReadBuffer.h.

{ return this->readFlattenable<SkColorFilterBase>(); }

readFlattenable() [1/2]

template<typename T >

sk_sp< T > SkReadBuffer::readFlattenable ( )

inline

Definition at line 133 of file SkReadBuffer.h.

                                                     {
        return sk_sp<T>((T*)this->readFlattenable(T::GetFlattenableType()));
    }

readFlattenable() [2/2]

SkFlattenable * SkReadBuffer::readFlattenable

(

SkFlattenable::Type

ft

)

Definition at line 541 of file SkReadBuffer.cpp.

                                                                 {
    SkFlattenable* obj = this->readRawFlattenable();
    if (obj && obj->getFlattenableType() != ft) {
        this->validate(false);
        obj->unref();
        return nullptr;
    }
    return obj;
}

readImage()

sk_sp< SkImage > SkReadBuffer::readImage

(

)

Definition at line 411 of file SkReadBuffer.cpp.

                                       {
    uint32_t flags = this->read32();
 
    std::optional<SkAlphaType> alphaType = std::nullopt;
    if (flags & SkWriteBufferImageFlags::kUnpremul) {
        alphaType = kUnpremul_SkAlphaType;
    }
    sk_sp<SkImage> image;
    {
        sk_sp<SkData> data = this->readByteArrayAsData();
        if (!data) {
            this->validate(false);
            return nullptr;
        }
        image = deserialize_image(data, fProcs, alphaType);
    }
 
    // This flag is not written by new SKPs anymore.
    if (flags & SkWriteBufferImageFlags::kHasSubsetRect) {
        SkIRect subset;
        this->readIRect(&subset);
        if (image) {
            image = image->makeSubset(nullptr, subset);
        }
    }
 
    if (flags & SkWriteBufferImageFlags::kHasMipmap) {
        sk_sp<SkData> data = this->readByteArrayAsData();
        if (!data) {
            this->validate(false);
            return nullptr;
        }
        if (image) {
            image = add_mipmaps(image, std::move(data), fProcs, alphaType);
        }
    }
    return image ? image : MakeEmptyImage(1, 1);
}

readImageFilter()

sk_sp< SkImageFilter > SkReadBuffer::readImageFilter ( )

inline

Definition at line 137 of file SkReadBuffer.h.

{ return this->readFlattenable<SkImageFilter_Base>(); }

readInt()

int32_t SkReadBuffer::readInt

(

)

Definition at line 102 of file SkReadBuffer.cpp.

                              {
    const size_t inc = sizeof(int32_t);
    if (!this->validate(IsPtrAlign4(fCurr) && this->isAvailable(inc))) {
        return 0;
    }
    int32_t value = *((const int32_t*)fCurr);
    fCurr += inc;
    return value;
}

readIntArray()

bool SkReadBuffer::readIntArray	(	int32_t *	values,
		size_t	size
	)

Definition at line 296 of file SkReadBuffer.cpp.

                                                            {
    return this->readArray(values, size, sizeof(int32_t));
}

readIRect()

void SkReadBuffer::readIRect

(

SkIRect *

rect

)

Definition at line 207 of file SkReadBuffer.cpp.

                                          {
    if (!this->readPad32(rect, sizeof(SkIRect))) {
        rect->setEmpty();
    }
}

readMaskFilter()

sk_sp< SkMaskFilter > SkReadBuffer::readMaskFilter ( )

inline

Definition at line 139 of file SkReadBuffer.h.

{ return this->readFlattenable<SkMaskFilterBase>(); }

readMatrix()

void SkReadBuffer::readMatrix

(

SkMatrix *

matrix

)

Definition at line 195 of file SkReadBuffer.cpp.

                                              {
    size_t size = 0;
    if (this->isValid()) {
        size = SkMatrixPriv::ReadFromMemory(matrix, fCurr, this->available());
        (void)this->validate((SkAlign4(size) == size) && (0 != size));
    }
    if (!this->isValid()) {
        matrix->reset();
    }
    (void)this->skip(size);
}

readPad32()

bool SkReadBuffer::readPad32	(	void *	buffer,
		size_t	bytes
	)

Definition at line 138 of file SkReadBuffer.cpp.

                                                       {
    if (const void* src = this->skip(bytes)) {
        // buffer might be null if bytes is zero (see SkAutoMalloc), hence we call
        // the careful version of memcpy.
        sk_careful_memcpy(buffer, src, bytes);
        return true;
    }
    return false;
}

readPaint()

SkPaint SkReadBuffer::readPaint ( )

inline

Definition at line 127 of file SkReadBuffer.h.

                        {
        return SkPaintPriv::Unflatten(*this);
    }

readPath()

void SkReadBuffer::readPath

(

SkPath *

path

)

Definition at line 267 of file SkReadBuffer.cpp.

                                        {
    size_t size = 0;
    if (!fError) {
        size = path->readFromMemory(fCurr, this->available());
        if (!this->validate((SkAlign4(size) == size) && (0 != size))) {
            path->reset();
        }
    }
    (void)this->skip(size);
}

readPathEffect()

sk_sp< SkPathEffect > SkReadBuffer::readPathEffect ( )

inline

Definition at line 140 of file SkReadBuffer.h.

{ return this->readFlattenable<SkPathEffect>(); }

readPoint() [1/2]

SkPoint SkReadBuffer::readPoint ( )

inline

Definition at line 115 of file SkReadBuffer.h.

{ SkPoint p; this->readPoint(&p); return p; }

readPoint() [2/2]

void SkReadBuffer::readPoint

(

SkPoint *

point

)

Definition at line 175 of file SkReadBuffer.cpp.

                                           {
    point->fX = this->readScalar();
    point->fY = this->readScalar();
}

readPoint3()

void SkReadBuffer::readPoint3

(

SkPoint3 *

point

)

Definition at line 180 of file SkReadBuffer.cpp.

                                             {
    this->readPad32(point, sizeof(SkPoint3));
}

readPointArray()

bool SkReadBuffer::readPointArray	(	SkPoint *	points,
		size_t	size
	)

Definition at line 300 of file SkReadBuffer.cpp.

                                                              {
    return this->readArray(points, size, sizeof(SkPoint));
}

readRawFlattenable()

SkFlattenable * SkReadBuffer::readRawFlattenable

(

)

Definition at line 474 of file SkReadBuffer.cpp.

                                                {
    SkFlattenable::Factory factory = nullptr;
 
    if (fFactoryCount > 0) {
        int32_t index = this->read32();
        if (0 == index || !this->isValid()) {
            return nullptr; // writer failed to give us the flattenable
        }
        if (index < 0) {
            this->validate(false);
            return nullptr;
        }
        index -= 1;     // we stored the index-base-1
        if ((unsigned)index >= (unsigned)fFactoryCount) {
            this->validate(false);
            return nullptr;
        }
        factory = fFactoryArray[index];
    } else {
        if (this->peekByte() != 0) {
            // If the first byte is non-zero, the flattenable is specified by a string.
            size_t ignored_length;
            if (const char* name = this->readString(&ignored_length)) {
                factory = SkFlattenable::NameToFactory(name);
                fFlattenableDict.set(fFlattenableDict.count() + 1, factory);
            }
        } else {
            // Read the index.  We are guaranteed that the first byte
            // is zeroed, so we must shift down a byte.
            uint32_t index = this->readUInt() >> 8;
            if (index == 0) {
                return nullptr; // writer failed to give us the flattenable
            }
 
            if (SkFlattenable::Factory* found = fFlattenableDict.find(index)) {
                factory = *found;
            }
        }
 
        if (!this->validate(factory != nullptr)) {
            return nullptr;
        }
    }
 
    // if we get here, factory may still be null, but if that is the case, the
    // failure was ours, not the writer.
    sk_sp<SkFlattenable> obj;
    uint32_t sizeRecorded = this->read32();
    if (factory) {
        size_t offset = this->offset();
        obj = (*factory)(*this);
        // check that we read the amount we expected
        size_t sizeRead = this->offset() - offset;
        if (sizeRecorded != sizeRead) {
            this->validate(false);
            return nullptr;
        }
    } else {
        // we must skip the remaining data
        this->skip(sizeRecorded);
    }
    if (!this->isValid()) {
        return nullptr;
    }
    return obj.release();
}

readRect() [1/2]

SkRect SkReadBuffer::readRect

(

)

Definition at line 219 of file SkReadBuffer.cpp.

                              {
    SkRect r;
    if (!this->readPad32(&r, sizeof(SkRect))) {
        r.setEmpty();
    }
    return r;
}

readRect() [2/2]

void SkReadBuffer::readRect

(

SkRect *

rect

)

Definition at line 213 of file SkReadBuffer.cpp.

                                        {
    if (!this->readPad32(rect, sizeof(SkRect))) {
        rect->setEmpty();
    }
}

readRegion()

void SkReadBuffer::readRegion

(

SkRegion *

region

)

Definition at line 256 of file SkReadBuffer.cpp.

                                              {
    size_t size = 0;
    if (!fError) {
        size = region->readFromMemory(fCurr, this->available());
        if (!this->validate((SkAlign4(size) == size) && (0 != size))) {
            region->setEmpty();
        }
    }
    (void)this->skip(size);
}

readRRect()

void SkReadBuffer::readRRect

(

SkRRect *

rrect

)

Definition at line 245 of file SkReadBuffer.cpp.

                                           {
    size_t size = 0;
    if (!fError) {
        size = rrect->readFromMemory(fCurr, this->available());
        if (!this->validate((SkAlign4(size) == size) && (0 != size))) {
            rrect->setEmpty();
        }
    }
    (void)this->skip(size);
}

readSampling()

SkSamplingOptions SkReadBuffer::readSampling

(

)

Definition at line 227 of file SkReadBuffer.cpp.

                                             {
    if (!this->isVersionLT(SkPicturePriv::kAnisotropicFilter)) {
        int maxAniso = this->readInt();
        if (maxAniso != 0) {
            return SkSamplingOptions::Aniso(maxAniso);
        }
    }
    if (this->readBool()) {
        float B = this->readScalar();
        float C = this->readScalar();
        return SkSamplingOptions({B, C});
    } else {
        SkFilterMode filter = this->read32LE(SkFilterMode::kLinear);
        SkMipmapMode mipmap = this->read32LE(SkMipmapMode::kLinear);
        return SkSamplingOptions(filter, mipmap);
    }
}

readScalar()

SkScalar SkReadBuffer::readScalar

(

)

Definition at line 112 of file SkReadBuffer.cpp.

                                  {
    const size_t inc = sizeof(SkScalar);
    if (!this->validate(IsPtrAlign4(fCurr) && this->isAvailable(inc))) {
        return 0;
    }
    SkScalar value = *((const SkScalar*)fCurr);
    fCurr += inc;
    return value;
}

readScalarArray()

bool SkReadBuffer::readScalarArray	(	SkScalar *	values,
		size_t	size
	)

Definition at line 304 of file SkReadBuffer.cpp.

                                                                {
    return this->readArray(values, size, sizeof(SkScalar));
}

readShader()

sk_sp< SkShader > SkReadBuffer::readShader ( )

inline

Definition at line 141 of file SkReadBuffer.h.

{ return this->readFlattenable<SkShaderBase>(); }

readString()

void SkReadBuffer::readString

(

SkString *

string

)

Definition at line 160 of file SkReadBuffer.cpp.

                                              {
    size_t len;
    if (const char* c_str = this->readString(&len)) {
        string->set(c_str, len);
        return;
    }
    string->reset();
}

readTypeface()

sk_sp< SkTypeface > SkReadBuffer::readTypeface

(

)

Definition at line 450 of file SkReadBuffer.cpp.

                                             {
    // Read 32 bits (signed)
    //   0 -- return null (empty font)
    //  >0 -- index
    //  <0 -- custom (serial procs) : negative size in bytes
 
    int32_t index = this->read32();
    if (index == 0) {
        return nullptr;
    } else if (index > 0) {
        if (!this->validate(index <= fTFCount)) {
            return nullptr;
        }
        return fTFArray[index - 1];
    } else {    // custom
        size_t size = sk_negate_to_size_t(index);
        const void* data = this->skip(size);
        if (!this->validate(data != nullptr && fProcs.fTypefaceProc)) {
            return nullptr;
        }
        return fProcs.fTypefaceProc(data, size, fProcs.fTypefaceCtx);
    }
}

readUInt()

uint32_t SkReadBuffer::readUInt

(

)

Definition at line 122 of file SkReadBuffer.cpp.

                                {
    return this->readInt();
}

setAllowSkSL()

void SkReadBuffer::setAllowSkSL ( bool  allow )

inline

Definition at line 185 of file SkReadBuffer.h.

{ fAllowSkSL = allow; }

setDeserialProcs()

void SkReadBuffer::setDeserialProcs

(

const SkDeserialProcs &

procs

)

Definition at line 86 of file SkReadBuffer.cpp.

                                                                {
    fProcs = procs;
    this->setAllowSkSL(procs.fAllowSkSL);
}

setFactoryPlayback()

void SkReadBuffer::setFactoryPlayback ( SkFlattenable::Factory  array[], int  count  )

inline

Call this with a pre-loaded array of Factories, in the same order as were created/written by the writer. SkPicture uses this.

Definition at line 176 of file SkReadBuffer.h.

                                                                     {
        fFactoryArray = array;
        fFactoryCount = count;
    }

setMemory()

void SkReadBuffer::setMemory	(	const void *	data,
		size_t	size
	)

Definition at line 53 of file SkReadBuffer.cpp.

                                                          {
    this->validate(IsPtrAlign4(data) && (SkAlign4(size) == size));
    if (!fError) {
        fBase = fCurr = (const char*)data;
        fStop = fBase + size;
    }
}

setTypefaceArray()

void SkReadBuffer::setTypefaceArray ( sk_sp< SkTypeface >  array[], int  count  )

inline

Definition at line 167 of file SkReadBuffer.h.

                                                                {
        fTFArray = array;
        fTFCount = count;
    }

setVersion()

void SkReadBuffer::setVersion ( int  version )

inline

This may be called at most once; most clients of SkReadBuffer should not mess with it.

Definition at line 72 of file SkReadBuffer.h.

                                 {
        SkASSERT(0 == fVersion || version == fVersion);
        fVersion = version;
    }

size()

size_t SkReadBuffer::size ( ) const

inline

Definition at line 77 of file SkReadBuffer.h.

{ return fStop - fBase; }

skip() [1/2]

const void * SkReadBuffer::skip	(	size_t	count,
		size_t	size
	)

Definition at line 82 of file SkReadBuffer.cpp.

                                                        {
    return this->skip(SkSafeMath::Mul(count, size));
}

skip() [2/2]

const void * SkReadBuffer::skip

(

size_t

size

)

Definition at line 69 of file SkReadBuffer.cpp.

                                          {
    size_t inc = SkAlign4(size);
    this->validate(inc >= size);
    const void* addr = fCurr;
    this->validate(IsPtrAlign4(addr) && this->isAvailable(inc));
    if (fError) {
        return nullptr;
    }
 
    fCurr += inc;
    return addr;
}

skipByteArray()

const void * SkReadBuffer::skipByteArray

(

size_t *

size

)

Definition at line 308 of file SkReadBuffer.cpp.

                                                    {
    const uint32_t count = this->readUInt();
    const void* buf = this->skip(count);
    if (size) {
        *size = this->isValid() ? count : 0;
    }
    return buf;
}

skipT() [1/2]

template<typename T >

const T * SkReadBuffer::skipT ( )

inline

Definition at line 84 of file SkReadBuffer.h.

                                           {
        return static_cast<const T*>(this->skip(sizeof(T)));
    }

skipT() [2/2]

template<typename T >

const T * SkReadBuffer::skipT ( size_t  count )

inline

Definition at line 87 of file SkReadBuffer.h.

                                                       {
        return static_cast<const T*>(this->skip(count, sizeof(T)));
    }

validate()

bool SkReadBuffer::validate ( bool  isValid )

inline

If isValid is false, sets the buffer to be "invalid". Returns true if the buffer is still valid.

Definition at line 191 of file SkReadBuffer.h.

                                {
        if (!isValid) {
            this->setInvalid();
        }
        return !fError;
    }

validateCanReadN()

template<typename T >

bool SkReadBuffer::validateCanReadN ( size_t  n )

inline

Helper function to do a preflight check before a large allocation or read. Returns true if there is enough bytes in the buffer to read n elements of T. If not, the buffer will be "invalid" and false will be returned.

Definition at line 204 of file SkReadBuffer.h.

                                    {
        return this->validate(n <= (this->available() / sizeof(T)));
    }

validateIndex()

bool SkReadBuffer::validateIndex ( int  index, int  count  )

inline

Definition at line 209 of file SkReadBuffer.h.

                                             {
        return this->validate(index >= 0 && index < count);
    }

---

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

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