Helper collection class that functions as list of unique pointers.

src/Memory/UniquePtrList.hpp

@@ -0,0 +1,73 @@
+#ifndef ARBUTILS_UNIQUEPTRLIST_HPP
+#define ARBUTILS_UNIQUEPTRLIST_HPP
+
+#include <algorithm>
+#include <sstream>
+#include <stdexcept>
+#include <vector>
+#include "BorrowedPtr.hpp"
+
+namespace ArbUt {
+    template <class ValueT> class UniquePtrList {
+    private:
+        std::vector<ValueT*> _vector;
+        using iterator = typename std::vector<ValueT*>::iterator;
+
+    public:
+        inline UniquePtrList() : _vector() {}
+        explicit inline UniquePtrList(size_t capacity) : _vector() { _vector.reserve(capacity); }
+        inline UniquePtrList(const std::initializer_list<ValueT*>& l) : _vector(l) {}
+        inline UniquePtrList(ValueT* const* begin, ValueT* const* end) : _vector(begin, end) {}
+
+        UniquePtrList(const UniquePtrList<ValueT>&) = delete;
+        UniquePtrList<ValueT>& operator=(const UniquePtrList<ValueT>&) = delete;
+        ~UniquePtrList() { Clear(); }
+
+        inline void Clear() {
+            for (auto& i : _vector) {
+                delete i;
+            }
+        }
+
+        inline BorrowedPtr<ValueT> At(size_t index) {
+#ifndef NO_ASSERT
+            if (index >= _vector.size() || index < 0) {
+                std::stringstream ss;
+                ss << "Index " << index << " is out of bounds.";
+                throw std::logic_error(ss.str());
+            }
+#endif
+            return _vector[index];
+        }
+
+        inline bool Contains(const BorrowedPtr<ValueT>& value) const {
+            return std::find(_vector.begin(), _vector.end(), value) != _vector.end();
+        }
+
+        /// Find the index of the first occurrence of a value in the list, return -1 if none is found.
+        /// \param value The value we want the index for.
+        /// \return The index of the first occurrence of the value in the list, or -1 if none is found.
+        inline size_t IndexOf(const BorrowedPtr<ValueT>& value) const {
+            const auto& it = std::find(_vector.begin(), _vector.end(), value);
+            if (it == _vector.end())
+                return -1;
+            return std::distance(_vector.begin(), it);
+        }
+
+        inline void Append(ValueT* value) { _vector.push_back(value); }
+        inline BorrowedPtr<ValueT> operator[](size_t index) { return At(index); }
+
+        inline size_t Count() const { return _vector.size(); }
+
+        iterator begin() { return _vector.begin(); }
+        iterator end() { return _vector.end(); }
+
+        ValueT* const* RawData() const { return _vector.data(); }
+
+        const std::vector<ValueT*>& GetStdList() const { return _vector; }
+        std::vector<ValueT*>& GetStdList() { return _vector; }
+
+    };
+}
+
+#endif // ARBUTILS_UNIQUEPTRLIST_HPP