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

       1                 : 
       2                 : /*
       3                 :  * Copyright 2011 Google Inc.
       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                 : 
      11                 : #ifndef SkData_DEFINED
      12                 : #define SkData_DEFINED
      13                 : 
      14                 : #include "SkRefCnt.h"
      15                 : 
      16                 : /**
      17                 :  *  SkData holds an immutable data buffer. Not only is the data immutable,
      18                 :  *  but the actual ptr that is returned (by data() or bytes()) is guaranteed
      19                 :  *  to always be the same for the life of this instance.
      20                 :  */
      21                 : class SkData : public SkRefCnt {
      22                 : public:
      23                 :     /**
      24                 :      *  Returns the number of bytes stored.
      25                 :      */
      26               0 :     size_t size() const { return fSize; }
      27                 : 
      28                 :     /**
      29                 :      *  Returns the ptr to the data.
      30                 :      */
      31               0 :     const void* data() const { return fPtr; }
      32                 : 
      33                 :     /**
      34                 :      *  Like data(), returns a read-only ptr into the data, but in this case
      35                 :      *  it is cast to uint8_t*, to make it easy to add an offset to it.
      36                 :      */
      37               0 :     const uint8_t* bytes() const {
      38               0 :         return reinterpret_cast<const uint8_t*>(fPtr);
      39                 :     }
      40                 : 
      41                 :     /**
      42                 :      *  Helper to copy a range of the data into a caller-provided buffer.
      43                 :      *  Returns the actual number of bytes copied, after clamping offset and
      44                 :      *  length to the size of the data. If buffer is NULL, it is ignored, and
      45                 :      *  only the computed number of bytes is returned.
      46                 :      */
      47                 :     size_t copyRange(size_t offset, size_t length, void* buffer) const;
      48                 : 
      49                 :     /**
      50                 :      *  Function that, if provided, will be called when the SkData goes out
      51                 :      *  of scope, allowing for custom allocation/freeing of the data.
      52                 :      */
      53                 :     typedef void (*ReleaseProc)(const void* ptr, size_t length, void* context);
      54                 :     
      55                 :     /**
      56                 :      *  Create a new dataref by copying the specified data
      57                 :      */
      58                 :     static SkData* NewWithCopy(const void* data, size_t length);
      59                 : 
      60                 :     /**
      61                 :      *  Create a new dataref, taking the data ptr as is, and using the
      62                 :      *  releaseproc to free it. The proc may be NULL.
      63                 :      */
      64                 :     static SkData* NewWithProc(const void* data, size_t length,
      65                 :                                ReleaseProc proc, void* context);
      66                 : 
      67                 :     /**
      68                 :      *  Create a new dataref, reference the data ptr as is, and calling
      69                 :      *  sk_free to delete it.
      70                 :      */
      71                 :     static SkData* NewFromMalloc(const void* data, size_t length);
      72                 : 
      73                 :     /**
      74                 :      *  Create a new dataref using a subset of the data in the specified
      75                 :      *  src dataref.
      76                 :      */
      77                 :     static SkData* NewSubset(const SkData* src, size_t offset, size_t length);
      78                 : 
      79                 :     /**
      80                 :      *  Returns a new empty dataref (or a reference to a shared empty dataref).
      81                 :      *  New or shared, the caller must see that unref() is eventually called.
      82                 :      */
      83                 :     static SkData* NewEmpty();
      84                 : 
      85                 : private:
      86                 :     ReleaseProc fReleaseProc;
      87                 :     void*       fReleaseProcContext;
      88                 : 
      89                 :     const void* fPtr;
      90                 :     size_t      fSize;
      91                 : 
      92                 :     SkData(const void* ptr, size_t size, ReleaseProc, void* context);
      93                 :     ~SkData();
      94                 : };
      95                 : 
      96                 : /**
      97                 :  *  Specialized version of SkAutoTUnref<SkData> for automatically unref-ing a
      98                 :  *  SkData. If the SkData is null, data(), bytes() and size() will return 0.
      99                 :  */
     100                 : class SkAutoDataUnref : SkNoncopyable {
     101                 : public:
     102                 :     SkAutoDataUnref(SkData* data) : fRef(data) {
     103                 :         if (data) {
     104                 :             fData = data->data();
     105                 :             fSize = data->size();
     106                 :         } else {
     107                 :             fData = NULL;
     108                 :             fSize = 0;
     109                 :         }
     110                 :     }
     111                 :     ~SkAutoDataUnref() {
     112                 :         SkSafeUnref(fRef);
     113                 :     }
     114                 : 
     115                 :     const void* data() const { return fData; }
     116                 :     const uint8_t* bytes() const {
     117                 :         return reinterpret_cast<const uint8_t*> (fData);
     118                 :     }
     119                 :     size_t size() const { return fSize; }
     120                 :     SkData* get() const { return fRef; }
     121                 : 
     122                 :     void release() {
     123                 :         if (fRef) {
     124                 :             fRef->unref();
     125                 :             fRef = NULL;
     126                 :             fData = NULL;
     127                 :             fSize = 0;
     128                 :         }
     129                 :     }
     130                 : 
     131                 : private:
     132                 :     SkData*     fRef;
     133                 :     const void* fData;
     134                 :     size_t      fSize;
     135                 : };
     136                 : 
     137                 : #endif

Generated by: LCOV version 1.7