#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 void	flush ()

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 Symbol Documentation

◆ SkBlockMemoryRefCnt

friend class SkBlockMemoryRefCnt

friend

Definition at line 507 of file SkStream.h.

◆ SkBlockMemoryStream

friend class SkBlockMemoryStream