clang format apply

utils/common/vlarray.h

@@ -17,84 +17,111 @@
 #ifndef UTILS_COMMON_VLARRAY_H
 #define UTILS_COMMON_VLARRAY_H
 
-namespace utils {
-
-template <typename T, size_t SIZE=64>
+namespace utils
+{
+template <typename T, size_t SIZE = 64>
 class VLArray
 {
-public:
-    VLArray(size_t sz) :
-        sz(sz),
-        stack_storage(NULL),
-        dyn_storage(NULL),
-        ptr(NULL)
+ public:
+  VLArray(size_t sz) : sz(sz), stack_storage(NULL), dyn_storage(NULL), ptr(NULL)
+  {
+    if (sz > SIZE)
     {
-        if (sz > SIZE) {
-            dyn_storage = new T[sz];
-            ptr = dyn_storage;
-        } else {
-            stack_storage = new (stack) T[sz];
-            ptr = stack_storage;
-        }
+      dyn_storage = new T[sz];
+      ptr = dyn_storage;
     }
-
-    VLArray(size_t sz, const T& initval) : VLArray(sz)
+    else
     {
-      for (size_t i= 0; i < sz; ++i)
-        ptr[i]= initval;
+      stack_storage = new (stack) T[sz];
+      ptr = stack_storage;
     }
+  }
 
-    VLArray(const VLArray&) = delete;
-    VLArray(VLArray&&) = delete;
-    VLArray& operator=(const VLArray&) = delete;
-    VLArray& operator=(VLArray&&) = delete;
+  VLArray(size_t sz, const T& initval) : VLArray(sz)
+  {
+    for (size_t i = 0; i < sz; ++i)
+      ptr[i] = initval;
+  }
 
-    ~VLArray() {
-        if (dyn_storage) {
-            delete [] dyn_storage;
-        } else {
-            // we cannot use `delete [] stack_storage` here so call d-tors explicitly
-            if (!std::is_trivially_destructible<T>::value) {
-                for (size_t i = 0; i < sz; ++i)
-                    stack_storage[i].~T();
-            }
-        }
+  VLArray(const VLArray&) = delete;
+  VLArray(VLArray&&) = delete;
+  VLArray& operator=(const VLArray&) = delete;
+  VLArray& operator=(VLArray&&) = delete;
+
+  ~VLArray()
+  {
+    if (dyn_storage)
+    {
+      delete[] dyn_storage;
     }
-
-    size_t size() const { return sz; }
-    const T* data() const { return ptr; }
-    T* data() { return ptr; }
-
-    const T& operator[](size_t i) const { return ptr[i]; }
-    T& operator[](size_t i) { return ptr[i]; }
-
-    const T& at(size_t i) const {
-        if (i >= sz) {
-            throw std::out_of_range("index out of range: " + std::to_string(i) +
-                                    " >= size " + std::to_string(sz));
-        }
-        return ptr[i];
+    else
+    {
+      // we cannot use `delete [] stack_storage` here so call d-tors explicitly
+      if (!std::is_trivially_destructible<T>::value)
+      {
+        for (size_t i = 0; i < sz; ++i)
+          stack_storage[i].~T();
+      }
     }
+  }
 
-    T& at(size_t i) {
-        if (i >= sz) {
-            throw std::out_of_range("index out of range: " + std::to_string(i) +
-                                    " >= size " + std::to_string(sz));
-        }
-        return ptr[i];
+  size_t size() const
+  {
+    return sz;
+  }
+  const T* data() const
+  {
+    return ptr;
+  }
+  T* data()
+  {
+    return ptr;
+  }
+
+  const T& operator[](size_t i) const
+  {
+    return ptr[i];
+  }
+  T& operator[](size_t i)
+  {
+    return ptr[i];
+  }
+
+  const T& at(size_t i) const
+  {
+    if (i >= sz)
+    {
+      throw std::out_of_range("index out of range: " + std::to_string(i) + " >= size " + std::to_string(sz));
     }
+    return ptr[i];
+  }
 
-    operator const T* () const { return ptr; }
-    operator T* () { return ptr; }
+  T& at(size_t i)
+  {
+    if (i >= sz)
+    {
+      throw std::out_of_range("index out of range: " + std::to_string(i) + " >= size " + std::to_string(sz));
+    }
+    return ptr[i];
+  }
 
-private:
-    const size_t sz;
-    alignas(T) char stack[SIZE * sizeof(T)];
-    T* stack_storage;
-    T* dyn_storage;
-    T* ptr;
+  operator const T*() const
+  {
+    return ptr;
+  }
+  operator T*()
+  {
+    return ptr;
+  }
+
+ private:
+  const size_t sz;
+  alignas(T) char stack[SIZE * sizeof(T)];
+  T* stack_storage;
+  T* dyn_storage;
+  T* ptr;
 };
 
-} // namespace utils
+}  // namespace utils
 
-#endif // UTILS_COMMON_VLARRAY_H
+#endif  // UTILS_COMMON_VLARRAY_H