SkWriter32 Class Reference

#include <SkWriter32.h>

Inheritance diagram for SkWriter32:

Public Member Functions
	SkWriter32 (void *external=nullptr, size_t externalBytes=0)
size_t	bytesWritten () const
bool	usingInitialStorage () const
void	reset (void *external=nullptr, size_t externalBytes=0)
uint32_t *	reserve (size_t size)
template<typename T >
const T &	readTAt (size_t offset) const
template<typename T >
void	overwriteTAt (size_t offset, const T &value)
bool	writeBool (bool value)
void	writeInt (int32_t value)
void	write8 (int32_t value)
void	write16 (int32_t value)
void	write32 (int32_t value)
void	writeScalar (SkScalar value)
void	writePoint (const SkPoint &pt)
void	writePoint3 (const SkPoint3 &pt)
void	writeRect (const SkRect &rect)
void	writeIRect (const SkIRect &rect)
void	writeRRect (const SkRRect &rrect)
void	writePath (const SkPath &path)
void	writeMatrix (const SkMatrix &matrix)
void	writeRegion (const SkRegion &rgn)
void	writeSampling (const SkSamplingOptions &sampling)
void	writeMul4 (const void *values, size_t size)
void	write (const void *values, size_t size)
uint32_t *	reservePad (size_t size)
void	writePad (const void *src, size_t size)
void	writeString (const char *str, size_t len=(size_t) -1)
void	writeData (const SkData *data)
void	rewindToOffset (size_t offset)
void	flatten (void *dst) const
bool	writeToStream (SkWStream *stream) const
size_t	readFromStream (SkStream *stream, size_t length)
sk_sp< SkData >	snapshotAsData () const

Static Public Member Functions
static size_t	WriteStringSize (const char *str, size_t len=(size_t) -1)
static size_t	WriteDataSize (const SkData *data)

Detailed Description

Definition at line 34 of file SkWriter32.h.

Constructor & Destructor Documentation

SkWriter32()

SkWriter32::SkWriter32 ( void *  external = nullptr, size_t  externalBytes = 0  )

inline

The caller can specify an initial block of storage, which the caller manages.

SkWriter32 will try to back reserve and write calls with this external storage until the first time an allocation doesn't fit. From then it will use dynamically allocated storage. This used to be optional behavior, but pipe now relies on it.

Definition at line 43 of file SkWriter32.h.

                                                                   {
        this->reset(external, externalBytes);
    }

Member Function Documentation

bytesWritten()

size_t SkWriter32::bytesWritten ( ) const

inline

Definition at line 48 of file SkWriter32.h.

{ return fUsed; }

flatten()

void SkWriter32::flatten ( void *  dst ) const

inline

Definition at line 235 of file SkWriter32.h.

                                  {
        memcpy(dst, fData, fUsed);
    }

overwriteTAt()

template<typename T >

void SkWriter32::overwriteTAt ( size_t  offset, const T &  value  )

inline

Overwrite a T record at offset, which must be a multiple of 4. Only legal if the record was written atomically using the write methods below.

Definition at line 94 of file SkWriter32.h.

                                                     {
        SkASSERT(SkAlign4(offset) == offset);
        SkASSERT(offset < fUsed);
        *(T*)(fData + offset) = value;
    }

readFromStream()

size_t SkWriter32::readFromStream ( SkStream *  stream, size_t  length  )

inline

Definition at line 245 of file SkWriter32.h.

                                                           {
        return stream->read(this->reservePad(length), length);
    }

readTAt()

template<typename T >

const T & SkWriter32::readTAt ( size_t  offset ) const

inline

Read a T record at offset, which must be a multiple of 4. Only legal if the record was written atomically using the write methods below.

Definition at line 83 of file SkWriter32.h.

                                          {
        SkASSERT(SkAlign4(offset) == offset);
        SkASSERT(offset < fUsed);
        return *(T*)(fData + offset);
    }

reserve()

uint32_t * SkWriter32::reserve ( size_t  size )

inline

Definition at line 67 of file SkWriter32.h.

                                   {
        SkASSERT(SkAlign4(size) == size);
        size_t offset = fUsed;
        size_t totalRequired = fUsed + size;
        if (totalRequired > fCapacity) {
            this->growToAtLeast(totalRequired);
        }
        fUsed = totalRequired;
        return (uint32_t*)(fData + offset);
    }

reservePad()

uint32_t * SkWriter32::reservePad ( size_t  size )

inline

Reserve size bytes. Does not need to be 4 byte aligned. The remaining space (if any) will be filled in with zeroes.

Definition at line 179 of file SkWriter32.h.

                                      {
        size_t alignedSize = SkAlign4(size);
        uint32_t* p = this->reserve(alignedSize);
        if (alignedSize != size) {
            SkASSERT(alignedSize >= 4);
            p[alignedSize / 4 - 1] = 0;
        }
        return p;
    }

reset()

void SkWriter32::reset ( void *  external = nullptr, size_t  externalBytes = 0  )

inline

Definition at line 54 of file SkWriter32.h.

                                                                   {
        // we cast this pointer to int* and float* at times, so assert that it is aligned.
        SkASSERT(SkIsAlign4((uintptr_t)external));
        // we always write multiples of 4-bytes, so truncate down the size to match that
        externalBytes &= ~3;
 
        fData = (uint8_t*)external;
        fCapacity = externalBytes;
        fUsed = 0;
        fExternal = external;
    }

rewindToOffset()

void SkWriter32::rewindToOffset ( size_t  offset )

inline

Move the cursor back to offset bytes from the beginning. offset must be a multiple of 4 no greater than size().

Definition at line 228 of file SkWriter32.h.

                                       {
        SkASSERT(SkAlign4(offset) == offset);
        SkASSERT(offset <= bytesWritten());
        fUsed = offset;
    }

snapshotAsData()

sk_sp< SkData > SkWriter32::snapshotAsData

(

)

const

Captures a snapshot of the data as it is right now, and return it.

Definition at line 78 of file SkWriter32.cpp.

                                               {
    return SkData::MakeWithCopy(fData, fUsed);
}

usingInitialStorage()

bool SkWriter32::usingInitialStorage ( ) const

inline

Definition at line 52 of file SkWriter32.h.

{ return fData == fExternal; }

write()

void SkWriter32::write ( const void *  values, size_t  size  )

inline

Write size bytes from values. size must be a multiple of 4, though values need not be 4-byte aligned.

Definition at line 170 of file SkWriter32.h.

                                                {
        SkASSERT(SkAlign4(size) == size);
        sk_careful_memcpy(this->reserve(size), values, size);
    }

write16()

void SkWriter32::write16 ( int32_t  value )

inline

Definition at line 113 of file SkWriter32.h.

                                {
        *(int32_t*)this->reserve(sizeof(value)) = value & 0xFFFF;
    }

write32()

void SkWriter32::write32 ( int32_t  value )

inline

Definition at line 117 of file SkWriter32.h.

                                {
        *(int32_t*)this->reserve(sizeof(value)) = value;
    }

write8()

void SkWriter32::write8 ( int32_t  value )

inline

Definition at line 109 of file SkWriter32.h.

                               {
        *(int32_t*)this->reserve(sizeof(value)) = value & 0xFF;
    }

writeBool()

bool SkWriter32::writeBool ( bool  value )

inline

Definition at line 100 of file SkWriter32.h.

                               {
        this->write32(value);
        return value;
    }

writeData()

void SkWriter32::writeData ( const SkData *  data )

inline

Definition at line 212 of file SkWriter32.h.

                                       {
        uint32_t len = data ? SkToU32(data->size()) : 0;
        this->write32(len);
        if (data) {
            this->writePad(data->data(), len);
        }
    }

WriteDataSize()

static size_t SkWriter32::WriteDataSize ( const SkData *  data )

inlinestatic

Definition at line 220 of file SkWriter32.h.

                                                    {
        return 4 + SkAlign4(data ? data->size() : 0);
    }

writeInt()

void SkWriter32::writeInt ( int32_t  value )

inline

Definition at line 105 of file SkWriter32.h.

                                 {
        this->write32(value);
    }

writeIRect()

void SkWriter32::writeIRect ( const SkIRect &  rect )

inline

Definition at line 137 of file SkWriter32.h.

                                         {
        *(SkIRect*)this->reserve(sizeof(rect)) = rect;
    }

writeMatrix()

void SkWriter32::writeMatrix

(

const SkMatrix &

matrix

)

Definition at line 18 of file SkWriter32.cpp.

                                                   {
    size_t size = SkMatrixPriv::WriteToMemory(matrix, nullptr);
    SkASSERT(SkAlign4(size) == size);
    SkMatrixPriv::WriteToMemory(matrix, this->reserve(size));
}

writeMul4()

void SkWriter32::writeMul4 ( const void *  values, size_t  size  )

inline

Definition at line 162 of file SkWriter32.h.

                                                    {
        this->write(values, size);
    }

writePad()

void SkWriter32::writePad ( const void *  src, size_t  size  )

inline

Write size bytes from src, and pad to 4 byte alignment with zeroes.

Definition at line 192 of file SkWriter32.h.

                                                {
        sk_careful_memcpy(this->reservePad(size), src, size);
    }

writePath()

void SkWriter32::writePath ( const SkPath &  path )

inline

Definition at line 145 of file SkWriter32.h.

                                       {
        size_t size = path.writeToMemory(nullptr);
        SkASSERT(SkAlign4(size) == size);
        path.writeToMemory(this->reserve(size));
    }

writePoint()

void SkWriter32::writePoint ( const SkPoint &  pt )

inline

Definition at line 125 of file SkWriter32.h.

                                       {
        *(SkPoint*)this->reserve(sizeof(pt)) = pt;
    }

writePoint3()

void SkWriter32::writePoint3 ( const SkPoint3 &  pt )

inline

Definition at line 129 of file SkWriter32.h.

                                         {
        *(SkPoint3*)this->reserve(sizeof(pt)) = pt;
    }

writeRect()

void SkWriter32::writeRect ( const SkRect &  rect )

inline

Definition at line 133 of file SkWriter32.h.

                                       {
        *(SkRect*)this->reserve(sizeof(rect)) = rect;
    }

writeRegion()

void SkWriter32::writeRegion ( const SkRegion &  rgn )

inline

Definition at line 153 of file SkWriter32.h.

                                          {
        size_t size = rgn.writeToMemory(nullptr);
        SkASSERT(SkAlign4(size) == size);
        rgn.writeToMemory(this->reserve(size));
    }

writeRRect()

void SkWriter32::writeRRect ( const SkRRect &  rrect )

inline

Definition at line 141 of file SkWriter32.h.

                                          {
        rrect.writeToMemory(this->reserve(SkRRect::kSizeInMemory));
    }

writeSampling()

void SkWriter32::writeSampling

(

const SkSamplingOptions &

sampling

)

Definition at line 24 of file SkWriter32.cpp.

                                                                {
    this->write32(sampling.maxAniso);
    if (!sampling.isAniso()) {
        this->writeBool(sampling.useCubic);
        if (sampling.useCubic) {
            this->writeScalar(sampling.cubic.B);
            this->writeScalar(sampling.cubic.C);
        } else {
            this->write32((unsigned)sampling.filter);
            this->write32((unsigned)sampling.mipmap);
        }
    }
}

writeScalar()

void SkWriter32::writeScalar ( SkScalar  value )

inline

Definition at line 121 of file SkWriter32.h.

                                     {
        *(SkScalar*)this->reserve(sizeof(value)) = value;
    }

writeString()

void SkWriter32::writeString	(	const char *	str,
		size_t	len = (size_t)-1
	)

Writes a string to the writer, which can be retrieved with SkReadBuffer::readString(). The length can be specified, or if -1 is passed, it will be computed by calling strlen(). The length must be < max size_t.

If you write NULL, it will be read as "".

Definition at line 38 of file SkWriter32.cpp.

                                                         {
    if (nullptr == str) {
        str = "";
        len = 0;
    }
    if ((long)len < 0) {
        len = strlen(str);
    }
 
    // [ 4 byte len ] [ str ... ] [1 - 4 \0s]
    uint32_t* ptr = this->reservePad(sizeof(uint32_t) + len + 1);
    *ptr = SkToU32(len);
    char* chars = (char*)(ptr + 1);
    memcpy(chars, str, len);
    chars[len] = '\0';
}

WriteStringSize()

size_t SkWriter32::WriteStringSize ( const char *  str, size_t  len = (size_t)-1  )

static

Computes the size (aligned to multiple of 4) need to write the string in a call to writeString(). If the length is not specified, it will be computed by calling strlen().

Definition at line 55 of file SkWriter32.cpp.

                                                              {
    if ((long)len < 0) {
        SkASSERT(str);
        len = strlen(str);
    }
    const size_t lenBytes = 4;    // we use 4 bytes to record the length
    // add 1 since we also write a terminating 0
    return SkAlign4(lenBytes + len + 1);
}

writeToStream()

bool SkWriter32::writeToStream ( SkWStream *  stream ) const

inline

Definition at line 239 of file SkWriter32.h.

                                                {
        return stream->write(fData, fUsed);
    }

---

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

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