XPS ttc handling.

include/core/SkTemplates.h

 
 /*
  * Copyright 2006 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 SkTemplates_DEFINED
@@ skipping 28 matching lines @@
 ///@{
 /** SkTConstType<T, CONST>::type will be 'const T' if CONST is true, 'T' otherwise. */
 template <typename T, bool CONST> struct SkTConstType {
     typedef T type;
 };
 template <typename T> struct SkTConstType<T, true> {
     typedef const T type;
 };
 ///@}
 
+/**
+ *  Returns a pointer to a D which comes immediately after S[count].
+ */
+template <typename D, typename S> static D* SkTAfter(S* ptr, size_t count = 1) {
+    return reinterpret_cast<D*>(ptr + count);
+}
+
+/**
+ *  Returns a pointer to a D which comes byteOffset bytes after S.
+ */
+template <typename D, typename S> static D* SkTAddOffset(S* ptr, size_t byteOffset) {
+    // The intermediate char* has the same const-ness as D as this produces better error messages.
+    // This relies on the fact that reinterpret_cast can add constness, but cannot remove it.
+    return reinterpret_cast<D*>(
+        reinterpret_cast<SkTConstType<char, SkTIsConst<D>::value>::type*>(ptr) + byteOffset);
+}
+
 /** \class SkAutoTCallVProc
 
     Call a function when this goes out of scope. The template uses two
     parameters, the object, and a function that is to be called in the destructor.
     If detach() is called, the object reference is set to null. If the object
     reference is null when the destructor is called, we do not call the
     function.
 */
 template <typename T, void (*P)(T*)> class SkAutoTCallVProc : SkNoncopyable {
 public:
@@ skipping 14 matching lines @@
 */
 template <typename T, int (*P)(T*)> class SkAutoTCallIProc : SkNoncopyable {
 public:
     SkAutoTCallIProc(T* obj): fObj(obj) {}
     ~SkAutoTCallIProc() { if (fObj) P(fObj); }
     T* detach() { T* obj = fObj; fObj = NULL; return obj; }
 private:
     T* fObj;
 };
 
+template <typename T> class SkAutoTFree : SkNoncopyable {
+public:
+    explicit SkAutoTFree(T* ptr = NULL) : fPtr(ptr) { }
+    ~SkAutoTFree() { sk_free(fPtr); }
+
+    /** Return the current buffer, or null. */
+    T* get() const { return fPtr; }
+
+    /** Assign a new ptr allocated with sk_malloc (or null), and return the
+        previous ptr. Note it is the caller's responsibility to sk_free the
+        returned ptr.
+    */
+    T* set(T* ptr) {

[reed1, 2013/05/06 18:09:58]

Do we have this pattern (where we return the old as we accept a new) in other
helpers? It is certainly different from reset(), which always disposes of the
old while accepting the new...

[bungeman-skia, 2013/05/06 20:48:45]

Hmmm... not really. This is mostly copy-pasta from Types.h but with templates.
It appears that this 'set' method is called by SkBitSet and SkPDFShader.
SkBitSet should probably use a SkTDArray, SkPDFShader should be using
SkAutoMalloc. Those two are using 'set' as something of a delayed constructor
(an init).

I actually do want an auto free because it's some other code making calls to
malloc, so I already have some malloc'ed memory. Adding to the complication is
that I also need to realloc, as the returned memory region is generally much too
big. A 'reset' doesn't play well with realloc. I'd like to avoid doing a
'detach' then a 'reset' in order to use realloc.

Perhaps the correct thing to do here is to simply not return the old value. Then
it is the callers responsibility to ensure that the old value magically should
not be freed. Since that is the job of detatch, perhaps realloc is the only
valid use of this sort of thing and it should be named/work as such. This
certainly makes my use case easier.

+        T* prev = fPtr;
+        fPtr = ptr;
+        return prev;
+    }
+
+    /** Transfer ownership of the current ptr to the caller, setting the
+        internal reference to null. Note the caller is reponsible for calling
+        sk_free on the returned address.
+    */
+    T* detach() { return this->set(NULL); }
+
+    /** Free the current buffer, and set the internal reference to NULL. Same
+        as calling sk_free(detach())
+    */
+    void free() {
+        sk_free(fPtr);
+        fPtr = NULL;
+    }
+
+private:
+    T* fPtr;
+};
+
 template <typename T> class SkAutoTDelete : SkNoncopyable {
 public:
     SkAutoTDelete(T* obj = NULL) : fObj(obj) {}
     ~SkAutoTDelete() { delete fObj; }
 
     T* get() const { return fObj; }
     T& operator*() const { SkASSERT(fObj); return *fObj; }
     T* operator->() const { SkASSERT(fObj); return fObj; }
 
     void reset(T* obj) {
@@ skipping 288 matching lines @@
     /**
      * Returns void* because this object does not initialize the
      * memory. Use placement new for types that require a cons.
      */
     void* get() { return fStorage.get(); }
 private:
     SkAlignedSStorage<sizeof(T)*N> fStorage;
 };
 
 #endif