LCOV - app.info - gfx/skia/include/core/SkBuffer.h

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

           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               0 :     SkRBuffer(const void* data) {
          29               0 :         fData = (const char*)data;
          30               0 :         fPos = (const char*)data;
          31               0 :         fStop = 0;  // no bounds checking
          32               0 :     }
          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                 :     /** Return the number of bytes that have been read from the beginning
          43                 :         of the data pointer.
          44                 :     */
          45               0 :     size_t  pos() const { return fPos - fData; }
          46                 :     /** Return the total size of the data pointer. Only defined if the length was
          47                 :         specified in the constructor or in a call to reset().
          48                 :     */
          49                 :     size_t  size() const { return fStop - fData; }
          50                 :     /** Return true if the buffer has read to the end of the data pointer.
          51                 :         Only defined if the length was specified in the constructor or in a call
          52                 :         to reset(). Always returns true if the length was not specified.
          53                 :     */
          54                 :     bool    eof() const { return fPos >= fStop; }
          55                 :
          56                 :     /** Read the specified number of bytes from the data pointer. If buffer is not
          57                 :         null, copy those bytes into buffer.
          58                 :     */
          59               0 :     void read(void* buffer, size_t size) {
          60               0 :         if (size) {
          61               0 :             this->readNoSizeCheck(buffer, size);
          62                 :         }
          63               0 :     }
          64                 :
          65                 :     const void* skip(size_t size); // return start of skipped data
          66                 :     size_t  skipToAlign4();
          67                 :
          68                 :     void*       readPtr() { void* ptr; read(&ptr, sizeof(ptr)); return ptr; }
          69                 :     SkScalar    readScalar() { SkScalar x; read(&x, 4); return x; }
          70                 :     uint32_t    readU32() { uint32_t x; read(&x, 4); return x; }
          71               0 :     int32_t     readS32() { int32_t x; read(&x, 4); return x; }
          72                 :     uint16_t    readU16() { uint16_t x; read(&x, 2); return x; }
          73                 :     int16_t     readS16() { int16_t x; read(&x, 2); return x; }
          74                 :     uint8_t     readU8() { uint8_t x; read(&x, 1); return x; }
          75                 :     bool        readBool() { return this->readU8() != 0; }
          76                 :
          77                 : protected:
          78                 :     void    readNoSizeCheck(void* buffer, size_t size);
          79                 :
          80                 :     const char* fData;
          81                 :     const char* fPos;
          82                 :     const char* fStop;
          83                 : };
          84                 :
          85                 : /** \class SkWBuffer
          86                 :
          87                 :     Light weight class for writing data to a memory block.
          88                 :     The WBuffer is given the buffer to write into, with either a specified size
          89                 :     or no size, in which case no range checking is performed. An empty WBuffer
          90                 :     is legal, in which case no data is ever written, but the relative pos()
          91                 :     is updated.
          92                 : */
          93                 : class SkWBuffer : SkNoncopyable {
          94                 : public:
          95                 :     SkWBuffer() : fData(0), fPos(0), fStop(0) {}
          96               0 :     SkWBuffer(void* data) { reset(data); }
          97                 :     SkWBuffer(void* data, size_t size) { reset(data, size); }
          98                 :
          99               0 :     void reset(void* data) {
         100               0 :         fData = (char*)data;
         101               0 :         fPos = (char*)data;
         102               0 :         fStop = 0;  // no bounds checking
         103               0 :     }
         104                 :
         105                 :     void reset(void* data, size_t size) {
         106                 :         SkASSERT(data != 0 || size == 0);
         107                 :         fData = (char*)data;
         108                 :         fPos = (char*)data;
         109                 :         fStop = (char*)data + size;
         110                 :     }
         111                 :
         112               0 :     size_t  pos() const { return fPos - fData; }
         113                 :     void*   skip(size_t size); // return start of skipped data
         114                 :
         115               0 :     void write(const void* buffer, size_t size) {
         116               0 :         if (size) {
         117               0 :             this->writeNoSizeCheck(buffer, size);
         118                 :         }
         119               0 :     }
         120                 :
         121                 :     size_t  padToAlign4();
         122                 :
         123                 :     void    writePtr(const void* x) { this->writeNoSizeCheck(&x, sizeof(x)); }
         124                 :     void    writeScalar(SkScalar x) { this->writeNoSizeCheck(&x, 4); }
         125               0 :     void    write32(int32_t x) { this->writeNoSizeCheck(&x, 4); }
         126                 :     void    write16(int16_t x) { this->writeNoSizeCheck(&x, 2); }
         127                 :     void    write8(int8_t x) { this->writeNoSizeCheck(&x, 1); }
         128                 :     void    writeBool(bool x) { this->write8(x); }
         129                 :
         130                 : protected:
         131                 :     void    writeNoSizeCheck(const void* buffer, size_t size);
         132                 :
         133                 :     char* fData;
         134                 :     char* fPos;
         135                 :     char* fStop;
         136                 : };
         137                 :
         138                 : #endif
         139                 :

Generated by: LCOV version 1.7