skgpu::BufferWriter Struct Reference

#include <BufferWriter.h>

Inheritance diagram for skgpu::BufferWriter:

Classes
struct	Mark

Public Member Functions
	operator bool () const
Mark	mark (size_t offset=0) const

Protected Member Functions
	BufferWriter ()=default
	BufferWriter (void *ptr, size_t size)
	BufferWriter (void *ptr, Mark end={})
BufferWriter &	operator= (const BufferWriter &)=delete
BufferWriter &	operator= (BufferWriter &&that)
template<typename W >
W	makeOffset (size_t offsetInBytes) const
void	validate (size_t bytesToWrite) const

Protected Attributes
void *	fPtr = nullptr

Detailed Description

Definition at line 31 of file BufferWriter.h.

Constructor & Destructor Documentation

BufferWriter() [1/3]

skgpu::BufferWriter::BufferWriter ( )

protecteddefault

BufferWriter() [2/3]

skgpu::BufferWriter::BufferWriter ( void *  ptr, size_t  size  )

inlineprotected

Definition at line 65 of file BufferWriter.h.

                                         : fPtr(ptr) {
        SkDEBUGCODE(fEnd = Mark(ptr, ptr ? size : 0);)
    }

BufferWriter() [3/3]

skgpu::BufferWriter::BufferWriter ( void *  ptr, Mark  end = {}  )

inlineprotected

Definition at line 68 of file BufferWriter.h.

                                       {}) : fPtr(ptr) {
        SkDEBUGCODE(fEnd = end;)
    }

Member Function Documentation

makeOffset()

template<typename W >

W skgpu::BufferWriter::makeOffset ( size_t  offsetInBytes ) const

inlineprotected

Definition at line 94 of file BufferWriter.h.

                                             {
        this->validate(offsetInBytes);
        void* p = SkTAddOffset<void>(fPtr, offsetInBytes);
        Mark end{SkDEBUGCODE(fEnd)};
        SkDEBUGCODE(fEnd = Mark(p);)
        return W{p, end};
    }

mark()

Mark skgpu::BufferWriter::mark ( size_t  offset = 0 ) const

inline

Definition at line 58 of file BufferWriter.h.

                                     {
        this->validate(offset);
        return Mark(fPtr, offset);
    }

operator bool()

skgpu::BufferWriter::operator bool ( ) const

inlineexplicit

Definition at line 56 of file BufferWriter.h.

{ return fPtr != nullptr; }

operator=() [1/2]

BufferWriter & skgpu::BufferWriter::operator= ( BufferWriter &&  that )

inlineprotected

Definition at line 73 of file BufferWriter.h.

                                                 {
        fPtr = that.fPtr;
        that.fPtr = nullptr;
        SkDEBUGCODE(fEnd = that.fEnd;)
        SkDEBUGCODE(that.fEnd = Mark();)
        return *this;
    }

operator=() [2/2]

BufferWriter & skgpu::BufferWriter::operator= ( const BufferWriter &  )

protecteddelete

validate()

void skgpu::BufferWriter::validate ( size_t  bytesToWrite ) const

inlineprotected

Definition at line 102 of file BufferWriter.h.

                                             {
        // If the buffer writer had an end marked, make sure we're not crossing it.
        // Ideally, all creators of BufferWriters mark the end, but a lot of legacy code is not set
        // up to easily do this.
        SkASSERT(fPtr || bytesToWrite == 0);
        SkASSERT(!fEnd || Mark(fPtr, bytesToWrite) <= fEnd);
    }

Member Data Documentation

fPtr

void* skgpu::BufferWriter::fPtr = nullptr

protected

Definition at line 111 of file BufferWriter.h.

---

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

• third_party/skia/src/gpu/BufferWriter.h