SkData Class Reference

#include <SkData.h>

Inheritance diagram for SkData:

Public Types
typedef void(*	ReleaseProc) (const void *ptr, void *context)

Public Member Functions
size_t	size () const
bool	isEmpty () const
const void *	data () const
const uint8_t *	bytes () const
void *	writable_data ()
size_t	copyRange (size_t offset, size_t length, void *buffer) const
bool	equals (const SkData *other) const
Public Member Functions inherited from SkNVRefCnt< SkData >
	SkNVRefCnt ()
	~SkNVRefCnt ()
bool	unique () const
void	ref () const
void	unref () const
void	deref () const
bool	refCntGreaterThan (int32_t threadIsolatedTestCnt) const

Static Public Member Functions
static sk_sp< SkData >	MakeWithCopy (const void *data, size_t length)
static sk_sp< SkData >	MakeUninitialized (size_t length)
static sk_sp< SkData >	MakeZeroInitialized (size_t length)
static sk_sp< SkData >	MakeWithCString (const char cstr[])
static sk_sp< SkData >	MakeWithProc (const void *ptr, size_t length, ReleaseProc proc, void *ctx)
static sk_sp< SkData >	MakeWithoutCopy (const void *data, size_t length)
static sk_sp< SkData >	MakeFromMalloc (const void *data, size_t length)
static sk_sp< SkData >	MakeFromFileName (const char path[])
static sk_sp< SkData >	MakeFromFILE (FILE *f)
static sk_sp< SkData >	MakeFromFD (int fd)
static sk_sp< SkData >	MakeFromStream (SkStream *, size_t size)
static sk_sp< SkData >	MakeSubset (const SkData *src, size_t offset, size_t length)
static sk_sp< SkData >	MakeEmpty ()

Friends
class	SkNVRefCnt< SkData >

Detailed Description

SkData holds an immutable data buffer. Not only is the data immutable, but the actual ptr that is returned (by data() or bytes()) is guaranteed to always be the same for the life of this instance.

Definition at line 25 of file SkData.h.

Member Typedef Documentation

ReleaseProc

typedef void(* SkData::ReleaseProc) (const void *ptr, void *context)

Function that, if provided, will be called when the SkData goes out of scope, allowing for custom allocation/freeing of the data's contents.

Definition at line 78 of file SkData.h.

Member Function Documentation

bytes()

const uint8_t * SkData::bytes ( ) const

inline

Like data(), returns a read-only ptr into the data, but in this case it is cast to uint8_t*, to make it easy to add an offset to it.

Definition at line 43 of file SkData.h.

                                 {
        return reinterpret_cast<const uint8_t*>(fPtr);
    }

copyRange()

size_t SkData::copyRange	(	size_t	offset,
		size_t	length,
		void *	buffer
	)		const

Helper to copy a range of the data into a caller-provided buffer. Returns the actual number of bytes copied, after clamping offset and length to the size of the data. If buffer is NULL, it is ignored, and only the computed number of bytes is returned.

Definition at line 53 of file SkData.cpp.

                                                                         {
    size_t available = fSize;
    if (offset >= available || 0 == length) {
        return 0;
    }
    available -= offset;
    if (length > available) {
        length = available;
    }
    SkASSERT(length > 0);
 
    if (buffer) {
        memcpy(buffer, this->bytes() + offset, length);
    }
    return length;
}

data()

const void * SkData::data ( ) const

inline

Returns the ptr to the data.

Definition at line 37 of file SkData.h.

{ return fPtr; }

equals()

bool SkData::equals

(

const SkData *

other

)

const

Returns true if these two objects have the same length and contents, effectively returning 0 == memcmp(...)

Definition at line 43 of file SkData.cpp.

                                             {
    if (this == other) {
        return true;
    }
    if (nullptr == other) {
        return false;
    }
    return fSize == other->fSize && !sk_careful_memcmp(fPtr, other->fPtr, fSize);
}

isEmpty()

bool SkData::isEmpty ( ) const

inline

Definition at line 32 of file SkData.h.

{ return 0 == fSize; }

MakeEmpty()

sk_sp< SkData > SkData::MakeEmpty ( )

static

Returns a new empty dataref (or a reference to a shared empty dataref). New or shared, the caller must see that unref() is eventually called.

Definition at line 94 of file SkData.cpp.

                                {
    static SkOnce once;
    static SkData* empty;
 
    once([]{ empty = new SkData(nullptr, 0, nullptr, nullptr); });
    return sk_ref_sp(empty);
}

MakeFromFD()

sk_sp< SkData > SkData::MakeFromFD ( int  fd )

static

Create a new dataref from a file descriptor. This does not take ownership of the file descriptor, nor close it. The caller is free to close the file descriptor at its convenience. The file descriptor must be open for reading only. Returns NULL on failure.

Definition at line 158 of file SkData.cpp.

                                       {
    size_t size;
    void* addr = sk_fdmmap(fd, &size);
    if (nullptr == addr) {
        return nullptr;
    }
    return SkData::MakeWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
}

MakeFromFILE()

sk_sp< SkData > SkData::MakeFromFILE ( FILE *  f )

static

Create a new dataref from a stdio FILE. This does not take ownership of the FILE, nor close it. The caller is free to close the FILE at its convenience. The FILE must be open for reading only. Returns NULL on failure.

Definition at line 138 of file SkData.cpp.

                                          {
    size_t size;
    void* addr = sk_fmmap(f, &size);
    if (nullptr == addr) {
        return nullptr;
    }
 
    return SkData::MakeWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
}

MakeFromFileName()

sk_sp< SkData > SkData::MakeFromFileName ( const char  path[] )

static

Create a new dataref the file with the specified path. If the file cannot be opened, this returns NULL.

Definition at line 148 of file SkData.cpp.

                                                        {
    FILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : nullptr;
    if (nullptr == f) {
        return nullptr;
    }
    auto data = MakeFromFILE(f);
    sk_fclose(f);
    return data;
}

MakeFromMalloc()

sk_sp< SkData > SkData::MakeFromMalloc ( const void *  data, size_t  length  )

static

Create a new dataref from a pointer allocated by malloc. The Data object takes ownership of that allocation, and will handling calling sk_free.

Definition at line 107 of file SkData.cpp.

                                                                    {
    return sk_sp<SkData>(new SkData(data, length, sk_free_releaseproc, nullptr));
}

MakeFromStream()

sk_sp< SkData > SkData::MakeFromStream ( SkStream *  stream, size_t  size  )

static

Attempt to read size bytes into a SkData. If the read succeeds, return the data, else return NULL. Either way the stream's cursor may have been changed as a result of calling read().

Definition at line 208 of file SkData.cpp.

                                                                  {
    // reduce the chance of OOM by checking that the stream has enough bytes to read from before
    // allocating that potentially large buffer.
    if (StreamRemainingLengthIsBelow(stream, size)) {
        return nullptr;
    }
    sk_sp<SkData> data(SkData::MakeUninitialized(size));
    if (stream->read(data->writable_data(), size) != size) {
        return nullptr;
    }
    return data;
}

MakeSubset()

sk_sp< SkData > SkData::MakeSubset ( const SkData *  src, size_t  offset, size_t  length  )

static

Create a new dataref using a subset of the data in the specified src dataref.

Definition at line 173 of file SkData.cpp.

                                                                                {
    /*
        We could, if we wanted/need to, just make a deep copy of src's data,
        rather than referencing it. This would duplicate the storage (of the
        subset amount) but would possibly allow src to go out of scope sooner.
     */
 
    size_t available = src->size();
    if (offset >= available || 0 == length) {
        return SkData::MakeEmpty();
    }
    available -= offset;
    if (length > available) {
        length = available;
    }
    SkASSERT(length > 0);
 
    src->ref(); // this will be balanced in sk_dataref_releaseproc
    return sk_sp<SkData>(new SkData(src->bytes() + offset, length, sk_dataref_releaseproc,
                                    const_cast<SkData*>(src)));
}

MakeUninitialized()

sk_sp< SkData > SkData::MakeUninitialized ( size_t  length )

static

Create a new data with uninitialized contents. The caller should call writable_data() to write into the buffer, but this must be done before another ref() is made.

Definition at line 116 of file SkData.cpp.

                                                     {
    return PrivateNewWithCopy(nullptr, length);
}

MakeWithCopy()

sk_sp< SkData > SkData::MakeWithCopy ( const void *  data, size_t  length  )

static

Create a new dataref by copying the specified data

Definition at line 111 of file SkData.cpp.

                                                                 {
    SkASSERT(src);
    return PrivateNewWithCopy(src, length);
}

MakeWithCString()

sk_sp< SkData > SkData::MakeWithCString ( const char  cstr[] )

static

Create a new dataref by copying the specified c-string (a null-terminated array of bytes). The returned SkData will have size() equal to strlen(cstr) + 1. If cstr is NULL, it will be treated the same as "".

Definition at line 195 of file SkData.cpp.

                                                       {
    size_t size;
    if (nullptr == cstr) {
        cstr = "";
        size = 1;
    } else {
        size = strlen(cstr) + 1;
    }
    return MakeWithCopy(cstr, size);
}

MakeWithoutCopy()

static sk_sp< SkData > SkData::MakeWithoutCopy ( const void *  data, size_t  length  )

inlinestatic

Call this when the data parameter is already const and will outlive the lifetime of the SkData. Suitable for with const globals.

Definition at line 116 of file SkData.h.

                                                                          {
        return MakeWithProc(data, length, NoopReleaseProc, nullptr);
    }

MakeWithProc()

sk_sp< SkData > SkData::MakeWithProc ( const void *  ptr, size_t  length, ReleaseProc  proc, void *  ctx  )

static

Create a new dataref, taking the ptr as is, and using the releaseproc to free it. The proc may be NULL.

Definition at line 128 of file SkData.cpp.

                                                                                              {
    return sk_sp<SkData>(new SkData(ptr, length, proc, ctx));
}

MakeZeroInitialized()

sk_sp< SkData > SkData::MakeZeroInitialized ( size_t  length )

static

Create a new data with zero-initialized contents. The caller should call writable_data() to write into the buffer, but this must be done before another ref() is made.

Definition at line 120 of file SkData.cpp.

                                                       {
    auto data = MakeUninitialized(length);
    if (length != 0) {
        memset(data->writable_data(), 0, data->size());
    }
    return data;
}

size()

size_t SkData::size ( ) const

inline

Returns the number of bytes stored.

Definition at line 30 of file SkData.h.

{ return fSize; }

writable_data()

void * SkData::writable_data ( )

inline

USE WITH CAUTION. This call will assert that the refcnt is 1, as a precaution against modifying the contents when another client/thread has access to the data.

Definition at line 52 of file SkData.h.

                          {
        if (fSize) {
            // only assert we're unique if we're not empty
            SkASSERT(this->unique());
        }
        return const_cast<void*>(fPtr);
    }

Friends And Related Function Documentation

SkNVRefCnt< SkData >

friend class SkNVRefCnt< SkData >

friend

Definition at line 167 of file SkData.h.

---

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

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