Home | History | Annotate | Download | only in core 
      1 
      2 /*
      3  * Copyright 2006 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 SkBuffer_DEFINED
     11 #define SkBuffer_DEFINED
     12 
     13 #include "SkScalar.h"
     14 
     15 /** \class SkRBuffer
     16 
     17     Light weight class for reading data from a memory block.
     18     The RBuffer is given the buffer to read from, with either a specified size
     19     or no size (in which case no range checking is performed). It is iillegal
     20     to attempt to read a value from an empty RBuffer (data == null).
     21 */
     22 class SkRBuffer : SkNoncopyable {
     23 public:
     24     SkRBuffer() : fData(0), fPos(0), fStop(0) {}
     25     /** Initialize RBuffer with a data pointer, but no specified length.
     26         This signals the RBuffer to not perform range checks during reading.
     27     */
     28     SkRBuffer(const void* data) {
     29         fData = (const char*)data;
     30         fPos = (const char*)data;
     31         fStop = 0;  // no bounds checking
     32     }
     33     /** Initialize RBuffer with a data point and length.
     34     */
     35     SkRBuffer(const void* data, size_t size) {
     36         SkASSERT(data != 0 || size == 0);
     37         fData = (const char*)data;
     38         fPos = (const char*)data;
     39         fStop = (const char*)data + size;
     40     }
     41 
     42     virtual ~SkRBuffer() { }
     43 
     44     /** Return the number of bytes that have been read from the beginning
     45         of the data pointer.
     46     */
     47     size_t  pos() const { return fPos - fData; }
     48     /** Return the total size of the data pointer. Only defined if the length was
     49         specified in the constructor or in a call to reset().
     50     */
     51     size_t  size() const { return fStop - fData; }
     52     /** Return true if the buffer has read to the end of the data pointer.
     53         Only defined if the length was specified in the constructor or in a call
     54         to reset(). Always returns true if the length was not specified.
     55     */
     56     bool    eof() const { return fPos >= fStop; }
     57 
     58     /** Read the specified number of bytes from the data pointer. If buffer is not
     59         null, copy those bytes into buffer.
     60     */
     61     virtual bool read(void* buffer, size_t size) {
     62         if (size) {
     63             this->readNoSizeCheck(buffer, size);
     64         }
     65         return true;
     66     }
     67 
     68     const void* skip(size_t size); // return start of skipped data
     69     size_t  skipToAlign4();
     70 
     71     bool readPtr(void** ptr) { return read(ptr, sizeof(void*)); }
     72     bool readScalar(SkScalar* x) { return read(x, 4); }
     73     bool readU32(uint32_t* x) { return read(x, 4); }
     74     bool readS32(int32_t* x) { return read(x, 4); }
     75     bool readU16(uint16_t* x) { return read(x, 2); }
     76     bool readS16(int16_t* x) { return read(x, 2); }
     77     bool readU8(uint8_t* x) { return read(x, 1); }
     78     bool readBool(bool* x) {
     79         uint8_t u8;
     80         if (this->readU8(&u8)) {
     81             *x = (u8 != 0);
     82             return true;
     83         }
     84         return false;
     85     }
     86 
     87 protected:
     88     void    readNoSizeCheck(void* buffer, size_t size);
     89 
     90     const char* fData;
     91     const char* fPos;
     92     const char* fStop;
     93 };
     94 
     95 /** \class SkRBufferWithSizeCheck
     96 
     97     Same as SkRBuffer, except that a size check is performed before the read operation and an
     98     error is set if the read operation is attempting to read past the end of the data.
     99 */
    100 class SkRBufferWithSizeCheck : public SkRBuffer {
    101 public:
    102     SkRBufferWithSizeCheck(const void* data, size_t size) : SkRBuffer(data, size), fError(false) {}
    103 
    104     /** Read the specified number of bytes from the data pointer. If buffer is not
    105         null and the number of bytes to read does not overflow this object's data,
    106         copy those bytes into buffer.
    107     */
    108     bool read(void* buffer, size_t size) override;
    109 
    110     /** Returns whether or not a read operation attempted to read past the end of the data.
    111     */
    112     bool isValid() const { return !fError; }
    113 private:
    114     bool fError;
    115 };
    116 
    117 /** \class SkWBuffer
    118 
    119     Light weight class for writing data to a memory block.
    120     The WBuffer is given the buffer to write into, with either a specified size
    121     or no size, in which case no range checking is performed. An empty WBuffer
    122     is legal, in which case no data is ever written, but the relative pos()
    123     is updated.
    124 */
    125 class SkWBuffer : SkNoncopyable {
    126 public:
    127     SkWBuffer() : fData(0), fPos(0), fStop(0) {}
    128     SkWBuffer(void* data) { reset(data); }
    129     SkWBuffer(void* data, size_t size) { reset(data, size); }
    130 
    131     void reset(void* data) {
    132         fData = (char*)data;
    133         fPos = (char*)data;
    134         fStop = 0;  // no bounds checking
    135     }
    136 
    137     void reset(void* data, size_t size) {
    138         SkASSERT(data != 0 || size == 0);
    139         fData = (char*)data;
    140         fPos = (char*)data;
    141         fStop = (char*)data + size;
    142     }
    143 
    144     size_t  pos() const { return fPos - fData; }
    145     void*   skip(size_t size); // return start of skipped data
    146 
    147     void write(const void* buffer, size_t size) {
    148         if (size) {
    149             this->writeNoSizeCheck(buffer, size);
    150         }
    151     }
    152 
    153     size_t  padToAlign4();
    154 
    155     void    writePtr(const void* x) { this->writeNoSizeCheck(&x, sizeof(x)); }
    156     void    writeScalar(SkScalar x) { this->writeNoSizeCheck(&x, 4); }
    157     void    write32(int32_t x) { this->writeNoSizeCheck(&x, 4); }
    158     void    write16(int16_t x) { this->writeNoSizeCheck(&x, 2); }
    159     void    write8(int8_t x) { this->writeNoSizeCheck(&x, 1); }
    160     void    writeBool(bool x) { this->write8(x); }
    161 
    162 private:
    163     void    writeNoSizeCheck(const void* buffer, size_t size);
    164 
    165     char* fData;
    166     char* fPos;
    167     char* fStop;
    168 };
    169 
    170 #endif
    171