From 2ae108517d4124036a4ec970901bdb51a72be497 Mon Sep 17 00:00:00 2001
From: Deukhoofd <deukhoofd@gmail.com>
Date: Tue, 26 May 2020 17:18:12 +0200
Subject: [PATCH] Support for easy type casting from borrowed_ptr.

---
 src/Memory/borrowed_ptr.hpp | 63 ++++++++++++++++++++++++-------------
 1 file changed, 42 insertions(+), 21 deletions(-)

diff --git a/src/Memory/borrowed_ptr.hpp b/src/Memory/borrowed_ptr.hpp
index eefdd70..fb7e597 100644
--- a/src/Memory/borrowed_ptr.hpp
+++ b/src/Memory/borrowed_ptr.hpp
@@ -3,32 +3,53 @@
 
 #include <memory>
 
-/// 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;
+namespace ArbUt::Memory {
+    /// 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()){};
+    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;
+        ~borrowed_ptr() = default;
 
-    inline borrowed_ptr<T>& operator=(const borrowed_ptr<T>& rhs) {
-        _raw = rhs._raw;
-        return *this;
-    }
+        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 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; }
+        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; }
-};
+        [[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