SkDynamicMemoryWStream Class Reference

#include <SkStream.h>

Inheritance diagram for SkDynamicMemoryWStream:

Classes
struct	Block

Public Member Functions
	SkDynamicMemoryWStream ()=default
	SkDynamicMemoryWStream (SkDynamicMemoryWStream &&)
SkDynamicMemoryWStream &	operator= (SkDynamicMemoryWStream &&)
	~SkDynamicMemoryWStream () override
bool	write (const void *buffer, size_t size) override
size_t	bytesWritten () const override
bool	read (void *buffer, size_t offset, size_t size)
void	copyTo (void *dst) const
bool	writeToStream (SkWStream *dst) const
void	copyToAndReset (void *dst)
bool	writeToAndReset (SkWStream *dst)
bool	writeToAndReset (SkDynamicMemoryWStream *dst)
void	prependToAndReset (SkDynamicMemoryWStream *dst)
sk_sp< SkData >	detachAsData ()
std::unique_ptr< SkStreamAsset >	detachAsStream ()
void	reset ()
void	padToAlign4 ()
Public Member Functions inherited from SkWStream
virtual	~SkWStream ()
	SkWStream ()
virtual bool	write (const void *buffer, size_t size)=0
virtual void	flush ()
virtual size_t	bytesWritten () const =0
bool	write8 (U8CPU value)
bool	write16 (U16CPU value)
bool	write32 (uint32_t v)
bool	writeText (const char text[])
bool	newline ()
bool	writeDecAsText (int32_t)
bool	writeBigDecAsText (int64_t, int minDigits=0)
bool	writeHexAsText (uint32_t, int minDigits=0)
bool	writeScalarAsText (SkScalar)
bool	writeBool (bool v)
bool	writeScalar (SkScalar)
bool	writePackedUInt (size_t)
bool	writeStream (SkStream *input, size_t length)

Friends
class	SkBlockMemoryStream
class	SkBlockMemoryRefCnt

Additional Inherited Members
Static Public Member Functions inherited from SkWStream
static int	SizeOfPackedUInt (size_t value)

Detailed Description

Definition at line 455 of file SkStream.h.

Constructor & Destructor Documentation

SkDynamicMemoryWStream() [1/2]

SkDynamicMemoryWStream::SkDynamicMemoryWStream ( )

default

SkDynamicMemoryWStream() [2/2]

SkDynamicMemoryWStream::SkDynamicMemoryWStream

(

SkDynamicMemoryWStream &&

other

)

Definition at line 493 of file SkStream.cpp.

    : fHead(other.fHead)
    , fTail(other.fTail)
    , fBytesWrittenBeforeTail(other.fBytesWrittenBeforeTail)
{
    other.fHead = nullptr;
    other.fTail = nullptr;
    other.fBytesWrittenBeforeTail = 0;
}

~SkDynamicMemoryWStream()

SkDynamicMemoryWStream::~SkDynamicMemoryWStream ( )

override

Definition at line 511 of file SkStream.cpp.

                                                {
    this->reset();
}

Member Function Documentation

bytesWritten()

size_t SkDynamicMemoryWStream::bytesWritten ( ) const

overridevirtual

Implements SkWStream.

Definition at line 526 of file SkStream.cpp.

                                                  {
    this->validate();
 
    if (fTail) {
        return fBytesWrittenBeforeTail + fTail->written();
    }
    return 0;
}

copyTo()

void SkDynamicMemoryWStream::copyTo

(

void *

dst

)

const

More efficient version of read(dst, 0, bytesWritten()).

Definition at line 631 of file SkStream.cpp.

                                                   {
    SkASSERT(dst);
    Block* block = fHead;
    while (block != nullptr) {
        size_t size = block->written();
        memcpy(dst, block->start(), size);
        dst = (void*)((char*)dst + size);
        block = block->fNext;
    }
}

copyToAndReset()

void SkDynamicMemoryWStream::copyToAndReset

(

void *

dst

)

Equivalent to copyTo() followed by reset(), but may save memory use.

Definition at line 668 of file SkStream.cpp.

                                                     {
    if (!ptr) {
        this->reset();
        return;
    }
    // By looping through the source and freeing as we copy, we
    // can reduce real memory use with large streams.
    char* dst = reinterpret_cast<char*>(ptr);
    Block* block = fHead;
    while (block != nullptr) {
        size_t len = block->written();
        memcpy(dst, block->start(), len);
        dst += len;
        Block* next = block->fNext;
        sk_free(block);
        block = next;
    }
    fHead = fTail = nullptr;
    fBytesWrittenBeforeTail = 0;
}

detachAsData()

sk_sp< SkData > SkDynamicMemoryWStream::detachAsData

(

)

Return the contents as SkData, and then reset the stream.

Definition at line 707 of file SkStream.cpp.

                                                   {
    const size_t size = this->bytesWritten();
    if (0 == size) {
        return SkData::MakeEmpty();
    }
    sk_sp<SkData> data = SkData::MakeUninitialized(size);
    this->copyToAndReset(data->writable_data());
    return data;
}

detachAsStream()

std::unique_ptr< SkStreamAsset > SkDynamicMemoryWStream::detachAsStream

(

)

Reset, returning a reader stream with the current content.

Definition at line 876 of file SkStream.cpp.

                                                                    {
    if (nullptr == fHead) {
        // no need to reset.
        return SkMemoryStream::Make(nullptr);
    }
    if (fHead == fTail) {  // one block, may be worth shrinking.
        ptrdiff_t used = fTail->fCurr - (char*)fTail;
        fHead = fTail = (SkDynamicMemoryWStream::Block*)sk_realloc_throw(fTail, SkToSizeT(used));
        fTail->fStop = fTail->fCurr = (char*)fTail + used;  // Update pointers.
        SkASSERT(nullptr == fTail->fNext);
        SkASSERT(0 == fBytesWrittenBeforeTail);
    }
    std::unique_ptr<SkStreamAsset> stream
            = std::make_unique<SkBlockMemoryStream>(sk_make_sp<SkBlockMemoryRefCnt>(fHead),
                                                      this->bytesWritten());
    fHead = nullptr;    // signal reset() to not free anything
    this->reset();
    return stream;
}

operator=()

SkDynamicMemoryWStream & SkDynamicMemoryWStream::operator=

(

SkDynamicMemoryWStream &&

other

)

Definition at line 503 of file SkStream.cpp.

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

padToAlign4()

void SkDynamicMemoryWStream::padToAlign4

(

)

Definition at line 652 of file SkStream.cpp.

                                         {
    // The contract is to write zeros until the entire stream has written a multiple of 4 bytes.
    // Our Blocks are guaranteed always be (a) full (except the tail) and (b) a multiple of 4
    // so it is sufficient to just examine the tail (if present).
 
    if (fTail) {
        // cast to remove unary-minus warning
        int padBytes = -(int)fTail->written() & 0x03;
        if (padBytes) {
            int zero = 0;
            fTail->append(&zero, padBytes);
        }
    }
}

prependToAndReset()

void SkDynamicMemoryWStream::prependToAndReset

(

SkDynamicMemoryWStream *

dst

)

Prepend this stream to dst, resetting this.

Definition at line 591 of file SkStream.cpp.

                                                                          {
    SkASSERT(dst);
    SkASSERT(dst != this);
    if (0 == this->bytesWritten()) {
        return;
    }
    if (0 == dst->bytesWritten()) {
        *dst = std::move(*this);
        return;
    }
    fTail->fNext = dst->fHead;
    dst->fHead = fHead;
    dst->fBytesWrittenBeforeTail += fBytesWrittenBeforeTail + fTail->written();
    fHead = fTail = nullptr;
    fBytesWrittenBeforeTail = 0;
}

read()

bool SkDynamicMemoryWStream::read	(	void *	buffer,
		size_t	offset,
		size_t	size
	)

Definition at line 609 of file SkStream.cpp.

                                                                           {
    if (offset + count > this->bytesWritten()) {
        return false; // test does not partially modify
    }
    Block* block = fHead;
    while (block != nullptr) {
        size_t size = block->written();
        if (offset < size) {
            size_t part = offset + count > size ? size - offset : count;
            memcpy(buffer, block->start() + offset, part);
            if (count <= part) {
                return true;
            }
            count -= part;
            buffer = (void*) ((char* ) buffer + part);
        }
        offset = offset > size ? offset - size : 0;
        block = block->fNext;
    }
    return false;
}

reset()

void SkDynamicMemoryWStream::reset

(

)

Reset the stream to its original, empty, state.

Definition at line 515 of file SkStream.cpp.

                                   {
    Block* block = fHead;
    while (block != nullptr) {
        Block* next = block->fNext;
        sk_free(block);
        block = next;
    }
    fHead = fTail = nullptr;
    fBytesWrittenBeforeTail = 0;
}

write()

bool SkDynamicMemoryWStream::write ( const void *  buffer, size_t  size  )

overridevirtual

Called to write bytes to a SkWStream. Returns true on success

Parameters

buffer	the address of at least size bytes to be written to the stream
size	The number of bytes in buffer to write to the stream

Returns

true on success

Implements SkWStream.

Reimplemented in SkRawLimitedDynamicMemoryWStream.

Definition at line 535 of file SkStream.cpp.

                                                                   {
    if (count > 0) {
        SkASSERT(buffer);
        size_t size;
 
        if (fTail && fTail->avail() > 0) {
            size = std::min(fTail->avail(), count);
            buffer = fTail->append(buffer, size);
            SkASSERT(count >= size);
            count -= size;
            if (count == 0) {
                return true;
            }
        }
 
        size = std::max<size_t>(count, SkDynamicMemoryWStream_MinBlockSize - sizeof(Block));
        size = SkAlign4(size);  // ensure we're always a multiple of 4 (see padToAlign4())
 
        Block* block = (Block*)sk_malloc_canfail(sizeof(Block) + size);
        if (!block) {
            this->validate();
            return false;
        }
        block->init(size);
        block->append(buffer, count);
 
        if (fTail) {
            fBytesWrittenBeforeTail += fTail->written();
            fTail->fNext = block;
        } else {
            fHead = fTail = block;
        }
        fTail = block;
        this->validate();
    }
    return true;
}

writeToAndReset() [1/2]

bool SkDynamicMemoryWStream::writeToAndReset

(

SkDynamicMemoryWStream *

dst

)

Equivalent to writeToStream() followed by reset(), but may save memory use. When the dst is also a SkDynamicMemoryWStream, the implementation is constant time.

Definition at line 573 of file SkStream.cpp.

                                                                        {
    SkASSERT(dst);
    SkASSERT(dst != this);
    if (0 == this->bytesWritten()) {
        return true;
    }
    if (0 == dst->bytesWritten()) {
        *dst = std::move(*this);
        return true;
    }
    dst->fTail->fNext = fHead;
    dst->fBytesWrittenBeforeTail += fBytesWrittenBeforeTail + dst->fTail->written();
    dst->fTail = fTail;
    fHead = fTail = nullptr;
    fBytesWrittenBeforeTail = 0;
    return true;
}

writeToAndReset() [2/2]

bool SkDynamicMemoryWStream::writeToAndReset

(

SkWStream *

dst

)

Equivalent to writeToStream() followed by reset(), but may save memory use.

Definition at line 689 of file SkStream.cpp.

                                                           {
    SkASSERT(dst);
    // By looping through the source and freeing as we copy, we
    // can reduce real memory use with large streams.
    bool dstStreamGood = true;
    for (Block* block = fHead; block != nullptr; ) {
        if (dstStreamGood && !dst->write(block->start(), block->written())) {
            dstStreamGood = false;
        }
        Block* next = block->fNext;
        sk_free(block);
        block = next;
    }
    fHead = fTail = nullptr;
    fBytesWrittenBeforeTail = 0;
    return dstStreamGood;
}

writeToStream()

bool SkDynamicMemoryWStream::writeToStream

(

SkWStream *

dst

)

const

Definition at line 642 of file SkStream.cpp.

                                                               {
    SkASSERT(dst);
    for (Block* block = fHead; block != nullptr; block = block->fNext) {
        if (!dst->write(block->start(), block->written())) {
            return false;
        }
    }
    return true;
}

Friends And Related Function Documentation

SkBlockMemoryRefCnt

friend class SkBlockMemoryRefCnt

friend

Definition at line 507 of file SkStream.h.

SkBlockMemoryStream

friend class SkBlockMemoryStream

friend

Definition at line 506 of file SkStream.h.

---

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

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