From c34fd10b5bcf1e692cd609b5b156abd70624f7b7 Mon Sep 17 00:00:00 2001
From: Andreas Kling <awesomekling@gmail.com>
Date: Fri, 20 Sep 2019 15:19:11 +0200
Subject: [PATCH] LibCore: Introduce ObjectPtr, a step towards
 reference-counted CObject

Long-term we should use reference counting for the CObject hierarchy.
Since we've already accumulated a fair amount of code, this is quite a
large task, so I'm breaking it into some steps.

So, ObjectPtr is a "smart" pointer for CObject-derived types.
It becomes null when moved from, and will destroy unparented CObjects
in its destructor.

The idea here is to convert the codebase over to ObjectPtr piece by
piece, and then when everything is moved and CObject itself refactored
for ref-counting, we can just replace ObjectPtr with RefPtr everywhere.
---
 Libraries/LibCore/ObjectPtr.h | 53 +++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 Libraries/LibCore/ObjectPtr.h

diff --git a/Libraries/LibCore/ObjectPtr.h b/Libraries/LibCore/ObjectPtr.h
new file mode 100644
index 0000000000..1c4942da82
--- /dev/null
+++ b/Libraries/LibCore/ObjectPtr.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <AK/StdLibExtras.h>
+
+// This is a stopgap pointer. It's not meant to stick around forever.
+
+template<typename T>
+class ObjectPtr {
+public:
+    ObjectPtr() {}
+    ObjectPtr(T* ptr) : m_ptr(ptr) {}
+    ~ObjectPtr()
+    {
+        if (m_ptr && !m_ptr->parent())
+            delete m_ptr;
+    }
+
+    ObjectPtr(const ObjectPtr& other)
+        : m_ptr(other.m_ptr)
+    {
+    }
+
+    ObjectPtr(ObjectPtr&& other)
+    {
+        m_ptr = exchange(other.m_ptr, nullptr);
+    }
+
+    ObjectPtr& operator=(const ObjectPtr& other)
+    {
+        m_ptr = other.m_ptr;
+        return *this;
+    }
+
+    ObjectPtr& operator=(ObjectPtr&& other)
+    {
+        if (this != &other) {
+            m_ptr = exchange(other.m_ptr, nullptr);
+        }
+        return *this;
+    }
+
+    T* operator->() { return m_ptr; }
+    const T* operator->() const { return m_ptr; }
+
+    operator T*() { return m_ptr; }
+    operator const T*() const { return m_ptr; }
+
+    T& operator*() { return *m_ptr; }
+    const T& operator*() const { return *m_ptr; }
+
+private:
+    T* m_ptr { nullptr };
+};