Arbutils/src/Memory/__OptionalUniquePtrList.hpp

#ifndef ARBUTILS___OPTIONALOptionalUniquePtrList_HPP
#define ARBUTILS___OPTIONALOptionalUniquePtrList_HPP

#include <optional>
#include <vector>
#include "__OptionalBorrowedPtr.hpp"

namespace ArbUt {
    /// @brief Collection of pointers that is owned by the list. When the list exits scope, the destructor on all
    /// pointers will be called.
    template <class ValueT> class OptionalUniquePtrList {
    private:
        std::vector<ValueT * nullable> _vector;
        using iterator = typename std::vector<ValueT * nullable>::iterator;
        using const_iterator = typename std::vector<ValueT * nullable>::const_iterator;

    public:
        /// @brief The type of the value stored in the list.
        typedef ValueT* type;

        inline OptionalUniquePtrList() noexcept : _vector() {}
        /// @brief Initialises a OptionalUniquePtrList from a std::vector of raw pointers.
        /// @param vec A std::vector of raw pointers.
        inline OptionalUniquePtrList(const std::vector<ValueT*>& vec) noexcept : _vector(vec) {}
        /// @brief Initialises a OptionalUniquePtrList with a certain capacity reserved for use. This does not set
        /// immediate size.
        /// @param capacity The desired capacity.
        explicit inline OptionalUniquePtrList(size_t capacity) : _vector() { _vector.reserve(capacity); }
        /// @brief Initialises a OptionalUniquePtrList from a initialiser_list.
        /// @param l A initialiser_list
        inline OptionalUniquePtrList(const std::initializer_list<ValueT*>& l) noexcept : _vector(l) {}
        /// @brief Initialises a OptionalUniquePtrList from a raw pointer range.
        /// @param begin The raw pointer to the start of the list.
        /// @param end The raw pointer to the end of the list.
        inline OptionalUniquePtrList(ValueT* nullable const* non_null begin,
                                     ValueT* nullable const* non_null end) noexcept
            : _vector(begin, end) {}

        OptionalUniquePtrList(const OptionalUniquePtrList<ValueT>&) = delete;
        OptionalUniquePtrList<ValueT>& operator=(const OptionalUniquePtrList<ValueT>&) = delete;
        ~OptionalUniquePtrList() noexcept { Clear(); }

        /// @brief Clears the OptionalUniquePtrList, and run the destructor on all containing pointers.
        inline void Clear() noexcept {
            for (auto& i : _vector) {
                delete i;
            }
            _vector.clear();
        }

        /// @brief Borrow a pointer at a certain index.
        /// @param index The index to retrieve.
        /// @return A borrowed pointer reference to the containing raw pointer.
        inline OptionalBorrowedPtr<ValueT> At(size_t index) const {
#ifndef NO_ASSERT
            if (index >= _vector.size()) {
                std::stringstream ss;
                ss << "Index " << index << " is out of bounds for length: " << _vector.size();
                throw ArbUt::Exception(ss.str());
            }
#endif
            return _vector[index];
        }
        /// @brief Returns a raw pointer at an index, and releases ownership. Proper handling of the memory is assumed
        /// to be done by the taker.
        /// @param index The index to get the pointer from.
        /// @return A raw pointer.
        ValueT* nullable TakeOwnership(size_t index) {
            auto p = _vector[index];
            _vector[index] = nullptr;
            return p;
        }
        /// @brief Swaps two pointers at indices with each other.
        /// @param indexA The first index to swap from.
        /// @param indexB The second index to swap from
        void Swap(size_t indexA, size_t indexB) {
            auto temp = _vector[indexA];
            _vector[indexA] = _vector[indexB];
            _vector[indexB] = temp;
        }
        /// @brief Sets a pointer to a certain index. If an item already existed at that index, it's destructor will be
        /// called.
        /// @param index The index to set the pointer to.
        /// @param ptr The pointer to store.
        void Set(size_t index, ValueT* nullable ptr) {
            delete _vector[index];
            _vector[index] = ptr;
        }

        /// @brief Removes a pointer at a certain index. It's destructor will be called.
        /// @param index The index to remove.
        inline void Remove(size_t index) {
#ifndef NO_ASSERT
            if (index >= _vector.size()) {
                std::stringstream ss;
                ss << "Index " << index << " is out of bounds for length: " << _vector.size();
                throw ArbUt::Exception(ss.str());
            }
#endif
            delete _vector[index];
            _vector.erase(_vector.begin() + index);
        }

        /// @brief Check whether a pointer is contained in the list.
        /// @param value The value to check for.
        /// @return True if the list contains the pointer, false otherwise.
        inline bool Contains(const BorrowedPtr<ValueT>& value) const noexcept {
            return std::find(_vector.begin(), _vector.end(), value) != _vector.end();
        }

        /// @brief 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 std::optional<size_t> IndexOf(const BorrowedPtr<ValueT>& value) const noexcept {
            const auto& it = std::find(_vector.begin(), _vector.end(), value);
            if (it == _vector.end())
                return {};
            return std::distance(_vector.begin(), it);
        }

        /// @brief Append a pointer to the list.
        /// @param value The pointer to push to the list.
        inline void Append(ValueT* nullable value) { _vector.push_back(value); }
        /// @brief Borrow a pointer at a certain index.
        /// @param index The index to retrieve.
        /// @return A borrowed pointer reference to the containing raw pointer.
        inline OptionalBorrowedPtr<ValueT> operator[](size_t index) const { return At(index); }

        /// @brief Returns the number of pointers contained.
        /// @return The number of pointers contained.
        [[nodiscard]] inline size_t Count() const noexcept { return _vector.size(); }

        /// @brief returns an iterator to the beginning of the specified bucket
        iterator begin() noexcept { return _vector.begin(); }
        /// @brief returns an iterator to the beginning of the specified bucket
        iterator end() noexcept { return _vector.end(); }
        /// @brief returns an iterator to the end of the specified bucket
        const_iterator begin() const noexcept { return _vector.begin(); }
        /// @brief returns an iterator to the end of the specified bucket
        const_iterator end() const noexcept { return _vector.end(); }

        /// @brief Return a raw pointer to the beginning of the list.
        /// @return A raw array pointer to the beginning of the list.
        ValueT* nullable const* nullable RawData() const noexcept { return _vector.data(); }

        /// @brief Returns a std::vector representation of the current list.
        /// @return A std::vector representation of the current list.
        const std::vector<ValueT*>& GetStdList() const noexcept { return _vector; }
        /// @brief Returns a std::vector representation of the current list.
        /// @return A std::vector representation of the current list.
        std::vector<ValueT*>& GetStdList() noexcept { return _vector; }

        /// @brief Returns a raw pointer to the current list.
        /// @return A raw pointer to the current list.
        inline const OptionalUniquePtrList<ValueT>* non_null GetListPointer() const { return this; }
        /// @brief Returns a raw pointer to the current list.
        /// @return A raw pointer to the current list.
        inline OptionalUniquePtrList<ValueT>* non_null GetListPointer() { return this; }
    };
}

#endif // ARBUTILS___OPTIONALOptionalUniquePtrList_HPP