From bd0214b1da66225f410641692e89e492f668472a Mon Sep 17 00:00:00 2001
From: David Robillard <d@drobilla.net>
Date: Sat, 2 Jan 2021 14:46:29 +0100
Subject: Format all code with clang-format

---
 include/raul/Array.hpp | 238 +++++++++++++++++++++++++------------------------
 1 file changed, 120 insertions(+), 118 deletions(-)

(limited to 'include/raul/Array.hpp')

diff --git a/include/raul/Array.hpp b/include/raul/Array.hpp
index a80038f..9e7e24c 100644
--- a/include/raul/Array.hpp
+++ b/include/raul/Array.hpp
@@ -29,129 +29,131 @@ namespace Raul {
  *
  * \ingroup raul
  */
-template <class T>
+template<class T>
 class Array : public Maid::Disposable
 {
 public:
-	explicit Array(size_t size = 0)
-		: Maid::Disposable()
-		, _size(size)
-		, _elems(size ? new T[size] : nullptr)
-	{
-	}
-
-	Array(size_t size, T initial_value)
-		: Maid::Disposable()
-		, _size(size)
-		, _elems(size ? new T[size] : nullptr)
-	{
-		if (size > 0) {
-			for (size_t i = 0; i < size; ++i) {
-				_elems[i] = initial_value;
-			}
-		}
-	}
-
-	Array(const Array<T>& array)
-		: Maid::Disposable()
-		, _size(array._size)
-		, _elems(_size ? new T[_size] : nullptr)
-	{
-		for (size_t i = 0; i < _size; ++i) {
-			_elems[i] = array._elems[i];
-		}
-	}
-
-	~Array() override = default;
-
-	Array<T>& operator=(const Array<T>& array)
-	{
-		if (&array == this) {
-			return *this;
-		}
-
-		_size  = array._size;
-		_elems = _size ? new T[_size] : nullptr;
-
-		for (size_t i = 0; i < _size; ++i) {
-			_elems[i] = array._elems[i];
-		}
-	}
-
-	Array(Array<T>&& array) noexcept
-	    : _size(array._size)
-	    , _elems(std::move(array._elems))
-	{
-	}
-
-	Array<T>& operator=(Array<T>&& array) noexcept
-	{
-		_size  = array._size;
-		_elems = std::move(array._elems);
-		return *this;
-	}
-
-	Array(size_t size, const Array<T>& contents)
-		: _size(size)
-		, _elems(size ? new T[size] : nullptr)
-	{
-		assert(contents.size() >= size);
-		for (size_t i = 0; i < std::min(size, contents.size()); ++i) {
-			_elems[i] = contents[i];
-		}
-	}
-
-	Array(size_t size, const Array<T>& contents, T initial_value = T())
-		: _size(size)
-		, _elems(size ? new T[size] : nullptr)
-	{
-		const size_t end = std::min(size, contents.size());
-		for (size_t i = 0; i < end; ++i) {
-			_elems[i] = contents[i];
-		}
-		for (size_t i = end; i < size; ++i) {
-			_elems[i] = initial_value;
-		}
-	}
-
-	virtual void alloc(size_t num_elems) {
-		_size = num_elems;
-
-		if (num_elems > 0) {
-			_elems = std::unique_ptr<T[]>(new T[num_elems]);
-		} else {
-			_elems.reset();
-		}
-	}
-
-	virtual void alloc(size_t num_elems, T initial_value) {
-		_size = num_elems;
-
-		if (num_elems > 0) {
-			_elems = std::unique_ptr<T[]>(new T[num_elems]);
-			for (size_t i = 0; i < _size; ++i) {
-				_elems[i] = initial_value;
-			}
-		} else {
-			_elems.reset();
-		}
-	}
-
-	inline size_t size() const  { return _size; }
-
-	inline T& operator[](size_t i) const {
-		assert(i < _size);
-		return _elems[i];
-	}
-
-	inline T& at(size_t i) const {
-		assert(i < _size);
-		return _elems[i];
-	}
+  explicit Array(size_t size = 0)
+    : Maid::Disposable()
+    , _size(size)
+    , _elems(size ? new T[size] : nullptr)
+  {}
+
+  Array(size_t size, T initial_value)
+    : Maid::Disposable()
+    , _size(size)
+    , _elems(size ? new T[size] : nullptr)
+  {
+    if (size > 0) {
+      for (size_t i = 0; i < size; ++i) {
+        _elems[i] = initial_value;
+      }
+    }
+  }
+
+  Array(const Array<T>& array)
+    : Maid::Disposable()
+    , _size(array._size)
+    , _elems(_size ? new T[_size] : nullptr)
+  {
+    for (size_t i = 0; i < _size; ++i) {
+      _elems[i] = array._elems[i];
+    }
+  }
+
+  ~Array() override = default;
+
+  Array<T>& operator=(const Array<T>& array)
+  {
+    if (&array == this) {
+      return *this;
+    }
+
+    _size  = array._size;
+    _elems = _size ? new T[_size] : nullptr;
+
+    for (size_t i = 0; i < _size; ++i) {
+      _elems[i] = array._elems[i];
+    }
+  }
+
+  Array(Array<T>&& array) noexcept
+    : _size(array._size)
+    , _elems(std::move(array._elems))
+  {}
+
+  Array<T>& operator=(Array<T>&& array) noexcept
+  {
+    _size  = array._size;
+    _elems = std::move(array._elems);
+    return *this;
+  }
+
+  Array(size_t size, const Array<T>& contents)
+    : _size(size)
+    , _elems(size ? new T[size] : nullptr)
+  {
+    assert(contents.size() >= size);
+    for (size_t i = 0; i < std::min(size, contents.size()); ++i) {
+      _elems[i] = contents[i];
+    }
+  }
+
+  Array(size_t size, const Array<T>& contents, T initial_value = T())
+    : _size(size)
+    , _elems(size ? new T[size] : nullptr)
+  {
+    const size_t end = std::min(size, contents.size());
+    for (size_t i = 0; i < end; ++i) {
+      _elems[i] = contents[i];
+    }
+    for (size_t i = end; i < size; ++i) {
+      _elems[i] = initial_value;
+    }
+  }
+
+  virtual void alloc(size_t num_elems)
+  {
+    _size = num_elems;
+
+    if (num_elems > 0) {
+      _elems = std::unique_ptr<T[]>(new T[num_elems]);
+    } else {
+      _elems.reset();
+    }
+  }
+
+  virtual void alloc(size_t num_elems, T initial_value)
+  {
+    _size = num_elems;
+
+    if (num_elems > 0) {
+      _elems = std::unique_ptr<T[]>(new T[num_elems]);
+      for (size_t i = 0; i < _size; ++i) {
+        _elems[i] = initial_value;
+      }
+    } else {
+      _elems.reset();
+    }
+  }
+
+  inline size_t size() const { return _size; }
+
+  inline T& operator[](size_t i) const
+  {
+    assert(i < _size);
+    return _elems[i];
+  }
+
+  inline T& at(size_t i) const
+  {
+    assert(i < _size);
+    return _elems[i];
+  }
 
 private:
-	size_t _size;
-	std::unique_ptr<T[]> _elems;
+  size_t               _size;
+  std::unique_ptr<T[]> _elems;
 };
 
 } // namespace Raul
-- 
cgit v1.2.1