SkRecord: infer return type for visit() and mutate().

src/core/SkRecord.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
@@ skipping 28 matching lines @@
                  fInlineAlloc, sizeof(fInlineAlloc)) {}
     ~SkRecord();
 
     // Returns the number of canvas commands in this SkRecord.
     int count() const { return fCount; }
 
     // Visit the i-th canvas command with a functor matching this interface:
     //   template <typename T>
     //   R operator()(const T& record) { ... }
     // This operator() must be defined for at least all SkRecords::*.
-    template <typename R, typename F>
-    R visit(int i, F& f) const {
-        SkASSERT(i < this->count());
-        return fRecords[i].visit<R>(f);
+    template <typename F>
+    auto visit(int i, F&& f) const -> decltype(f(SkRecords::NoOp())) {
+        return fRecords[i].visit(f);
     }
 
     // Mutate the i-th canvas command with a functor matching this interface:
     //   template <typename T>
     //   R operator()(T* record) { ... }
     // This operator() must be defined for at least all SkRecords::*.
-    template <typename R, typename F>
-    R mutate(int i, F& f) {
-        SkASSERT(i < this->count());
-        return fRecords[i].mutate<R>(f);
+    template <typename F>
+    auto mutate(int i, F&& f) -> decltype(f((SkRecords::NoOp*)nullptr)) {
+        return fRecords[i].mutate(f);
     }
 
-    // TODO: It'd be nice to infer R from F for visit and mutate.
-
     // Allocate contiguous space for count Ts, to be freed when the SkRecord is destroyed.
     // Here T can be any class, not just those from SkRecords.  Throws on failure.
     template <typename T>
     T* alloc(size_t count = 1) {
         return (T*)fAlloc.alloc(sizeof(T) * count);
     }
 
     // Add a new command of type T to the end of this SkRecord.
     // You are expected to placement new an object of type T onto this pointer.
     template <typename T>
     T* append() {
         if (fCount == fReserved) {
             this->grow();
         }
         return fRecords[fCount++].set(this->allocCommand<T>());
     }
 
     // Replace the i-th command with a new command of type T.
     // You are expected to placement new an object of type T onto this pointer.
     // References to the original command are invalidated.
     template <typename T>
     T* replace(int i) {
         SkASSERT(i < this->count());
 
         Destroyer destroyer;
-        this->mutate<void>(i, destroyer);
+        this->mutate(i, destroyer);
 
         return fRecords[i].set(this->allocCommand<T>());
     }
 
     // Replace the i-th command with a new command of type T.
     // You are expected to placement new an object of type T onto this pointer.
     // You must show proof that you've already adopted the existing command.
     template <typename T, typename Existing>
     T* replace(int i, const SkRecords::Adopted<Existing>& proofOfAdoption) {
         SkASSERT(i < this->count());
@@ skipping 58 matching lines @@
         T* set(T* ptr) {
             fTypeAndPtr = ((uint64_t)T::kType) << kTypeShift | (uintptr_t)ptr;
             SkASSERT(this->ptr() == ptr && this->type() == T::kType);
             return ptr;
         }
 
         SkRecords::Type type() const { return (SkRecords::Type)(fTypeAndPtr >> kTypeShift); }
         void* ptr() const { return (void*)(fTypeAndPtr & ((1ull<<kTypeShift)-1)); }
 
         // Visit this record with functor F (see public API above).
-        template <typename R, typename F>
-        R visit(F& f) const {
+        template <typename F>
+        auto visit(F&& f) const -> decltype(f(SkRecords::NoOp())) {
         #define CASE(T) case SkRecords::T##_Type: return f(*(const SkRecords::T*)this->ptr());
             switch(this->type()) { SK_RECORD_TYPES(CASE) }
         #undef CASE
             SkDEBUGFAIL("Unreachable");
-            return R();
+            return f(SkRecords::NoOp());
         }
 
         // Mutate this record with functor F (see public API above).
-        template <typename R, typename F>
-        R mutate(F& f) {
+        template <typename F>
+        auto mutate(F&& f) -> decltype(f((SkRecords::NoOp*)nullptr)) {
         #define CASE(T) case SkRecords::T##_Type: return f((SkRecords::T*)this->ptr());
             switch(this->type()) { SK_RECORD_TYPES(CASE) }
         #undef CASE
             SkDEBUGFAIL("Unreachable");
-            return R();
+            return f((SkRecords::NoOp*)nullptr);
         }
     };
 
     // fRecords needs to be a data structure that can append fixed length data, and need to
     // support efficient random access and forward iteration.  (It doesn't need to be contiguous.)
     int fCount, fReserved;
     SkAutoSTMalloc<kInlineRecords, Record> fRecords;
 
     // fAlloc needs to be a data structure which can append variable length data in contiguous
     // chunks, returning a stable handle to that data for later retrieval.
     SkVarAlloc fAlloc;
     char fInlineAlloc[1 << kInlineAllocLgBytes];
 };
 
 #endif//SkRecord_DEFINED