Format all code with clang-format

1 files changed, 125 insertions, 110 deletions

diff --git a/include/raul/Maid.hpp b/include/raul/Maid.hpp
index 1c1977f..9176d8b 100644
--- a/include/raul/Maid.hpp
+++ b/include/raul/Maid.hpp
@@ -38,118 +38,133 @@ namespace Raul {
 class Maid : public Noncopyable
 {
 public:
-	/** An object that can be disposed via Maid::dispose(). */
-	class Disposable : public Deletable {
-	public:
-		Disposable() = default;
-
-		Disposable(const Disposable&) = delete;
-		Disposable& operator=(const Disposable&) = delete;
-
-		Disposable(Disposable&&) = delete;
-		Disposable& operator=(Disposable&&) = delete;
-
-		~Disposable() override = default;
-
-	private:
-		friend class Maid;
-		Disposable* _maid_next{};
-	};
-
-	/** Disposable wrapper for any type. */
-	template<typename T>
-	class Managed : public Raul::Maid::Disposable, public T
-	{
-	public:
-		template<typename... Args>
-		explicit Managed(Args&&... args)
-			: T(std::forward<Args>(args)...)
-		{}
-	};
-
-	/** Deleter for Disposable objects. */
-	template<typename T>
-	class Disposer {
-	public:
-		explicit Disposer(Maid* maid) : _maid(maid) {}
-
-		Disposer() = default;
-
-		void operator()(T* obj) {
-			if (_maid) { _maid->dispose(obj); }
-		}
-
-	private:
-		Maid* _maid{nullptr};
-	};
-
-	/** A managed pointer that automatically disposes of its contents.
-	 *
-	 * This is a unique_ptr so that it is possible to statically verify that
-	 * code is real-time safe.
-	 */
-	template<typename T> using managed_ptr = std::unique_ptr<T, Disposer<T>>;
-
-	Maid() : _disposed(nullptr) {}
-
-	Maid(const Maid&) = delete;
-	Maid& operator=(const Maid&) = delete;
-
-	Maid(Maid&&) = delete;
-	Maid& operator=(Maid&&) = delete;
-
-	inline ~Maid() { cleanup(); }
-
-	/** Return false iff there is currently no garbage. */
-	inline bool empty() const {
-		return !_disposed.load(std::memory_order_relaxed);
-	}
-
-	/** Enqueue an object for deletion when cleanup() is called next.
-	 *
-	 * This is thread-safe, and real-time safe assuming reasonably low
-	 * contention.
-	 */
-	inline void dispose(Disposable* obj) {
-		if (obj) {
-			// Atomically add obj to the head of the disposed list
-			do {
-				obj->_maid_next = _disposed.load(std::memory_order_relaxed);
-			} while (!_disposed.compare_exchange_weak(
-				         obj->_maid_next, obj,
-				         std::memory_order_release,
-				         std::memory_order_relaxed));
-		}
-	}
-
-	/** Delete all disposed objects immediately.
-	 *
-	 * Obviously not real-time safe, but may be called while other threads are
-	 * calling dispose().
-	 */
-	inline void cleanup() {
-		// Atomically get the head of the disposed list
-		Disposable* const disposed = _disposed.exchange(
-			nullptr, std::memory_order_acquire);
-
-		// Free the disposed list
-		for (Disposable* obj = disposed; obj;) {
-			Disposable* const next = obj->_maid_next;
-			delete obj;
-			obj = next;
-		}
-	}
-
-	/** Make a unique_ptr that will dispose its object when dropped. */
-	template<class T, class... Args>
-	managed_ptr<T> make_managed(Args&&... args) {
-		return std::unique_ptr<T, Disposer<T> >(
-			new T(std::forward<Args>(args)...),
-			Disposer<T>(this));
-	}
+  /** An object that can be disposed via Maid::dispose(). */
+  class Disposable : public Deletable
+  {
+  public:
+    Disposable() = default;
+
+    Disposable(const Disposable&) = delete;
+    Disposable& operator=(const Disposable&) = delete;
+
+    Disposable(Disposable&&) = delete;
+    Disposable& operator=(Disposable&&) = delete;
+
+    ~Disposable() override = default;
+
+  private:
+    friend class Maid;
+    Disposable* _maid_next{};
+  };
+
+  /** Disposable wrapper for any type. */
+  template<typename T>
+  class Managed
+    : public Raul::Maid::Disposable
+    , public T
+  {
+  public:
+    template<typename... Args>
+    explicit Managed(Args&&... args)
+      : T(std::forward<Args>(args)...)
+    {}
+  };
+
+  /** Deleter for Disposable objects. */
+  template<typename T>
+  class Disposer
+  {
+  public:
+    explicit Disposer(Maid* maid)
+      : _maid(maid)
+    {}
+
+    Disposer() = default;
+
+    void operator()(T* obj)
+    {
+      if (_maid) {
+        _maid->dispose(obj);
+      }
+    }
+
+  private:
+    Maid* _maid{nullptr};
+  };
+
+  /** A managed pointer that automatically disposes of its contents.
+   *
+   * This is a unique_ptr so that it is possible to statically verify that
+   * code is real-time safe.
+   */
+  template<typename T>
+  using managed_ptr = std::unique_ptr<T, Disposer<T>>;
+
+  Maid()
+    : _disposed(nullptr)
+  {}
+
+  Maid(const Maid&) = delete;
+  Maid& operator=(const Maid&) = delete;
+
+  Maid(Maid&&)  = delete;
+  Maid& operator=(Maid&&) = delete;
+
+  inline ~Maid() { cleanup(); }
+
+  /** Return false iff there is currently no garbage. */
+  inline bool empty() const
+  {
+    return !_disposed.load(std::memory_order_relaxed);
+  }
+
+  /** Enqueue an object for deletion when cleanup() is called next.
+   *
+   * This is thread-safe, and real-time safe assuming reasonably low
+   * contention.
+   */
+  inline void dispose(Disposable* obj)
+  {
+    if (obj) {
+      // Atomically add obj to the head of the disposed list
+      do {
+        obj->_maid_next = _disposed.load(std::memory_order_relaxed);
+      } while (!_disposed.compare_exchange_weak(obj->_maid_next,
+                                                obj,
+                                                std::memory_order_release,
+                                                std::memory_order_relaxed));
+    }
+  }
+
+  /** Delete all disposed objects immediately.
+   *
+   * Obviously not real-time safe, but may be called while other threads are
+   * calling dispose().
+   */
+  inline void cleanup()
+  {
+    // Atomically get the head of the disposed list
+    Disposable* const disposed =
+      _disposed.exchange(nullptr, std::memory_order_acquire);
+
+    // Free the disposed list
+    for (Disposable* obj = disposed; obj;) {
+      Disposable* const next = obj->_maid_next;
+      delete obj;
+      obj = next;
+    }
+  }
+
+  /** Make a unique_ptr that will dispose its object when dropped. */
+  template<class T, class... Args>
+  managed_ptr<T> make_managed(Args&&... args)
+  {
+    return std::unique_ptr<T, Disposer<T>>(new T(std::forward<Args>(args)...),
+                                           Disposer<T>(this));
+  }
 
 private:
-	std::atomic<Disposable*> _disposed;
+  std::atomic<Disposable*> _disposed;
 };
 
 template<typename T>