From 90bda57d79c1fd7731a0cc46d12b350142862fd8 Mon Sep 17 00:00:00 2001
From: Deukhoofd <deukhoofd@gmail.com>
Date: Tue, 26 May 2020 17:39:27 +0200
Subject: [PATCH] Renamed borrowed ptr to be in line with other types.

---
 src/Memory/BorrowedPtr.hpp  | 55 +++++++++++++++++++++++++++++++++++++
 src/Memory/borrowed_ptr.hpp | 55 -------------------------------------
 2 files changed, 55 insertions(+), 55 deletions(-)
 create mode 100644 src/Memory/BorrowedPtr.hpp
 delete mode 100644 src/Memory/borrowed_ptr.hpp

diff --git a/src/Memory/BorrowedPtr.hpp b/src/Memory/BorrowedPtr.hpp
new file mode 100644
index 0000000..34ee926
--- /dev/null
+++ b/src/Memory/BorrowedPtr.hpp
@@ -0,0 +1,55 @@
+#ifndef ARBUTILS_BORROWEDPTR_HPP
+#define ARBUTILS_BORROWEDPTR_HPP
+
+#include <memory>
+
+namespace ArbUt {
+    /// A borrowed pointer is used to indicate a pointer that is not owned by an object, but instead borrowed from
+    /// another owning object that is assumed to always be kept alive during the entire lifetime of the borrowing
+    /// object.
+    template <class T> class BorrowedPtr {
+    private:
+        T* _raw;
+
+    public:
+        inline BorrowedPtr<T>() : _raw(nullptr){};
+        inline BorrowedPtr<T>(T* ptr) : _raw(ptr){};
+        inline BorrowedPtr(const BorrowedPtr<T>& other) : _raw(other._raw){};
+        inline BorrowedPtr(const std::unique_ptr<T>& other) : _raw(other.get()){};
+
+        ~BorrowedPtr() = default;
+
+        inline BorrowedPtr<T>& operator=(const BorrowedPtr<T>& rhs) {
+            _raw = rhs._raw;
+            return *this;
+        }
+
+        inline T* operator->() const noexcept { return _raw; }
+        inline T* GetRaw() const noexcept { return _raw; }
+
+        inline bool operator==(const BorrowedPtr& rhs) const { return _raw == rhs._raw; }
+        inline bool operator!=(const BorrowedPtr& rhs) const { return _raw != rhs._raw; }
+
+        [[nodiscard]] inline constexpr bool IsNull() const noexcept { return _raw == nullptr; }
+
+        template <class TCast> inline BorrowedPtr<TCast> As() const {
+            auto cast = dynamic_cast<TCast>(_raw);
+            return BorrowedPtr<TCast>(cast);
+        }
+
+        template <class TCast> inline bool TryAs(BorrowedPtr<TCast>& out) const {
+            auto cast = dynamic_cast<TCast>(_raw);
+            if (cast == nullptr)
+                return false;
+            out = BorrowedPtr<TCast>(cast);
+            return true;
+        }
+
+        template <class TCast> inline BorrowedPtr<TCast> ForceAs() const {
+            auto cast = reinterpret_cast<TCast>(_raw);
+            return BorrowedPtr<TCast>(cast);
+        }
+    };
+}
+
+#endif // ARBUTILS_BORROWEDPTR_HPP
diff --git a/src/Memory/borrowed_ptr.hpp b/src/Memory/borrowed_ptr.hpp
deleted file mode 100644
index fef160b..0000000
--- a/src/Memory/borrowed_ptr.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef ARBUTILS_BORROWED_PTR_HPP
-#define ARBUTILS_BORROWED_PTR_HPP
-
-#include <memory>
-
-namespace ArbUt {
-    /// A borrowed pointer is used to indicate a pointer that is not owned by an object, but instead borrowed from
-    /// another owning object that is assumed to always be kept alive during the entire lifetime of the borrowing
-    /// object.
-    template <class T> class borrowed_ptr {
-    private:
-        T* _raw;
-
-    public:
-        inline borrowed_ptr<T>() : _raw(nullptr){};
-        inline borrowed_ptr<T>(T* ptr) : _raw(ptr){};
-        inline borrowed_ptr(const borrowed_ptr<T>& other) : _raw(other._raw){};
-        inline borrowed_ptr(const std::unique_ptr<T>& other) : _raw(other.get()){};
-
-        ~borrowed_ptr() = default;
-
-        inline borrowed_ptr<T>& operator=(const borrowed_ptr<T>& rhs) {
-            _raw = rhs._raw;
-            return *this;
-        }
-
-        inline T* operator->() const noexcept { return _raw; }
-        inline T* GetRaw() const noexcept { return _raw; }
-
-        inline bool operator==(const borrowed_ptr& rhs) const { return _raw == rhs._raw; }
-        inline bool operator!=(const borrowed_ptr& rhs) const { return _raw != rhs._raw; }
-
-        [[nodiscard]] inline constexpr bool IsNull() const noexcept { return _raw == nullptr; }
-
-        template <class TCast> inline borrowed_ptr<TCast> As() const {
-            auto cast = dynamic_cast<TCast>(_raw);
-            return borrowed_ptr<TCast>(cast);
-        }
-
-        template <class TCast> inline bool TryAs(borrowed_ptr<TCast>& out) const {
-            auto cast = dynamic_cast<TCast>(_raw);
-            if (cast == nullptr)
-                return false;
-            out = borrowed_ptr<TCast>(cast);
-            return true;
-        }
-
-        template <class TCast> inline borrowed_ptr<TCast> ForceAs() const {
-            auto cast = reinterpret_cast<TCast>(_raw);
-            return borrowed_ptr<TCast>(cast);
-        }
-    };
-}
-
-#endif // ARBUTILS_BORROWED_PTR_HPP