Initial error handling code

include/core/SkFlattenable.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 SkFlattenable_DEFINED
 #define SkFlattenable_DEFINED
 
 #include "SkRefCnt.h"
 
 class SkFlattenableReadBuffer;
 class SkFlattenableWriteBuffer;
 
 #define SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(flattenable) \
-        SkFlattenable::Registrar(#flattenable, flattenable::CreateProc);
+        SkFlattenable::Registrar(#flattenable, flattenable::CreateProc, flattenable::IsA);
 
 #define SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP() static void InitializeFlattenables();
 
 #define SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(flattenable) \
     void flattenable::InitializeFlattenables() {
 
 #define SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END \
     }
 
 #define SK_DECLARE_UNFLATTENABLE_OBJECT() \
     virtual Factory getFactory() SK_OVERRIDE { return NULL; }
 
-#define SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(flattenable) \
+/** For SkFlattenable derived objects with a valid type
+    This macros would typically be used by virtual classes, which need a type, but can't
+    be constructed or serialized directly without going through a derived class
+  */
+#define SK_DEFINE_FLATTENABLE_TYPE_CHECKING_PROCS(flattenable) \
+    static const char* GetTypeName() { \
+        return #flattenable; \
+    } \
+    static bool IsA(const char* name) { \
+        return (strcmp(flattenable::GetTypeName(), name) == 0) || INHERITED::IsA(name); \
+    } \
+    virtual const char* getTypeName() SK_OVERRIDE { \
+        return flattenable::GetTypeName(); \
+    }
+
+/** For SkFlattenable derived classes defined within the skia library
+  */
+#define SK_DEFINE_FLATTENABLE_DESERIALIZATION_PROCS(flattenable) \
     virtual Factory getFactory() SK_OVERRIDE { return CreateProc; } \
     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { \
         return SkNEW_ARGS(flattenable, (buffer)); \
-    }
+    } \
+    SK_DEFINE_FLATTENABLE_TYPE_CHECKING_PROCS(flattenable)
+
+/** Deprecated, remove once noone is using it anymore
+  */
+#define SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(flattenable) \
+    SK_DEFINE_FLATTENABLE_DESERIALIZATION_PROCS(flattenable)
 
 /** \class SkFlattenable
 
  SkFlattenable is the base class for objects that need to be flattened
  into a data stream for either transport or as part of the key to the
  font cache.
  */
 class SK_API SkFlattenable : public SkRefCnt {
 public:
+
     SK_DECLARE_INST_COUNT(SkFlattenable)
 
     typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);
+    typedef bool (*TypeCheck)(const char*);
 
     SkFlattenable() {}
 
     /** Implement this to return a factory function pointer that can be called
      to recreate your class given a buffer (previously written to by your
      override of flatten().
      */
     virtual Factory getFactory() = 0;
 
     static Factory NameToFactory(const char name[]);
     static const char* FactoryToName(Factory);
-    static void Register(const char name[], Factory);
+
+    static void Register(const char name[], Factory, TypeCheck);
+
+    /** Returns the class id
+        GetTypeName() methods on classes descending from SkFlattenable will return
+        the name associated with that class, which is a stringified version of
+        the class' name. Typically, SK_DEFINE_FLATTENABLE_TYPE_CHECKING_PROCS()
+        will define GetTypeName(), getFlattenableType() and IsA() in the derived class.
+        * Note that SK_DEFINE_FLATTENABLE_TYPE_CHECKING_PROCS() is included in
+          SK_DEFINE_FLATTENABLE_DESERIALIZATION_PROCS(), so most classes will have
+          these declared by default.
+      */
+    static const char* GetTypeName() { return "SkFlattenable"; }
+
+    /** Returns the name of the object's class
+      */
+    virtual const char* getTypeName() = 0;
+
+    /** Returns whether this class is itself or inherits from a class with this type name.
+      * (SkFlattenable is the root of this type checking system.)
+      */
+    static bool IsA(const char* name) {
+        return strcmp(GetTypeName(), name) == 0;
+    }
+
+    /** Checks if typeA is a typeB
+      * For example, if typeA is "SkImageFilter" and typeB is "SkFlattenable", this would return true
+      * Inversely, if typeA is "SkFlattenable" and typeB is "SkImageFilter", this would return false
+      */
+    static bool TypeIsA(const char* nameA, const char* nameB) {
+        TypeCheck typeCheck = NameToTypeCheck(nameA);
+        return typeCheck ? (*typeCheck)(nameB) : false;
+    }
 
     class Registrar {
     public:
-        Registrar(const char name[], Factory factory) {
-            SkFlattenable::Register(name, factory);
+        Registrar(const char name[], Factory factory, TypeCheck typeCheck) {
+            SkFlattenable::Register(name, factory, typeCheck);
         }
     };
 
 protected:
     SkFlattenable(SkFlattenableReadBuffer&) {}
     /** Override this to write data specific to your subclass into the buffer,
      being sure to call your super-class' version first. This data will later
      be passed to your Factory function, returned by getFactory().
      */
     virtual void flatten(SkFlattenableWriteBuffer&) const;
 
 private:
-    static void InitializeFlattenables();
+    static void InitializeFlattenablesIfNeeded();
+    static TypeCheck NameToTypeCheck(const char name[]);
 
     friend class SkGraphics;
     friend class SkFlattenableWriteBuffer;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif