TPCFastTransform: Do not pollute the global namespace

Author: davidrohr

GPU/TPCFastTransformation/TPCFastTransform.h

@@ -115,7 +115,7 @@ class TPCFastTransform : public FlatObject
   }
 
 /// Destructor
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_GPUCODE)
   ~TPCFastTransform()
   {
     delete mCorrectionSlow;

GPU/Utils/FlatObject.h

@@ -115,63 +115,6 @@ namespace gpu
 ///  before the transport. The object will be ready-to-use right after the porting.
 ///
 
-#ifndef GPUCA_GPUCODE // code invisible on GPU
-
-template <typename T>
-T* resizeArray(T*& ptr, int32_t oldSize, int32_t newSize, T* newPtr = nullptr)
-{
-  // Resize array pointed by ptr. T must be a POD class.
-  // If the non-null newPtr is provided, use it instead of allocating a new one.
-  // In this case it is up to the user to ensure that it has at least newSize slots allocated.
-  // Return original array pointer, so that the user can manage previously allocate memory
-  if (oldSize < 0) {
-    oldSize = 0;
-  }
-  if (newSize > 0) {
-    if (!newPtr) {
-      newPtr = new T[newSize];
-    }
-    int32_t mcp = std::min(newSize, oldSize);
-    if (mcp) {
-      assert(ptr);
-      std::memmove(newPtr, ptr, mcp * sizeof(T));
-    }
-    if (newSize > oldSize) {
-      std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T));
-    }
-  }
-  T* oldPtr = ptr;
-  ptr = newPtr;
-  return oldPtr;
-}
-
-template <typename T>
-T** resizeArray(T**& ptr, int32_t oldSize, int32_t newSize, T** newPtr = nullptr)
-{
-  // Resize array of pointers pointed by ptr.
-  // If the non-null newPtr is provided, use it instead of allocating a new one.
-  // In this case it is up to the user to ensure that it has at least newSize slots allocated.
-  // Return original array pointer, so that the user can manage previously allocate memory
-  if (oldSize < 0) {
-    oldSize = 0;
-  }
-  if (newSize > 0) {
-    if (!newPtr) {
-      newPtr = new T*[newSize];
-    }
-    int32_t mcp = std::min(newSize, oldSize);
-    std::memmove(newPtr, ptr, mcp * sizeof(T*));
-    if (newSize > oldSize) {
-      std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T*));
-    }
-  }
-  T** oldPtr = ptr;
-  ptr = newPtr;
-  return oldPtr;
-}
-
-#endif //! GPUCA_GPUCODE
-
 class FlatObject
 {
  public:
@@ -187,6 +130,61 @@ class FlatObject
   FlatObject() = delete;
 #endif
 
+#ifndef GPUCA_GPUCODE // code invisible on GPU
+  template <typename T>
+  T* resizeArray(T*& ptr, int32_t oldSize, int32_t newSize, T* newPtr = nullptr)
+  {
+    // Resize array pointed by ptr. T must be a POD class.
+    // If the non-null newPtr is provided, use it instead of allocating a new one.
+    // In this case it is up to the user to ensure that it has at least newSize slots allocated.
+    // Return original array pointer, so that the user can manage previously allocate memory
+    if (oldSize < 0) {
+      oldSize = 0;
+    }
+    if (newSize > 0) {
+      if (!newPtr) {
+        newPtr = new T[newSize];
+      }
+      int32_t mcp = std::min(newSize, oldSize);
+      if (mcp) {
+        assert(ptr);
+        std::memmove(newPtr, ptr, mcp * sizeof(T));
+      }
+      if (newSize > oldSize) {
+        std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T));
+      }
+    }
+    T* oldPtr = ptr;
+    ptr = newPtr;
+    return oldPtr;
+  }
+
+  template <typename T>
+  T** resizeArray(T**& ptr, int32_t oldSize, int32_t newSize, T** newPtr = nullptr)
+  {
+    // Resize array of pointers pointed by ptr.
+    // If the non-null newPtr is provided, use it instead of allocating a new one.
+    // In this case it is up to the user to ensure that it has at least newSize slots allocated.
+    // Return original array pointer, so that the user can manage previously allocate memory
+    if (oldSize < 0) {
+      oldSize = 0;
+    }
+    if (newSize > 0) {
+      if (!newPtr) {
+        newPtr = new T*[newSize];
+      }
+      int32_t mcp = std::min(newSize, oldSize);
+      std::memmove(newPtr, ptr, mcp * sizeof(T*));
+      if (newSize > oldSize) {
+        std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T*));
+      }
+    }
+    T** oldPtr = ptr;
+    ptr = newPtr;
+    return oldPtr;
+  }
+#endif //! GPUCA_GPUCODE
+
  protected:
   /// _____________  Memory alignment  __________________________