1 :
2 : /*
3 : * Copyright 2008 The Android Open Source Project
4 : *
5 : * Use of this source code is governed by a BSD-style license that can be
6 : * found in the LICENSE file.
7 : */
8 :
9 :
10 : #ifndef SkReader32_DEFINED
11 : #define SkReader32_DEFINED
12 :
13 : #include "SkScalar.h"
14 :
15 : class SkString;
16 :
17 : class SkReader32 : SkNoncopyable {
18 : public:
19 0 : SkReader32() : fCurr(NULL), fStop(NULL), fBase(NULL) {}
20 0 : SkReader32(const void* data, size_t size) {
21 0 : this->setMemory(data, size);
22 0 : }
23 :
24 0 : void setMemory(const void* data, size_t size) {
25 0 : SkASSERT(ptr_align_4(data));
26 0 : SkASSERT(SkAlign4(size) == size);
27 :
28 0 : fBase = fCurr = (const char*)data;
29 0 : fStop = (const char*)data + size;
30 0 : }
31 :
32 0 : uint32_t size() const { return fStop - fBase; }
33 0 : uint32_t offset() const { return fCurr - fBase; }
34 0 : bool eof() const { return fCurr >= fStop; }
35 0 : const void* base() const { return fBase; }
36 0 : const void* peek() const { return fCurr; }
37 :
38 : uint32_t available() const { return fStop - fCurr; }
39 : bool isAvailable(uint32_t size) const { return fCurr + size <= fStop; }
40 :
41 0 : void rewind() { fCurr = fBase; }
42 :
43 0 : void setOffset(size_t offset) {
44 0 : SkASSERT(SkAlign4(offset) == offset);
45 0 : SkASSERT(offset <= this->size());
46 0 : fCurr = fBase + offset;
47 0 : }
48 :
49 0 : bool readBool() { return this->readInt() != 0; }
50 :
51 0 : int32_t readInt() {
52 0 : SkASSERT(ptr_align_4(fCurr));
53 0 : int32_t value = *(const int32_t*)fCurr;
54 0 : fCurr += sizeof(value);
55 0 : SkASSERT(fCurr <= fStop);
56 0 : return value;
57 : }
58 :
59 0 : SkScalar readScalar() {
60 0 : SkASSERT(ptr_align_4(fCurr));
61 0 : SkScalar value = *(const SkScalar*)fCurr;
62 0 : fCurr += sizeof(value);
63 0 : SkASSERT(fCurr <= fStop);
64 0 : return value;
65 : }
66 :
67 0 : const void* skip(size_t size) {
68 0 : SkASSERT(ptr_align_4(fCurr));
69 0 : const void* addr = fCurr;
70 0 : fCurr += SkAlign4(size);
71 0 : SkASSERT(fCurr <= fStop);
72 0 : return addr;
73 : }
74 :
75 0 : template <typename T> const T& skipT() {
76 : SkASSERT(SkAlign4(sizeof(T)) == sizeof(T));
77 0 : return *(const T*)this->skip(sizeof(T));
78 : }
79 :
80 0 : void read(void* dst, size_t size) {
81 0 : SkASSERT(0 == size || dst != NULL);
82 0 : SkASSERT(ptr_align_4(fCurr));
83 0 : memcpy(dst, fCurr, size);
84 0 : fCurr += SkAlign4(size);
85 0 : SkASSERT(fCurr <= fStop);
86 0 : }
87 :
88 0 : uint8_t readU8() { return (uint8_t)this->readInt(); }
89 0 : uint16_t readU16() { return (uint16_t)this->readInt(); }
90 0 : int32_t readS32() { return this->readInt(); }
91 0 : uint32_t readU32() { return this->readInt(); }
92 :
93 : /**
94 : * Read the length of a string (written by SkWriter32::writeString) into
95 : * len (if len is not NULL) and return the null-ternimated address of the
96 : * string within the reader's buffer.
97 : */
98 : const char* readString(size_t* len = NULL);
99 :
100 : /**
101 : * Read the string (written by SkWriter32::writeString) and return it in
102 : * copy (if copy is not null). Return the length of the string.
103 : */
104 : size_t readIntoString(SkString* copy);
105 :
106 : private:
107 : // these are always 4-byte aligned
108 : const char* fCurr; // current position within buffer
109 : const char* fStop; // end of buffer
110 : const char* fBase; // beginning of buffer
111 :
112 : #ifdef SK_DEBUG
113 0 : static bool ptr_align_4(const void* ptr) {
114 0 : return (((const char*)ptr - (const char*)NULL) & 3) == 0;
115 : }
116 : #endif
117 : };
118 :
119 : #endif
|