Templetized SkWriter32 readTAt() & overwriteTAt()

include/core/SkWriter32.h

 
 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkWriter32_DEFINED
@@ skipping 55 matching lines @@
         SkASSERT(SkAlign4(size) == size);
         size_t offset = fUsed;
         size_t totalRequired = fUsed + size;
         if (totalRequired > fCapacity) {
             this->growToAtLeast(totalRequired);
         }
         fUsed = totalRequired;
         return (uint32_t*)(fData + offset);
     }
 
-    // Read or write 4 bytes at offset, which must be a multiple of 4 <= size().
-    uint32_t read32At(size_t offset) {
+    /**
+     *  Read a T record at offset, which must be a multiple of 4. Only legal if the record
+     *  was writtern atomically using the write methods below.
+     */
+    template<typename T>
+    const T& readTAt(size_t offset) const {
         SkASSERT(SkAlign4(offset) == offset);
         SkASSERT(offset < fUsed);
-        return *(uint32_t*)(fData + offset);
+        return *(T*)(fData + offset);
     }
 
-    void write32At(size_t offset, uint32_t val) {
+    /**
+     *  Overwrite a T record at offset, which must be a multiple of 4. Only legal if the record
+     *  was writtern atomically using the write methods below.
+     */
+    template<typename T>
+    void overwriteTAt(size_t offset, const T& value) {
         SkASSERT(SkAlign4(offset) == offset);
         SkASSERT(offset < fUsed);
-        *(uint32_t*)(fData + offset) = val;
+        *(T*)(fData + offset) = value;
     }
 
     bool writeBool(bool value) {
         this->write32(value);
         return value;
     }
 
     void writeInt(int32_t value) {
         this->write32(value);
     }
@@ skipping 64 matching lines @@
     void write(const void* values, size_t size) {
         SkASSERT(SkAlign4(size) == size);
         memcpy(this->reserve(size), values, size);
     }
 
     /**
      *  Reserve size bytes. Does not need to be 4 byte aligned. The remaining space (if any) will be
      *  filled in with zeroes.
      */
     uint32_t* reservePad(size_t size) {
-        uint32_t* p = this->reserve(SkAlign4(size));
-        uint8_t* tail = (uint8_t*)p + size;
-        switch (SkAlign4(size) - size) {
-            default: SkDEBUGFAIL("SkAlign4(x) - x should always be 0, 1, 2, or 3.");
-            case 3: *tail++ = 0x00;  // fallthrough is intentional
-            case 2: *tail++ = 0x00;  // fallthrough is intentional
-            case 1: *tail++ = 0x00;
-            case 0: ;/*nothing to do*/
+        size_t alignedSize = SkAlign4(size);
+        uint32_t* p = this->reserve(alignedSize);
+        if (alignedSize != size) {
+            SkASSERT(alignedSize >= 4);
+            p[alignedSize / 4 - 1] = 0;
         }
         return p;
     }
 
     /**
      *  Write size bytes from src, and pad to 4 byte alignment with zeroes.
      */
     void writePad(const void* src, size_t size) {
         memcpy(this->reservePad(size), src, size);
     }
@@ skipping 66 matching lines @@
     union {
         void*   fPtrAlignment;
         double  fDoubleAlignment;
         char    fStorage[SIZE];
     } fData;
 
     typedef SkWriter32 INHERITED;
 };
 
 #endif