Arbutils/src/Collections/List.hpp

#ifndef ARBUTILS_LIST_HPP
#define ARBUTILS_LIST_HPP
#include <sstream>
#include <stdexcept>
#include <vector>
#include <algorithm>

namespace Arbutils::Collections {
    template <class ValueT> class List {
    private:
        std::vector<ValueT> _vector;
        using iterator = typename std::vector<ValueT>::iterator;

    public:
        List() : _vector() {}
        explicit List(size_t capacity) : _vector(capacity) {}
        List(const std::initializer_list<ValueT>& l) : _vector(l) {}

        inline void Clear(){
            _vector.clear();
        }

        inline const 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.at(index);
        }
        inline ValueT& At(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
            return _vector.at(index);
        }

        inline bool Contains(ValueT value){
            return std::find(_vector.begin(), _vector.end(), value) != _vector.end();
        }

        inline void Append(ValueT value) { _vector.push_back(value); }

        inline void Insert(size_t index, ValueT value) { _vector.insert(index, value); }

        inline ValueT& operator[](size_t index) { return At(index); }
        inline const ValueT& operator[](size_t index) const { return At(index); }

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


        iterator begin() { return _vector.begin(); }
        iterator begin() const { return _vector.begin(); }

        iterator end() { return _vector.end(); }
        iterator end() const { return _vector.end(); }
    };
}

#endif // ARBUTILS_LIST_HPP