Arbutils/src/Memory/UniquePtrList.hpp

#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;
        using const_iterator = typename std::vector<ValueT*>::const_iterator;

    public:
        inline UniquePtrList() : _vector() {}
        inline UniquePtrList(std::vector<ValueT*> vec) : _vector(vec) {}
        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) const {
#ifndef NO_ASSERT
            if (index >= _vector.size()) {
                std::stringstream ss;
                ss << "Index " << index << " is out of bounds.";
                throw std::logic_error(ss.str());
            }
#endif
            return _vector[index];
        }

        inline void Remove(size_t index) {
#ifndef NO_ASSERT
            if (index >= _vector.size()) {
                std::stringstream ss;
                ss << "Index " << index << " is out of bounds.";
                throw std::logic_error(ss.str());
            }
#endif
            delete _vector[index];
            _vector.erase(_vector.begin() + 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) const { return At(index); }

        inline size_t Count() const { return _vector.size(); }

        iterator begin() { return _vector.begin(); }
        iterator end() { return _vector.end(); }
        const_iterator begin() const { return _vector.begin(); }
        const_iterator end() const { 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