1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef SkBuffer_DEFINED 18 #define SkBuffer_DEFINED 19 20 #include "SkScalar.h" 21 22 /** \class SkRBuffer 23 24 Light weight class for reading data from a memory block. 25 The RBuffer is given the buffer to read from, with either a specified size 26 or no size (in which case no range checking is performed). It is iillegal 27 to attempt to read a value from an empty RBuffer (data == null). 28 */ 29 class SkRBuffer : SkNoncopyable { 30 public: SkRBuffer()31 SkRBuffer() : fData(0), fPos(0), fStop(0) {} 32 /** Initialize RBuffer with a data pointer, but no specified length. 33 This signals the RBuffer to not perform range checks during reading. 34 */ SkRBuffer(const void * data)35 SkRBuffer(const void* data) 36 { 37 fData = (const char*)data; 38 fPos = (const char*)data; 39 fStop = 0; // no bounds checking 40 } 41 /** Initialize RBuffer with a data point and length. 42 */ SkRBuffer(const void * data,size_t size)43 SkRBuffer(const void* data, size_t size) 44 { 45 SkASSERT(data != 0 || size == 0); 46 fData = (const char*)data; 47 fPos = (const char*)data; 48 fStop = (const char*)data + size; 49 } 50 51 /** Return the number of bytes that have been read from the beginning 52 of the data pointer. 53 */ pos()54 size_t pos() const { return fPos - fData; } 55 /** Return the total size of the data pointer. Only defined if the length was 56 specified in the constructor or in a call to reset(). 57 */ size()58 size_t size() const { return fStop - fData; } 59 /** Return true if the buffer has read to the end of the data pointer. 60 Only defined if the length was specified in the constructor or in a call 61 to reset(). Always returns true if the length was not specified. 62 */ eof()63 bool eof() const { return fPos >= fStop; } 64 65 /** Read the specified number of bytes from the data pointer. If buffer is not 66 null, copy those bytes into buffer. 67 */ read(void * buffer,size_t size)68 void read(void* buffer, size_t size) { if (size) this->readNoSizeCheck(buffer, size); } 69 const void* skip(size_t size); // return start of skipped data 70 size_t skipToAlign4(); 71 readPtr()72 void* readPtr() { void* ptr; read(&ptr, sizeof(ptr)); return ptr; } readScalar()73 SkScalar readScalar() { SkScalar x; read(&x, 4); return x; } readU32()74 uint32_t readU32() { uint32_t x; read(&x, 4); return x; } readS32()75 int32_t readS32() { int32_t x; read(&x, 4); return x; } readU16()76 uint16_t readU16() { uint16_t x; read(&x, 2); return x; } readS16()77 int16_t readS16() { int16_t x; read(&x, 2); return x; } readU8()78 uint8_t readU8() { uint8_t x; read(&x, 1); return x; } readBool()79 bool readBool() { return this->readU8() != 0; } 80 81 protected: 82 void readNoSizeCheck(void* buffer, size_t size); 83 84 const char* fData; 85 const char* fPos; 86 const char* fStop; 87 }; 88 89 /** \class SkWBuffer 90 91 Light weight class for writing data to a memory block. 92 The WBuffer is given the buffer to write into, with either a specified size 93 or no size, in which case no range checking is performed. An empty WBuffer 94 is legal, in which case no data is ever written, but the relative pos() 95 is updated. 96 */ 97 class SkWBuffer : SkNoncopyable { 98 public: SkWBuffer()99 SkWBuffer() : fData(0), fPos(0), fStop(0) {} SkWBuffer(void * data)100 SkWBuffer(void* data) { reset(data); } SkWBuffer(void * data,size_t size)101 SkWBuffer(void* data, size_t size) { reset(data, size); } 102 reset(void * data)103 void reset(void* data) 104 { 105 fData = (char*)data; 106 fPos = (char*)data; 107 fStop = 0; // no bounds checking 108 } reset(void * data,size_t size)109 void reset(void* data, size_t size) 110 { 111 SkASSERT(data != 0 || size == 0); 112 fData = (char*)data; 113 fPos = (char*)data; 114 fStop = (char*)data + size; 115 } 116 data()117 void* data() const { return fData; } pos()118 size_t pos() const { return fPos - fData; } size()119 size_t size() const { return fStop - fData; } eof()120 bool eof() const { return fPos >= fStop; } 121 void* skip(size_t size); // return start of skipped data write(const void * buffer,size_t size)122 void write(const void* buffer, size_t size) { if (size) this->writeNoSizeCheck(buffer, size); } 123 size_t padToAlign4(); 124 writePtr(const void * x)125 void writePtr(const void* x) { this->writeNoSizeCheck(&x, sizeof(x)); } writeScalar(SkScalar x)126 void writeScalar(SkScalar x) { this->writeNoSizeCheck(&x, 4); } write32(int32_t x)127 void write32(int32_t x) { this->writeNoSizeCheck(&x, 4); } write16(int16_t x)128 void write16(int16_t x) { this->writeNoSizeCheck(&x, 2); } write8(int8_t x)129 void write8(int8_t x) { this->writeNoSizeCheck(&x, 1); } writeBool(bool x)130 void writeBool(bool x) { this->write8(x); } 131 132 protected: 133 void writeNoSizeCheck(const void* buffer, size_t size); 134 135 char* fData; 136 char* fPos; 137 char* fStop; 138 }; 139 140 #endif 141 142