SkBlockMemoryStream Class Reference

Inheritance diagram for SkBlockMemoryStream:

Public Member Functions
	SkBlockMemoryStream (sk_sp< SkBlockMemoryRefCnt > headRef, size_t size)
size_t	read (void *buffer, size_t rawCount) override
bool	isAtEnd () const override
size_t	peek (void *buff, size_t bytesToPeek) const override
bool	rewind () override
SkBlockMemoryStream *	onDuplicate () const override
size_t	getPosition () const override
bool	seek (size_t position) override
bool	move (long offset) override
SkBlockMemoryStream *	onFork () const override
size_t	getLength () const override
const void *	getMemoryBase () override
Public Member Functions inherited from SkStreamAsset
bool	hasLength () const override
size_t	getLength () const override=0
std::unique_ptr< SkStreamAsset >	duplicate () const
std::unique_ptr< SkStreamAsset >	fork () const
Public Member Functions inherited from SkStreamSeekable
std::unique_ptr< SkStreamSeekable >	duplicate () const
bool	hasPosition () const override
size_t	getPosition () const override=0
bool	seek (size_t position) override=0
bool	move (long offset) override=0
std::unique_ptr< SkStreamSeekable >	fork () const
Public Member Functions inherited from SkStreamRewindable
bool	rewind () override=0
std::unique_ptr< SkStreamRewindable >	duplicate () const
Public Member Functions inherited from SkStream
virtual	~SkStream ()
	SkStream ()
virtual size_t	read (void *buffer, size_t size)=0
size_t	skip (size_t size)
virtual size_t	peek (void *, size_t) const
virtual bool	isAtEnd () const =0
bool	readS8 (int8_t *)
bool	readS16 (int16_t *)
bool	readS32 (int32_t *)
bool	readU8 (uint8_t *i)
bool	readU16 (uint16_t *i)
bool	readU32 (uint32_t *i)
bool	readBool (bool *b)
bool	readScalar (SkScalar *)
bool	readPackedUInt (size_t *)
virtual bool	rewind ()
std::unique_ptr< SkStream >	duplicate () const
std::unique_ptr< SkStream >	fork () const
virtual bool	hasPosition () const
virtual size_t	getPosition () const
virtual bool	seek (size_t)
virtual bool	move (long)
virtual bool	hasLength () const
virtual size_t	getLength () const
virtual const void *	getMemoryBase ()
virtual sk_sp< SkData >	getData () const

Additional Inherited Members
Static Public Member Functions inherited from SkStream
static std::unique_ptr< SkStreamAsset >	MakeFromFile (const char path[])

Detailed Description

Definition at line 756 of file SkStream.cpp.

Constructor & Destructor Documentation

SkBlockMemoryStream()

SkBlockMemoryStream::SkBlockMemoryStream ( sk_sp< SkBlockMemoryRefCnt >  headRef, size_t  size  )

inline

Definition at line 758 of file SkStream.cpp.

        : fBlockMemory(std::move(headRef)), fCurrent(fBlockMemory->fHead)
        , fSize(size) , fOffset(0), fCurrentOffset(0) { }

Member Function Documentation

getLength()

size_t SkBlockMemoryStream::getLength ( ) const

inlineoverridevirtual

Returns the total length of the stream. If this cannot be done, returns 0.

Implements SkStreamAsset.

Definition at line 857 of file SkStream.cpp.

                                      {
        return fSize;
    }

getMemoryBase()

const void * SkBlockMemoryStream::getMemoryBase ( )

inlineoverridevirtual

Returns the starting address for the data. If this cannot be done, returns NULL.

Reimplemented from SkStream.

Definition at line 861 of file SkStream.cpp.

                                         {
        if (fBlockMemory->fHead && !fBlockMemory->fHead->fNext) {
            return fBlockMemory->fHead->start();
        }
        return nullptr;
    }

getPosition()

size_t SkBlockMemoryStream::getPosition ( ) const

inlineoverridevirtual

Returns the current position in the stream. If this cannot be done, returns 0.

Implements SkStreamSeekable.

Definition at line 824 of file SkStream.cpp.

                                        {
        return fOffset;
    }

isAtEnd()

bool SkBlockMemoryStream::isAtEnd ( ) const

inlineoverridevirtual

Returns true when all the bytes in the stream have been read. As SkStream represents synchronous I/O, isAtEnd returns false when the final stream length isn't known yet, even when all the bytes available so far have been read. This may return true early (when there are no more bytes to be read) or late (after the first unsuccessful read).

Implements SkStream.

Definition at line 788 of file SkStream.cpp.

                                  {
        return fOffset == fSize;
    }

move()

bool SkBlockMemoryStream::move ( long  )

inlineoverridevirtual

Seeks to an relative offset in the stream. If this cannot be done, returns false. If an attempt is made to move to a position outside the stream, the position will be set to the closest point within the stream (beginning or end).

Implements SkStreamSeekable.

Definition at line 845 of file SkStream.cpp.

                                    {
        return seek(fOffset + offset);
    }

onDuplicate()

SkBlockMemoryStream * SkBlockMemoryStream::onDuplicate ( ) const

inlineoverridevirtual

Implements SkStreamAsset.

Definition at line 820 of file SkStream.cpp.

                                                      {
        return new SkBlockMemoryStream(fBlockMemory, fSize);
    }

onFork()

SkBlockMemoryStream * SkBlockMemoryStream::onFork ( ) const

inlineoverridevirtual

Implements SkStreamAsset.

Definition at line 849 of file SkStream.cpp.

                                                 {
        SkBlockMemoryStream* that = this->onDuplicate();
        that->fCurrent = this->fCurrent;
        that->fOffset = this->fOffset;
        that->fCurrentOffset = this->fCurrentOffset;
        return that;
    }

peek()

size_t SkBlockMemoryStream::peek ( void *  , size_t    ) const

inlineoverridevirtual

Attempt to peek at size bytes. If this stream supports peeking, copy min(size, peekable bytes) into buffer, and return the number of bytes copied. If the stream does not support peeking, or cannot peek any bytes, return 0 and leave buffer unchanged. The stream is guaranteed to be in the same visible state after this call, regardless of success or failure.

Parameters

buffer	Must not be NULL, and must be at least size bytes. Destination to copy bytes.
size	Number of bytes to copy.

Returns

The number of bytes peeked/copied.

Reimplemented from SkStream.

Definition at line 792 of file SkStream.cpp.

                                                               {
        SkASSERT(buff != nullptr);
 
        bytesToPeek = std::min(bytesToPeek, fSize - fOffset);
 
        size_t bytesLeftToPeek = bytesToPeek;
        char* buffer = static_cast<char*>(buff);
        const SkDynamicMemoryWStream::Block* current = fCurrent;
        size_t currentOffset = fCurrentOffset;
        while (bytesLeftToPeek) {
            SkASSERT(current);
            size_t bytesFromCurrent = std::min(current->written() - currentOffset, bytesLeftToPeek);
            memcpy(buffer, current->start() + currentOffset, bytesFromCurrent);
            bytesLeftToPeek -= bytesFromCurrent;
            buffer += bytesFromCurrent;
            current = current->fNext;
            currentOffset = 0;
        }
        return bytesToPeek;
    }

read()

size_t SkBlockMemoryStream::read ( void *  buffer, size_t  size  )

inlineoverridevirtual

Reads or skips size number of bytes. If buffer == NULL, skip size bytes, return how many were skipped. If buffer != NULL, copy size bytes into buffer, return how many were copied.

Parameters

buffer	when NULL skip size bytes, otherwise copy size bytes into buffer
size	the number of bytes to skip or copy

Returns

the number of bytes actually read.

Implements SkStream.

Definition at line 762 of file SkStream.cpp.

                                                        {
        size_t count = rawCount;
        if (fOffset + count > fSize) {
            count = fSize - fOffset;
        }
        size_t bytesLeftToRead = count;
        while (fCurrent != nullptr) {
            size_t bytesLeftInCurrent = fCurrent->written() - fCurrentOffset;
            size_t bytesFromCurrent = std::min(bytesLeftToRead, bytesLeftInCurrent);
            if (buffer) {
                memcpy(buffer, fCurrent->start() + fCurrentOffset, bytesFromCurrent);
                buffer = SkTAddOffset<void>(buffer, bytesFromCurrent);
            }
            if (bytesLeftToRead <= bytesFromCurrent) {
                fCurrentOffset += bytesFromCurrent;
                fOffset += count;
                return count;
            }
            bytesLeftToRead -= bytesFromCurrent;
            fCurrent = fCurrent->fNext;
            fCurrentOffset = 0;
        }
        SkASSERT(false);
        return 0;
    }

rewind()

bool SkBlockMemoryStream::rewind ( )

inlineoverridevirtual

Rewinds to the beginning of the stream. Returns true if the stream is known to be at the beginning after this call returns.

Implements SkStreamRewindable.

Definition at line 813 of file SkStream.cpp.

                           {
        fCurrent = fBlockMemory->fHead;
        fOffset = 0;
        fCurrentOffset = 0;
        return true;
    }

seek()

bool SkBlockMemoryStream::seek ( size_t  )

inlineoverridevirtual

Seeks to an absolute position in the stream. If this cannot be done, returns false. If an attempt is made to seek past the end of the stream, the position will be set to the end of the stream.

Implements SkStreamSeekable.

Definition at line 828 of file SkStream.cpp.

                                        {
        // If possible, skip forward.
        if (position >= fOffset) {
            size_t skipAmount = position - fOffset;
            return this->skip(skipAmount) == skipAmount;
        }
        // If possible, move backward within the current block.
        size_t moveBackAmount = fOffset - position;
        if (moveBackAmount <= fCurrentOffset) {
            fCurrentOffset -= moveBackAmount;
            fOffset -= moveBackAmount;
            return true;
        }
        // Otherwise rewind and move forward.
        return this->rewind() && this->skip(position) == position;
    }

---

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

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