From 872c275bc7bfda089d2320723c3796cf71d34d84 Mon Sep 17 00:00:00 2001
From: Deukhoofd <deukhoofd@gmail.com>
Date: Sat, 28 Mar 2020 21:08:55 +0100
Subject: [PATCH] Support for pointer holder outline.

---
 src/Memory/BorrowedPtr.hpp        | 21 +++++++++++++++++++
 src/Memory/NonNullBorrowedPtr.hpp | 24 ++++++++++++++++++++++
 src/Memory/NonNullOwnPtr.hpp      | 34 +++++++++++++++++++++++++++++++
 src/Memory/OwnPtr.hpp             | 32 +++++++++++++++++++++++++++++
 tests/MemoryTests.cpp             | 27 ++++++++++++++++++++++++
 5 files changed, 138 insertions(+)
 create mode 100644 src/Memory/BorrowedPtr.hpp
 create mode 100644 src/Memory/NonNullBorrowedPtr.hpp
 create mode 100644 src/Memory/NonNullOwnPtr.hpp
 create mode 100644 src/Memory/OwnPtr.hpp
 create mode 100644 tests/MemoryTests.cpp

diff --git a/src/Memory/BorrowedPtr.hpp b/src/Memory/BorrowedPtr.hpp
new file mode 100644
index 0000000..b043d17
--- /dev/null
+++ b/src/Memory/BorrowedPtr.hpp
@@ -0,0 +1,21 @@
+#ifndef ARBUTILS_BORROWEDPTR_HPP
+#define ARBUTILS_BORROWEDPTR_HPP
+
+namespace Arbutils::Memory{
+    template <class T>
+    class BorrowedPtr{
+        T* _ptr;
+
+    public:
+        inline explicit constexpr BorrowedPtr(T* ptr) noexcept : _ptr(ptr){};
+
+        inline constexpr T* GetUnsafe() noexcept { return _ptr; }
+        inline constexpr const T* GetUnsafe() const noexcept { return _ptr; }
+
+        T* operator->() noexcept { return _ptr; }
+        const T* operator->() const noexcept { return _ptr; }
+
+    };
+}
+
+#endif // ARBUTILS_BORROWEDPTR_HPP
diff --git a/src/Memory/NonNullBorrowedPtr.hpp b/src/Memory/NonNullBorrowedPtr.hpp
new file mode 100644
index 0000000..d545171
--- /dev/null
+++ b/src/Memory/NonNullBorrowedPtr.hpp
@@ -0,0 +1,24 @@
+#ifndef ARBUTILS_NONNULLBORROWEDPTR_HPP
+#define ARBUTILS_NONNULLBORROWEDPTR_HPP
+#include "../Assert.hpp"
+#include "BorrowedPtr.hpp"
+
+namespace Arbutils::Memory {
+    template <class T> class NonNullBorrowedPtr {
+    private:
+        T* _ptr;
+
+    public:
+        inline explicit NonNullBorrowedPtr(T* ptr) : _ptr(ptr){
+            AssertNotNull(ptr);
+        };
+
+        inline constexpr T* GetUnsafe() noexcept { return _ptr; }
+        inline constexpr const T* GetUnsafe() const noexcept { return _ptr; }
+
+        T* operator->() noexcept { return _ptr; }
+        const T* operator->() const noexcept { return _ptr; }
+    };
+}
+
+#endif // ARBUTILS_NONNULLBORROWEDPTR_HPP
diff --git a/src/Memory/NonNullOwnPtr.hpp b/src/Memory/NonNullOwnPtr.hpp
new file mode 100644
index 0000000..c844dff
--- /dev/null
+++ b/src/Memory/NonNullOwnPtr.hpp
@@ -0,0 +1,34 @@
+#ifndef ARBUTILS_NONNULLOWNPTR_HPP
+#define ARBUTILS_NONNULLOWNPTR_HPP
+
+#include "OwnPtr.hpp"
+#include "../Assert.hpp"
+#include "NonNullBorrowedPtr.hpp"
+
+namespace Arbutils::Memory {
+    template <class T> class NonNullOwnPtr{
+        T* _ptr;
+
+    public:
+        inline explicit NonNullOwnPtr(T* ptr) : _ptr(ptr){
+            AssertNotNull(ptr);
+        };
+
+        NonNullOwnPtr<T>(const NonNullOwnPtr<T>&) = delete;
+        NonNullOwnPtr<T>& operator=(OwnPtr<T> const&) = delete;
+
+        inline ~NonNullOwnPtr() noexcept { delete _ptr; }
+
+        inline constexpr T* GetUnsafe() noexcept { return _ptr; }
+        inline constexpr const T* GetUnsafe() const noexcept { return _ptr; }
+
+        inline NonNullBorrowedPtr<T> Borrow(){
+            return NonNullBorrowedPtr<T>(_ptr);
+        }
+
+        T* operator->() noexcept { return _ptr; }
+        const T* operator->() const noexcept { return _ptr; }
+    };
+}
+
+#endif // ARBUTILS_NONNULLOWNPTR_HPP
diff --git a/src/Memory/OwnPtr.hpp b/src/Memory/OwnPtr.hpp
new file mode 100644
index 0000000..406cb8b
--- /dev/null
+++ b/src/Memory/OwnPtr.hpp
@@ -0,0 +1,32 @@
+#ifndef ARBUTILS_OWNPTR_HPP
+#define ARBUTILS_OWNPTR_HPP
+
+#include <memory>
+#include "BorrowedPtr.hpp"
+
+namespace Arbutils::Memory {
+    template <class T> class OwnPtr {
+        T* _ptr;
+
+    public:
+        inline explicit constexpr OwnPtr(T* ptr) noexcept : _ptr(ptr){};
+
+        OwnPtr<T>(const OwnPtr<T>&) = delete;
+        OwnPtr<T>& operator=(OwnPtr<T> const&) = delete;
+
+        inline ~OwnPtr() noexcept { delete _ptr; }
+
+        inline constexpr T* GetUnsafe() noexcept { return _ptr; }
+        inline constexpr const T* GetUnsafe() const noexcept { return _ptr; }
+
+        inline BorrowedPtr<T> Borrow(){
+            return BorrowedPtr<T>(_ptr);
+        }
+
+        T* operator->() noexcept { return _ptr; }
+        const T* operator->() const noexcept { return _ptr; }
+    };
+}
+
+
+#endif // ARBUTILS_OWNPTR_HPP
diff --git a/tests/MemoryTests.cpp b/tests/MemoryTests.cpp
new file mode 100644
index 0000000..0e89a13
--- /dev/null
+++ b/tests/MemoryTests.cpp
@@ -0,0 +1,27 @@
+#ifdef TESTS_BUILD
+#include "../extern/catch.hpp"
+#include "../src/Memory/NonNullOwnPtr.hpp"
+#include "../src/Memory/OwnPtr.hpp"
+
+struct TestClass{
+    bool GetTestBool(){
+        return true;
+    }
+};
+
+TEST_CASE("Access OwnPtr", "[Utilities]") {
+    auto v = Arbutils::Memory::OwnPtr<TestClass>(new TestClass());
+    CHECK(v->GetTestBool());
+}
+
+TEST_CASE("Access NonNullOwnPtr", "[Utilities]") {
+    auto v = Arbutils::Memory::NonNullOwnPtr<TestClass>(new TestClass());
+    CHECK(v->GetTestBool());
+}
+
+TEST_CASE("Instantiate NonNullOwnPtr fails with nullptr", "[Utilities]") {
+    CHECK_THROWS(Arbutils::Memory::NonNullOwnPtr<TestClass>(nullptr));
+}
+
+
+#endif
\ No newline at end of file