Replace vtkDataArrayTemplate with vtkAoSDataArrayTemplate.

Author: David C. Lonie

Common/Core/CMakeLists.txt

@@ -222,8 +222,6 @@ SET(Module_SRCS
   vtkWeakPointerBase.cxx
   vtkWindow.cxx
   vtkXMLFileOutputWindow.cxx
-  vtkDataArrayTemplate.txx
-  vtkDataArrayTemplateHelper.cxx
   vtkDenseArray.txx
   vtkSparseArray.txx
   vtkTypedArray.txx
@@ -254,7 +252,6 @@ set(${vtk-module}_HDRS
   vtkAtomicTypes.h
   vtkAutoInit.h
   vtkDataArrayIteratorMacro.h
-  vtkDataArrayTemplateImplicit.txx
   vtkGenericDataArray.h
   vtkGenericDataArrayLookupHelper.h
   vtkGenericDataArrayMacros.h
@@ -583,7 +580,6 @@ set_source_files_properties(
   vtkAutoInit.h
   vtkDataArrayTemplateHelper.cxx
   vtkDataArrayTemplateImplicit.txx
-  vtkDataArrayTemplate.txx
   vtkDenseArray.txx
   vtkGenericDataArrayHelpers.h
   vtkIOStream.h

Common/Core/vtkAoSDataArrayTemplate.h

@@ -171,4 +171,78 @@ class vtkAoSDataArrayTemplate :
 };
 
 #include "vtkAoSDataArrayTemplate.txx"
+
+// Ported over from vtkDataArrayTemplate:
+
+#if !defined(VTK_NO_EXPLICIT_TEMPLATE_INSTANTIATION)
+# define VTK_AOS_DATA_ARRAY_TEMPLATE_INSTANTIATE(T) \
+   template class VTKCOMMONCORE_EXPORT vtkAoSDataArrayTemplate< T >
+#else
+// TODO Not sure what this does, need to dig some:
+//# include "vtkDataArrayTemplateImplicit.txx"
+//# define VTK_DATA_ARRAY_TEMPLATE_INSTANTIATE(T)
 #endif
+
+#endif // header guard
+
+// TODO clean this up, more or less copy/pasted from vtkDataArrayTemplate.h:
+
+// This portion must be OUTSIDE the include blockers.  Each
+// vtkDataArray subclass uses this to give its instantiation of this
+// template a DLL interface.
+#if defined(VTK_DATA_ARRAY_TEMPLATE_TYPE) && !defined(VTK_NO_EXPLICIT_TEMPLATE_INSTANTIATION)
+# if defined(VTK_BUILD_SHARED_LIBS) && defined(_MSC_VER)
+#  pragma warning (push)
+#  pragma warning (disable: 4091) // warning C4091: 'extern ' :
+   // ignored on left of 'int' when no variable is declared
+#  pragma warning (disable: 4231) // Compiler-specific extension warning.
+
+   // We need to disable warning 4910 and do an extern dllexport
+   // anyway.  When deriving vtkCharArray and other types from an
+   // instantiation of this template the compiler does an explicit
+   // instantiation of the base class.  From outside the vtkCommon
+   // library we block this using an extern dllimport instantiation.
+   // For classes inside vtkCommon we should be able to just do an
+   // extern instantiation, but VS 2008 complains about missing
+   // definitions.  We cannot do an extern dllimport inside vtkCommon
+   // since the symbols are local to the dll.  An extern dllexport
+   // seems to be the only way to convince VS 2008 to do the right
+   // thing, so we just disable the warning.
+#  pragma warning (disable: 4910) // extern and dllexport incompatible
+
+   // Use an "extern explicit instantiation" to give the class a DLL
+   // interface.  This is a compiler-specific extension.
+   extern VTK_AOS_DATA_ARRAY_TEMPLATE_INSTANTIATE(VTK_DATA_ARRAY_TEMPLATE_TYPE);
+#  pragma warning (pop)
+# endif
+# undef VTK_DATA_ARRAY_TEMPLATE_TYPE
+#endif
+
+// This macro is used by the subclasses to create dummy
+// declarations for these functions such that the wrapper
+// can see them. The wrappers ignore vtkDataArrayTemplate.
+#define vtkCreateWrappedArrayInterface(T) \
+  int GetDataType(); \
+  void GetTupleValue(vtkIdType i, T* tuple); \
+  void SetTupleValue(vtkIdType i, const T* tuple); \
+  void InsertTupleValue(vtkIdType i, const T* tuple); \
+  vtkIdType InsertNextTupleValue(const T* tuple); \
+  T GetValue(vtkIdType id); \
+  void SetValue(vtkIdType id, T value); \
+  void SetNumberOfValues(vtkIdType number); \
+  void InsertValue(vtkIdType id, T f); \
+  vtkIdType InsertNextValue(T f); \
+  T *GetValueRange(int comp); \
+  T *GetValueRange(); \
+  T* WritePointer(vtkIdType id, vtkIdType number); \
+  T* GetPointer(vtkIdType id)/*; \
+
+  * These methods are not wrapped to avoid wrappers exposing these
+  * easy-to-get-wrong methods because passing in the wrong value for 'save' is
+  * guaranteed to cause a memory issue down the line. Either the wrappers
+  * didn't use malloc to allocate the memory or the memory isn't actually
+  * persisted because a temporary array is used that doesn't persist like this
+  * method expects.
+
+  void SetArray(T* array, vtkIdType size, int save); \
+  void SetArray(T* array, vtkIdType size, int save, int deleteMethod) */

Common/Core/vtkCharArray.cxx

@@ -13,8 +13,8 @@
 
 =========================================================================*/
 // Instantiate superclass first to give the template a DLL interface.
-#include "vtkDataArrayTemplate.txx"
-VTK_DATA_ARRAY_TEMPLATE_INSTANTIATE(char);
+#include "vtkAoSDataArrayTemplate.h"
+VTK_AOS_DATA_ARRAY_TEMPLATE_INSTANTIATE(char);
 
 #include "vtkArrayIteratorTemplate.txx"
 VTK_ARRAY_ITERATOR_TEMPLATE_INSTANTIATE(char);

Common/Core/vtkCharArray.h

@@ -28,11 +28,11 @@
 
 #include "vtkCommonCoreModule.h" // For export macro
 #include "vtkDataArray.h"
-#include "vtkDataArrayTemplate.h" // Real Superclass
+#include "vtkAoSDataArrayTemplate.h" // Real Superclass
 
 // Fake the superclass for the wrappers.
 #ifndef __WRAP__
-#define vtkDataArray vtkDataArrayTemplate<char>
+#define vtkDataArray vtkAoSDataArrayTemplate<char>
 #endif
 class VTKCOMMONCORE_EXPORT vtkCharArray : public vtkDataArray
 {
@@ -65,7 +65,7 @@ class VTKCOMMONCORE_EXPORT vtkCharArray : public vtkDataArray
 
 private:
   //BTX
-  typedef vtkDataArrayTemplate<char> RealSuperclass;
+  typedef vtkAoSDataArrayTemplate<char> RealSuperclass;
   //ETX
   vtkCharArray(const vtkCharArray&);  // Not implemented.
   void operator=(const vtkCharArray&);  // Not implemented.