LCOV - code coverage report
Current view: directory - gfx/skia/include/core - SkReader32.h (source / functions) Found Hit Coverage
Test: app.info Lines: 55 0 0.0 %
Date: 2012-06-02 Functions: 23 0 0.0 %

       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

Generated by: LCOV version 1.7