The Tor Browser: gfx/skia/trunk/include/core/SkDataTable.h@6474c204b198 (annotated)

gfx/skia/trunk/include/core/SkDataTable.h@6474c204b198 (annotated)

gfx/skia/trunk/include/core/SkDataTable.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkDataTable_DEFINED
 #define SkDataTable_DEFINED
 #include "SkChunkAlloc.h"
 #include "SkData.h"
 #include "SkString.h"
 #include "SkTDArray.h"
 /**
  *  Like SkData, SkDataTable holds an immutable data buffer. The data buffer is
  *  organized into a table of entries, each with a length, so the entries are
  *  not required to all be the same size.
  */
 class SK_API SkDataTable : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkDataTable)
     /**
      *  Returns true if the table is empty (i.e. has no entries).
      */
     bool isEmpty() const { return 0 == fCount; }
     /**
      *  Return the number of entries in the table. 0 for an empty table
      */
     int count() const { return fCount; }
     /**
      *  Return the size of the index'th entry in the table. The caller must
      *  ensure that index is valid for this table.
      */
     size_t atSize(int index) const;
     /**
      *  Return a pointer to the data of the index'th entry in the table.
      *  The caller must ensure that index is valid for this table.
      *
      *  @param size If non-null, this returns the byte size of this entry. This
      *              will be the same value that atSize(index) would return.
      */
     const void* at(int index, size_t* size = NULL) const;
     template <typename T>
     const T* atT(int index, size_t* size = NULL) const {
         return reinterpret_cast<const T*>(this->at(index, size));
     }
     /**
      *  Returns the index'th entry as a c-string, and assumes that the trailing
      *  null byte had been copied into the table as well.
      */
     const char* atStr(int index) const {
         size_t size;
         const char* str = this->atT<const char>(index, &size);
         SkASSERT(strlen(str) + 1 == size);
         return str;
     }
     typedef void (*FreeProc)(void* context);
     static SkDataTable* NewEmpty();
     /**
      *  Return a new DataTable that contains a copy of the data stored in each
      *  "array".
      *
      *  @param ptrs array of points to each element to be copied into the table.
      *  @param sizes array of byte-lengths for each entry in the corresponding
      *               ptrs[] array.
      *  @param count the number of array elements in ptrs[] and sizes[] to copy.
      */
     static SkDataTable* NewCopyArrays(const void * const * ptrs,
                                       const size_t sizes[], int count);
     /**
      *  Return a new table that contains a copy of the data in array.
      *
      *  @param array contiguous array of data for all elements to be copied.
      *  @param elemSize byte-length for a given element.
      *  @param count the number of entries to be copied out of array. The number
      *               of bytes that will be copied is count * elemSize.
      */
     static SkDataTable* NewCopyArray(const void* array, size_t elemSize,
                                      int count);
     static SkDataTable* NewArrayProc(const void* array, size_t elemSize,
                                      int count, FreeProc proc, void* context);
 private:
     struct Dir {
         const void* fPtr;
         uintptr_t   fSize;
     };
     int         fCount;
     size_t      fElemSize;
     union {
         const Dir*  fDir;
         const char* fElems;
     } fU;
     FreeProc    fFreeProc;
     void*       fFreeProcContext;
     SkDataTable();
     SkDataTable(const void* array, size_t elemSize, int count,
                 FreeProc, void* context);
     SkDataTable(const Dir*, int count, FreeProc, void* context);
     virtual ~SkDataTable();
     friend class SkDataTableBuilder;    // access to Dir
     typedef SkRefCnt INHERITED;
 };
 /**
  *  Helper class that allows for incrementally building up the data needed to
  *  create a SkDataTable.
  */
 class SK_API SkDataTableBuilder : SkNoncopyable {
 public:
     SkDataTableBuilder(size_t minChunkSize);
     ~SkDataTableBuilder();
     int  count() const { return fDir.count(); }
     size_t minChunkSize() const { return fMinChunkSize; }
     /**
      *  Forget any previously appended entries, setting count() back to 0.
      */
     void reset(size_t minChunkSize);
     void reset() {
         this->reset(fMinChunkSize);
     }
     /**
      *  Copy size-bytes from data, and append it to the growing SkDataTable.
      */
     void append(const void* data, size_t size);
     /**
      *  Helper version of append() passes strlen() + 1 for the size,
      *  so the trailing-zero will be copied as well.
      */
     void appendStr(const char str[]) {
         this->append(str, strlen(str) + 1);
     }
     /**
      *  Helper version of append() passes string.size() + 1 for the size,
      *  so the trailing-zero will be copied as well.
      */
     void appendString(const SkString& string) {
         this->append(string.c_str(), string.size() + 1);
     }
     /**
      *  Return an SkDataTable from the accumulated entries that were added by
      *  calls to append(). This call also clears any accumluated entries from
      *  this builder, so its count() will be 0 after this call.
      */
     SkDataTable* detachDataTable();
 private:
     SkTDArray<SkDataTable::Dir> fDir;
     SkChunkAlloc*               fHeap;
     size_t                      fMinChunkSize;
 };
 #endif

The Tor Browser / annotate

gfx/skia/trunk/include/core/SkDataTable.h@6474c204b198 (annotated)

gfx/skia/trunk/include/core/SkDataTable.h