Add vtkArrayDownCast system.

vtkArrayDownCast will downcast a vtkAbstractArray to a more
derived class using FastDownCast, if available. If FastDownCast
is not supported by the the array, the slower SafeDownCast is
used instead.

The vtkArrayDownCast_FastCastMacro and
vtkArrayDownCast_TemplateFastCastMacro are used to tell
vtkArrayDownCast when FastDownCast is available for a given array
(or set of templated arrays).

Common/Core/vtkAbstractArray.h

@@ -524,7 +524,8 @@ public:
     };
 
   // Description:
-  // Method for type-checking in FastDownCast implementations.
+  // Method for type-checking in FastDownCast implementations. See also
+  // vtkArrayDownCast.
   virtual int GetArrayType()
   {
     return AbstractArray;
@@ -576,4 +577,64 @@ private:
   void operator=(const vtkAbstractArray&);  // Not implemented.
 };
 
+// Description:
+// Implementation of vtkArrayDownCast. The templating/etc is moved to this
+// worker struct to get around limitations of template functions (no partial
+// specialization, ambiguities, etc).
+template <typename ArrayT>
+struct vtkArrayDownCast_impl
+{
+  inline ArrayT* operator()(vtkAbstractArray* array)
+  {
+    return ArrayT::SafeDownCast(array);
+  }
+};
+
+// Description:
+// vtkArrayDownCast is to be used by generic (e.g. templated) code for quickly
+// downcasting vtkAbstractArray pointers to more derived classes.
+// The typical VTK downcast pattern (SafeDownCast) performs a string comparison
+// on the class names in the object's inheritance hierarchy, which is quite
+// expensive and can dominate computational resource usage when downcasting is
+// needed in a worker function.
+// To address this, certain arrays support a FastDownCast method, which replaces
+// the chain of string comparisons with 1-2 integer comparisons and thus is
+// significantly more efficient.
+// However, not all arrays support the FastDownCast mechanism. vtkArrayDownCast
+// exists to select between the two; Arrays that support FastDownCast will use
+// it, while others will fallback to the slower SafeDownCast.
+template <typename ArrayT>
+ArrayT* vtkArrayDownCast(vtkAbstractArray *array)
+{
+  // The default vtkArrayDownCast_impl struct uses SafeDownCast, but is
+  // specialized for arrays that support FastDownCast.
+  return vtkArrayDownCast_impl<ArrayT>()(array);
+}
+
+// Description:
+// This macro is used to tell vtkArrayDownCast to use FastDownCast instead of
+// SafeDownCast.
+#define vtkArrayDownCast_FastCastMacro(ArrayT) \
+  template <> struct vtkArrayDownCast_impl<ArrayT> \
+  { \
+    inline ArrayT* operator()(vtkAbstractArray *array) \
+    { \
+      return ArrayT::FastDownCast(array); \
+    } \
+  };
+
+// Description:
+// Same as vtkArrayDownCast_FastCastMacro, but treats ArrayT as a
+// single-parameter template (the parameter is the value type). Defines a
+// vtkArrayDownCast implementation that uses the specified array template class
+// with any value type.
+#define vtkArrayDownCast_TemplateFastCastMacro(ArrayT) \
+  template <typename ValueT> struct vtkArrayDownCast_impl<ArrayT<ValueT> > \
+  { \
+    inline ArrayT<ValueT>* operator()(vtkAbstractArray *array) \
+    { \
+      return ArrayT<ValueT>::FastDownCast(array); \
+    } \
+  };
+
 #endif

Common/Core/vtkAoSDataArrayTemplate.h

@@ -146,12 +146,14 @@ public:
   // This method checks if source->GetArrayType() returns DataArray
   // or a more derived type, and performs a static_cast to return
   // source as a vtkDataArray pointer. Otherwise, NULL is returned.
-  vtkAoSDataArrayTemplate<ValueType>* FastDownCast(vtkAbstractArray *source)
+  static vtkAoSDataArrayTemplate<ValueType>*
+  FastDownCast(vtkAbstractArray *source)
   {
     switch (source->GetArrayType())
       {
       case vtkAbstractArray::AoSDataArrayTemplate:
-        if (source->GetDataType() == vtkTypeTraits<ValueType>::VTK_TYPE_ID)
+        if (vtkDataTypesCompare(source->GetDataType(),
+                                vtkTypeTraits<ValueType>::VTK_TYPE_ID))
           {
           return static_cast<vtkAoSDataArrayTemplate<ValueType>*>(source);
           }
@@ -191,6 +193,9 @@ private:
 //ETX
 };
 
+// Declare vtkArrayDownCast implementations for AoS containers:
+vtkArrayDownCast_TemplateFastCastMacro(vtkAoSDataArrayTemplate)
+
 # define VTK_AOS_DATA_ARRAY_TEMPLATE_INSTANTIATE(T) \
    template class VTKCOMMONCORE_EXPORT vtkAoSDataArrayTemplate< T >
 

Common/Core/vtkCharArray.h

@@ -46,6 +46,13 @@ public:
   vtkCreateWrappedArrayInterface(char);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkCharArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkCharArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static char GetDataTypeValueMin() { return VTK_CHAR_MIN; }
@@ -66,4 +73,7 @@ private:
   void operator=(const vtkCharArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkCharArray)
+
 #endif

Common/Core/vtkDataArray.h

@@ -469,4 +469,6 @@ inline vtkDataArray* vtkDataArray::FastDownCast(vtkAbstractArray *source)
     }
 }
 
+vtkArrayDownCast_FastCastMacro(vtkDataArray)
+
 #endif

Common/Core/vtkDoubleArray.h

@@ -46,6 +46,13 @@ public:
   vtkCreateWrappedArrayInterface(double);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkDoubleArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkDoubleArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static double GetDataTypeValueMin() { return VTK_DOUBLE_MIN; }
@@ -66,4 +73,8 @@ private:
   void operator=(const vtkDoubleArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkDoubleArray)
+
+
 #endif

Common/Core/vtkFloatArray.h

@@ -47,6 +47,13 @@ public:
   vtkCreateWrappedArrayInterface(float);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkFloatArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkFloatArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static float GetDataTypeValueMin() { return VTK_FLOAT_MIN; }
@@ -68,4 +75,7 @@ private:
   void operator=(const vtkFloatArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkFloatArray)
+
 #endif

Common/Core/vtkIdTypeArray.h

@@ -59,6 +59,13 @@ public:
     }
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkIdTypeArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkIdTypeArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static vtkIdType GetDataTypeValueMin() { return VTK_ID_MIN; }
@@ -79,4 +86,7 @@ private:
   void operator=(const vtkIdTypeArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkIdTypeArray)
+
 #endif

Common/Core/vtkIntArray.h

@@ -50,6 +50,13 @@ public:
   vtkCreateWrappedArrayInterface(int);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkIntArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkIntArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static int GetDataTypeValueMin() { return VTK_INT_MIN; }
@@ -70,4 +77,7 @@ private:
   void operator=(const vtkIntArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkIntArray)
+
 #endif

Common/Core/vtkLongArray.h

@@ -51,6 +51,13 @@ public:
   vtkCreateWrappedArrayInterface(long);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkLongArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkLongArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static long GetDataTypeValueMin() { return VTK_LONG_MIN; }
@@ -71,4 +78,7 @@ private:
   void operator=(const vtkLongArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkLongArray)
+
 #endif

Common/Core/vtkLongLongArray.h

@@ -49,6 +49,14 @@ public:
 #if defined(__WRAP__) || defined (__WRAP_GCCXML__)
   vtkCreateWrappedArrayInterface(long long);
 #endif
+
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkLongLongArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkLongLongArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static long long GetDataTypeValueMin() { return VTK_LONG_LONG_MIN; }
@@ -69,4 +77,7 @@ private:
   void operator=(const vtkLongLongArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkLongLongArray)
+
 #endif

Common/Core/vtkMappedDataArray.h

@@ -128,6 +128,9 @@ private:
   size_t TemporaryScalarPointerSize;
 };
 
+// Declare vtkArrayDownCast implementations for mapped containers:
+vtkArrayDownCast_TemplateFastCastMacro(vtkMappedDataArray)
+
 #include "vtkMappedDataArray.txx"
 
 // Adds an implementation of NewInstanceInternal() that returns a standard

Common/Core/vtkMappedDataArray.txx

@@ -135,7 +135,8 @@ vtkMappedDataArray<Scalar>::FastDownCast(vtkAbstractArray *source)
   switch (source->GetArrayType())
     {
     case vtkAbstractArray::MappedDataArray:
-      if (source->GetDataType() == vtkTypeTraits<Scalar>::VTK_TYPE_ID)
+      if (vtkDataTypesCompare(source->GetDataType(),
+                              vtkTypeTraits<Scalar>::VTK_TYPE_ID))
         {
         return static_cast<vtkMappedDataArray<Scalar>*>(source);
         }

Common/Core/vtkShortArray.h

@@ -50,6 +50,13 @@ public:
   vtkCreateWrappedArrayInterface(short);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkShortArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkShortArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static short GetDataTypeValueMin() { return VTK_SHORT_MIN; }
@@ -70,4 +77,7 @@ private:
   void operator=(const vtkShortArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkShortArray)
+
 #endif

Common/Core/vtkSignedCharArray.h

@@ -46,6 +46,13 @@ public:
   vtkCreateWrappedArrayInterface(signed char);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkSignedCharArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkSignedCharArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static signed char GetDataTypeValueMin() { return VTK_SIGNED_CHAR_MIN; }
@@ -66,4 +73,7 @@ private:
   void operator=(const vtkSignedCharArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkSignedCharArray)
+
 #endif

Common/Core/vtkSoADataArrayTemplate.h

@@ -137,12 +137,14 @@ public:
   // This method checks if source->GetArrayType() returns DataArray
   // or a more derived type, and performs a static_cast to return
   // source as a vtkDataArray pointer. Otherwise, NULL is returned.
-  vtkSoADataArrayTemplate<ValueType>* FastDownCast(vtkAbstractArray *source)
+  static vtkSoADataArrayTemplate<ValueType>*
+  FastDownCast(vtkAbstractArray *source)
   {
     switch (source->GetArrayType())
       {
       case vtkAbstractArray::SoADataArrayTemplate:
-        if (source->GetDataType() == vtkTypeTraits<ValueType>::VTK_TYPE_ID)
+        if (vtkDataTypesCompare(source->GetDataType(),
+                                vtkTypeTraits<ValueType>::VTK_TYPE_ID))
           {
           return static_cast<vtkSoADataArrayTemplate<ValueType>*>(source);
           }
@@ -188,6 +190,9 @@ private:
                                    ValueTypeT>;
 };
 
+// Declare vtkArrayDownCast implementations for SoA containers:
+vtkArrayDownCast_TemplateFastCastMacro(vtkSoADataArrayTemplate)
+
 #include "vtkSoADataArrayTemplate.txx"
 #endif
 // VTK-HeaderTest-Exclude: vtkSoADataArrayTemplate.h

Common/Core/vtkTypedArray.h.in

@@ -36,6 +36,13 @@ public:
   vtkTypeMacro(vtkType@VTK_TYPE_NAME@Array,vtkTypeArrayBase);
   void PrintSelf(ostream& os, vtkIndent indent);
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkType@VTK_TYPE_NAME@Array* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkType@VTK_TYPE_NAME@Array*>(Superclass::FastDownCast(source));
+  }
+
 protected:
   vtkType@VTK_TYPE_NAME@Array();
   ~vtkType@VTK_TYPE_NAME@Array();
@@ -45,6 +52,9 @@ private:
   void operator=(const vtkType@VTK_TYPE_NAME@Array&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkType@VTK_TYPE_NAME@Array)
+
 #undef vtkTypeArrayBase
 
 #endif

Common/Core/vtkTypedDataArray.h

@@ -168,6 +168,9 @@ private:
   friend class vtkGenericDataArray<vtkTypedDataArray<Scalar>, Scalar>;
 };
 
+// Declare vtkArrayDownCast implementations for typed containers:
+vtkArrayDownCast_TemplateFastCastMacro(vtkTypedDataArray)
+
 // Included here to resolve chicken/egg issue with container/iterator:
 #include "vtkTypedDataArrayIterator.h" // For iterator
 

Common/Core/vtkTypedDataArray.txx

@@ -99,7 +99,8 @@ vtkTypedDataArray<Scalar>::FastDownCast(vtkAbstractArray *source)
     {
     case vtkAbstractArray::TypedDataArray:
     case vtkAbstractArray::MappedDataArray:
-      if (source->GetDataType() == vtkTypeTraits<Scalar>::VTK_TYPE_ID)
+      if (vtkDataTypesCompare(source->GetDataType(),
+                              vtkTypeTraits<Scalar>::VTK_TYPE_ID))
         {
         return static_cast<vtkTypedDataArray<Scalar>*>(source);
         }

Common/Core/vtkUnsignedCharArray.h

@@ -46,6 +46,13 @@ public:
   vtkCreateWrappedArrayInterface(unsigned char);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkUnsignedCharArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkUnsignedCharArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static unsigned char GetDataTypeValueMin() { return VTK_UNSIGNED_CHAR_MIN; }
@@ -66,4 +73,7 @@ private:
   void operator=(const vtkUnsignedCharArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkUnsignedCharArray)
+
 #endif

Common/Core/vtkUnsignedIntArray.h

@@ -50,6 +50,13 @@ public:
   vtkCreateWrappedArrayInterface(unsigned int);
 #endif
 
+  // Description:
+  // A faster alternative to SafeDownCast for downcasting vtkAbstractArrays.
+  static vtkUnsignedIntArray* FastDownCast(vtkAbstractArray *source)
+  {
+    return static_cast<vtkUnsignedIntArray*>(Superclass::FastDownCast(source));
+  }
+
   // Description:
   // Get the minimum data value in its native type.
   static unsigned int GetDataTypeValueMin() { return VTK_UNSIGNED_INT_MIN; }
@@ -70,4 +77,7 @@ private:
   void operator=(const vtkUnsignedIntArray&);  // Not implemented.
 };
 
+// Define vtkArrayDownCast implementation:
+vtkArrayDownCast_FastCastMacro(vtkUnsignedIntArray)
+
 #endif