AK: Share code between NonnullOwnPtrVector and NonnullRefPtrVector.

These can just inherit from a shared base template. Thanks to Robin for the
sweet idea :^)

3 files changed, 57 insertions, 84 deletions

diff --git a/AK/NonnullOwnPtrVector.h b/AK/NonnullOwnPtrVector.h
index 0616658ced..d1d7024b7b 100644
--- a/AK/NonnullOwnPtrVector.h
+++ b/AK/NonnullOwnPtrVector.h
@@ -1,52 +1,13 @@
 #pragma once
 
+#include <AK/NonnullPtrVector.h>
 #include <AK/NonnullOwnPtr.h>
-#include <AK/Vector.h>
 
 namespace AK {
 
 template<typename T, int inline_capacity = 0>
-class NonnullOwnPtrVector : public Vector<NonnullOwnPtr<T>, inline_capacity> {
-    typedef Vector<NonnullOwnPtr<T>, inline_capacity> Base;
-
-public:
-    NonnullOwnPtrVector()
-    {
-    }
-
-    NonnullOwnPtrVector(Vector<NonnullOwnPtr<T>>&& other)
-        : Base(static_cast<Base&&>(other))
-    {
-    }
-    NonnullOwnPtrVector(const Vector<NonnullOwnPtr<T>>& other)
-        : Base(static_cast<const Base&>(other))
-    {
-    }
-
-    using Base::size;
-
-    using Iterator = VectorIterator<NonnullOwnPtrVector, T>;
-    Iterator begin() { return Iterator(*this, 0); }
-    Iterator end() { return Iterator(*this, size()); }
-
-    using ConstIterator = VectorIterator<const NonnullOwnPtrVector, const T>;
-    ConstIterator begin() const { return ConstIterator(*this, 0); }
-    ConstIterator end() const { return ConstIterator(*this, size()); }
-
-    T& at(int index) { return *Base::at(index); }
-    const T& at(int index) const { return *Base::at(index); }
-    T& operator[](int index) { return at(index); }
-    const T& operator[](int index) const { return at(index); }
-    T& first() { return at(0); }
-    const T& first() const { return at(0); }
-    T& last() { return at(size() - 1); }
-    const T& last() const { return at(size() - 1); }
-
-private:
-    // NOTE: You can't use resize() on a NonnullOwnPtrVector since making the vector
-    //       bigger would require being able to default-construct NonnullOwnPtrs.
-    //       Instead, use shrink(new_size).
-    void resize(int) = delete;
+class NonnullOwnPtrVector : public NonnullPtrVector<NonnullOwnPtr<T>, T, inline_capacity>
+{
 };
 
 }
diff --git a/AK/NonnullPtrVector.h b/AK/NonnullPtrVector.h
new file mode 100644
index 0000000000..345da11e08
--- /dev/null
+++ b/AK/NonnullPtrVector.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <AK/Vector.h>
+
+namespace AK {
+
+template<typename PtrType, typename T, int inline_capacity = 0>
+class NonnullPtrVector : public Vector<PtrType, inline_capacity> {
+    typedef Vector<PtrType, inline_capacity> Base;
+
+public:
+    NonnullPtrVector()
+    {
+    }
+
+    NonnullPtrVector(Vector<PtrType>&& other)
+        : Base(static_cast<Base&&>(other))
+    {
+    }
+    NonnullPtrVector(const Vector<PtrType>& other)
+        : Base(static_cast<const Base&>(other))
+    {
+    }
+
+    using Base::size;
+
+    using Iterator = VectorIterator<NonnullPtrVector, T>;
+    Iterator begin() { return Iterator(*this, 0); }
+    Iterator end() { return Iterator(*this, size()); }
+
+    using ConstIterator = VectorIterator<const NonnullPtrVector, const T>;
+    ConstIterator begin() const { return ConstIterator(*this, 0); }
+    ConstIterator end() const { return ConstIterator(*this, size()); }
+
+    T& at(int index) { return *Base::at(index); }
+    const T& at(int index) const { return *Base::at(index); }
+    T& operator[](int index) { return at(index); }
+    const T& operator[](int index) const { return at(index); }
+    T& first() { return at(0); }
+    const T& first() const { return at(0); }
+    T& last() { return at(size() - 1); }
+    const T& last() const { return at(size() - 1); }
+
+private:
+    // NOTE: You can't use resize() on a NonnullFooPtrVector since making the vector
+    //       bigger would require being able to default-construct NonnullFooPtrs.
+    //       Instead, use shrink(new_size).
+    void resize(int) = delete;
+};
+
+}
diff --git a/AK/NonnullRefPtrVector.h b/AK/NonnullRefPtrVector.h
index 296b92402e..1997e9fe45 100644
--- a/AK/NonnullRefPtrVector.h
+++ b/AK/NonnullRefPtrVector.h
@@ -1,52 +1,13 @@
 #pragma once
 
+#include <AK/NonnullPtrVector.h>
 #include <AK/NonnullRefPtr.h>
-#include <AK/Vector.h>
 
 namespace AK {
 
 template<typename T, int inline_capacity = 0>
-class NonnullRefPtrVector : public Vector<NonnullRefPtr<T>, inline_capacity> {
-    typedef Vector<NonnullRefPtr<T>, inline_capacity> Base;
-
-public:
-    NonnullRefPtrVector()
-    {
-    }
-
-    NonnullRefPtrVector(Vector<NonnullRefPtr<T>>&& other)
-        : Base(static_cast<Base&&>(other))
-    {
-    }
-    NonnullRefPtrVector(const Vector<NonnullRefPtr<T>>& other)
-        : Base(static_cast<const Base&>(other))
-    {
-    }
-
-    using Base::size;
-
-    using Iterator = VectorIterator<NonnullRefPtrVector, T>;
-    Iterator begin() { return Iterator(*this, 0); }
-    Iterator end() { return Iterator(*this, size()); }
-
-    using ConstIterator = VectorIterator<const NonnullRefPtrVector, const T>;
-    ConstIterator begin() const { return ConstIterator(*this, 0); }
-    ConstIterator end() const { return ConstIterator(*this, size()); }
-
-    T& at(int index) { return *Base::at(index); }
-    const T& at(int index) const { return *Base::at(index); }
-    T& operator[](int index) { return at(index); }
-    const T& operator[](int index) const { return at(index); }
-    T& first() { return at(0); }
-    const T& first() const { return at(0); }
-    T& last() { return at(size() - 1); }
-    const T& last() const { return at(size() - 1); }
-
-private:
-    // NOTE: You can't use resize() on a NonnullRefPtrVector since making the vector
-    //       bigger would require being able to default-construct NonnullRefPtrs.
-    //       Instead, use shrink(new_size).
-    void resize(int) = delete;
+class NonnullRefPtrVector : public NonnullPtrVector<NonnullRefPtr<T>, T, inline_capacity>
+{
 };
 
 }