diff options
author | halcanary <halcanary@google.com> | 2014-08-18 13:04:59 -0700 |
---|---|---|
committer | Commit bot <commit-bot@chromium.org> | 2014-08-18 13:04:59 -0700 |
commit | 2a51d7c74cec217195f861677de8998b382b39e4 (patch) | |
tree | 3f6e78c3529b91d2fcd75251eca3a388cce901ec /src/core/SkReader32.h | |
parent | 750ae26745d261183001a78d24251f6392e96b27 (diff) |
Move SkReadBuffer.h and SkReader32.h out of include.
R=mtklein@google.com, reed@google.com
Author: halcanary@google.com
Review URL: https://codereview.chromium.org/481053002
Diffstat (limited to 'src/core/SkReader32.h')
-rw-r--r-- | src/core/SkReader32.h | 160 |
1 files changed, 160 insertions, 0 deletions
diff --git a/src/core/SkReader32.h b/src/core/SkReader32.h new file mode 100644 index 0000000000..3d874d170a --- /dev/null +++ b/src/core/SkReader32.h @@ -0,0 +1,160 @@ + +/* + * Copyright 2008 The Android Open Source Project + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + +#ifndef SkReader32_DEFINED +#define SkReader32_DEFINED + +#include "SkMatrix.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkRRect.h" +#include "SkScalar.h" + +class SkString; + +class SkReader32 : SkNoncopyable { +public: + SkReader32() : fCurr(NULL), fStop(NULL), fBase(NULL) {} + SkReader32(const void* data, size_t size) { + this->setMemory(data, size); + } + + void setMemory(const void* data, size_t size) { + SkASSERT(ptr_align_4(data)); + SkASSERT(SkAlign4(size) == size); + + fBase = fCurr = (const char*)data; + fStop = (const char*)data + size; + } + + size_t size() const { return fStop - fBase; } + size_t offset() const { return fCurr - fBase; } + bool eof() const { return fCurr >= fStop; } + const void* base() const { return fBase; } + const void* peek() const { return fCurr; } + + size_t available() const { return fStop - fCurr; } + bool isAvailable(size_t size) const { return size <= this->available(); } + + void rewind() { fCurr = fBase; } + + void setOffset(size_t offset) { + SkASSERT(SkAlign4(offset) == offset); + SkASSERT(offset <= this->size()); + fCurr = fBase + offset; + } + + bool readBool() { return this->readInt() != 0; } + + int32_t readInt() { + SkASSERT(ptr_align_4(fCurr)); + int32_t value = *(const int32_t*)fCurr; + fCurr += sizeof(value); + SkASSERT(fCurr <= fStop); + return value; + } + + void* readPtr() { + void* ptr; + // we presume this "if" is resolved at compile-time + if (4 == sizeof(void*)) { + ptr = *(void**)fCurr; + } else { + memcpy(&ptr, fCurr, sizeof(void*)); + } + fCurr += sizeof(void*); + return ptr; + } + + SkScalar readScalar() { + SkASSERT(ptr_align_4(fCurr)); + SkScalar value = *(const SkScalar*)fCurr; + fCurr += sizeof(value); + SkASSERT(fCurr <= fStop); + return value; + } + + const void* skip(size_t size) { + SkASSERT(ptr_align_4(fCurr)); + const void* addr = fCurr; + fCurr += SkAlign4(size); + SkASSERT(fCurr <= fStop); + return addr; + } + + template <typename T> const T& skipT() { + SkASSERT(SkAlign4(sizeof(T)) == sizeof(T)); + return *(const T*)this->skip(sizeof(T)); + } + + void read(void* dst, size_t size) { + SkASSERT(0 == size || dst != NULL); + SkASSERT(ptr_align_4(fCurr)); + memcpy(dst, fCurr, size); + fCurr += SkAlign4(size); + SkASSERT(fCurr <= fStop); + } + + uint8_t readU8() { return (uint8_t)this->readInt(); } + uint16_t readU16() { return (uint16_t)this->readInt(); } + int32_t readS32() { return this->readInt(); } + uint32_t readU32() { return this->readInt(); } + + bool readPath(SkPath* path) { + return this->readObjectFromMemory(path); + } + + bool readMatrix(SkMatrix* matrix) { + return this->readObjectFromMemory(matrix); + } + + bool readRRect(SkRRect* rrect) { + return this->readObjectFromMemory(rrect); + } + + bool readRegion(SkRegion* rgn) { + return this->readObjectFromMemory(rgn); + } + + /** + * Read the length of a string (written by SkWriter32::writeString) into + * len (if len is not NULL) and return the null-ternimated address of the + * string within the reader's buffer. + */ + const char* readString(size_t* len = NULL); + + /** + * Read the string (written by SkWriter32::writeString) and return it in + * copy (if copy is not null). Return the length of the string. + */ + size_t readIntoString(SkString* copy); + +private: + template <typename T> bool readObjectFromMemory(T* obj) { + size_t size = obj->readFromMemory(this->peek(), this->available()); + // If readFromMemory() fails (which means that available() was too small), it returns 0 + bool success = (size > 0) && (size <= this->available()) && (SkAlign4(size) == size); + // In case of failure, we want to skip to the end + (void)this->skip(success ? size : this->available()); + return success; + } + + // these are always 4-byte aligned + const char* fCurr; // current position within buffer + const char* fStop; // end of buffer + const char* fBase; // beginning of buffer + +#ifdef SK_DEBUG + static bool ptr_align_4(const void* ptr) { + return (((const char*)ptr - (const char*)NULL) & 3) == 0; + } +#endif +}; + +#endif |