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 61 matching lines @@
         if (fInternal.isEmpty() && this->externalCount() + count <= fExternalLimit) {
             p = fExternal + fCount;
         } else {
             p = fInternal.append(count);
         }
 
         fCount += count;
         return p;
     }
 
-    // Read or write 4 bytes at offset, which must be a multiple of 4 <= size().
-    uint32_t read32At(size_t offset) { return this->atOffset(offset); }
-    void write32At(size_t offset, uint32_t val) { this->atOffset(offset) = val; }
+    // Read/overwrite a record at offset, which must be a multiple of 4.
+    // These calls are valid only when the record was written atomically
+    // using the write* methods below.
+    template<typename T>
+    const T& readTAt(size_t offset) const {
+        return this->atOffset<T>(offset);
+    }
+    template<typename T>
+    void overwriteTAt(const T& value, size_t offset) {

[mtklein, 2014/02/10 22:37:34]

I have a slight preference for it to go back the other way, to
overwriteTAt(offset, value), just so the "At" makes a little more sense in
there.  Any reason to swap it as you have?

[f(malita), 2014/02/11 03:30:56]

Seemed more natural to follow the name hints ("overwrite <T> <at>"), but I can
see why changing the order may be confusing. I'll switch back.

+        this->atOffset<T>(offset) = value;
+    }
 
     bool writeBool(bool value) {
         this->write32(value);
         return value;
     }
 
     void writeInt(int32_t value) {
         this->write32(value);
     }
 
@@ skipping 136 matching lines @@
             && stream->write(fInternal.begin(), fInternal.bytes());
     }
 
     // read from the stream, and write up to length bytes. Return the actual
     // number of bytes written.
     size_t readFromStream(SkStream* stream, size_t length) {
         return stream->read(this->reservePad(length), length);
     }
 
 private:
-    uint32_t& atOffset(size_t offset) {
+    template<typename T>
+    T& atOffset(size_t offset) const {
         SkASSERT(SkAlign4(offset) == offset);
-        const int count = SkToInt(offset/4);
-        SkASSERT(count < fCount);
+        const int count = SkToInt(offset / 4);
+        SkASSERT(offset + sizeof(T) <= (unsigned)fCount * 4);
 
         if (count < this->externalCount()) {
-            return fExternal[count];
+            // A record should not span fExternal->fInternal.
+            SkASSERT(offset + sizeof(T) <= (unsigned)this->externalCount() * 4);
+            return *(T*)&fExternal[count];
         }
-        return fInternal[count - this->externalCount()];
+        return *(T*)&fInternal[count - this->externalCount()];
     }
 
-
     // Number of uint32_t written into fExternal.  <= fExternalLimit.
     int externalCount() const { return fCount - fInternal.count(); }
 
     int fCount;                     // Total number of uint32_t written.
     int fExternalLimit;             // Number of uint32_t we can write to fExternal.
     uint32_t* fExternal;            // Unmanaged memory block.
     SkTDArray<uint32_t> fInternal;  // Managed memory block.
 };
 
 /**
  *  Helper class to allocated SIZE bytes as part of the writer, and to provide
  *  that storage to the constructor as its initial storage buffer.
  *
  *  This wrapper ensures proper alignment rules are met for the storage.
  */
 template <size_t SIZE> class SkSWriter32 : public SkWriter32 {
 public:
     SkSWriter32() : SkWriter32(fData.fStorage, SIZE) {}
 
 private:
     union {
         void*   fPtrAlignment;
         double  fDoubleAlignment;
         char    fStorage[SIZE];
     } fData;
 };
 
 #endif