Home | History | Annotate | Download | only in core 
      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     SkReader32() : fCurr(NULL), fStop(NULL), fBase(NULL) {}
     20     SkReader32(const void* data, size_t size)  {
     21         this->setMemory(data, size);
     22     }
     23 
     24     void setMemory(const void* data, size_t size) {
     25         SkASSERT(ptr_align_4(data));
     26         SkASSERT(SkAlign4(size) == size);
     27 
     28         fBase = fCurr = (const char*)data;
     29         fStop = (const char*)data + size;
     30     }
     31 
     32     uint32_t size() const { return fStop - fBase; }
     33     uint32_t offset() const { return fCurr - fBase; }
     34     bool eof() const { return fCurr >= fStop; }
     35     const void* base() const { return fBase; }
     36     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     void rewind() { fCurr = fBase; }
     42 
     43     void setOffset(size_t offset) {
     44         SkASSERT(SkAlign4(offset) == offset);
     45         SkASSERT(offset <= this->size());
     46         fCurr = fBase + offset;
     47     }
     48 
     49     bool readBool() { return this->readInt() != 0; }
     50 
     51     int32_t readInt() {
     52         SkASSERT(ptr_align_4(fCurr));
     53         int32_t value = *(const int32_t*)fCurr;
     54         fCurr += sizeof(value);
     55         SkASSERT(fCurr <= fStop);
     56         return value;
     57     }
     58 
     59     SkScalar readScalar() {
     60         SkASSERT(ptr_align_4(fCurr));
     61         SkScalar value = *(const SkScalar*)fCurr;
     62         fCurr += sizeof(value);
     63         SkASSERT(fCurr <= fStop);
     64         return value;
     65     }
     66 
     67     const void* skip(size_t size) {
     68         SkASSERT(ptr_align_4(fCurr));
     69         const void* addr = fCurr;
     70         fCurr += SkAlign4(size);
     71         SkASSERT(fCurr <= fStop);
     72         return addr;
     73     }
     74 
     75     template <typename T> const T& skipT() {
     76         SkASSERT(SkAlign4(sizeof(T)) == sizeof(T));
     77         return *(const T*)this->skip(sizeof(T));
     78     }
     79 
     80     void read(void* dst, size_t size) {
     81         SkASSERT(0 == size || dst != NULL);
     82         SkASSERT(ptr_align_4(fCurr));
     83         memcpy(dst, fCurr, size);
     84         fCurr += SkAlign4(size);
     85         SkASSERT(fCurr <= fStop);
     86     }
     87 
     88     uint8_t readU8() { return (uint8_t)this->readInt(); }
     89     uint16_t readU16() { return (uint16_t)this->readInt(); }
     90     int32_t readS32() { return this->readInt(); }
     91     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     static bool ptr_align_4(const void* ptr) {
    114         return (((const char*)ptr - (const char*)NULL) & 3) == 0;
    115     }
    116 #endif
    117 };
    118 
    119 #endif
    120