list.hpp

Go to the documentation of this file.

#pragma once

#include <functional>
#include <vector>

#include "Mountain/core.hpp"


namespace Mountain
{
    template <typename T>
    class List
    {
    public:
        using Iterator = typename std::vector<T>::iterator;
        using ConstIterator = typename std::vector<T>::const_iterator;
        using ReverseIterator = typename std::vector<T>::reverse_iterator;
        using ConstReverseIterator = typename std::vector<T>::const_reverse_iterator;

        using Type = T;

        List() = default;

        explicit List(size_t size);

        explicit List(size_t size, const T& defaultValue);

        explicit List(size_t size, const T* values);

        template <size_t Size>
        explicit List(const std::array<T, Size>& array);

        explicit List(const std::vector<T>& vector);

        explicit List(std::vector<T>&& vector);

        explicit List(Iterator b, Iterator e);

        List(const std::initializer_list<T>& values);

        ~List() = default;

        DEFAULT_COPY_MOVE_OPERATIONS(List)

        
        void Resize(size_t size);

        void Clear();

        [[nodiscard]]
        bool_t Empty() const;

        T& Add();

        void Add(const T& element);

        void Add(T&& element);

        void AddRange(const T* data, size_t count);

        void AddRange(const std::initializer_list<T>& values);

        void Fill(const T& value);

        void Fill(T&& value);

        template <class... Args>
        void Emplace(Args&&... args);

        void PopBack();

        void Insert(size_t index);

        void Insert(const T& element, size_t index);

        void Insert(T&& element, size_t index);

        void Remove(const T& element);

        void RemoveAt(size_t index);

        void RemoveAt(ConstIterator iterator);

        void RemoveRange(size_t start, size_t end);

        [[nodiscard]]
        bool_t Contains(const T& element) const;

        void Iterate(const std::function<void(T*)>& lambda);

        void Iterate(const std::function<void(const T*)>& lambda) const;

        [[nodiscard]]
        bool_t Exists(const std::function<bool_t(const T*)>& lambda) const;

        [[nodiscard]]
        T* Find(const std::function<bool_t(const T*)>& lambda);

        [[nodiscard]]
        const T* Find(const std::function<bool_t(const T*)>& lambda) const;

        [[nodiscard]]
        List<T*> FindAll(const std::function<bool_t(const T*)>& lambda);

        [[nodiscard]]
        List<const T*> FindAll(const std::function<bool_t(const T*)>& lambda) const;

        [[nodiscard]]
        size_t FindPosition(const std::function<bool_t(const T*)>& lambda) const;

        [[nodiscard]]
        T* Find(const std::function<bool_t(const T*, size_t)>& lambda);

        void Sort(std::function<bool_t(const T& left, const T& right)> predicate = std::less());

        [[nodiscard]]
        T* GetData();

        [[nodiscard]]
        const T* GetData() const;

        [[nodiscard]]
        size_t GetSize() const;

        [[nodiscard]]
        size_t GetCapacity() const;

        [[nodiscard]]
        typename std::vector<T>::reference operator[](size_t index);

        [[nodiscard]]
        typename std::vector<T>::const_reference operator[](size_t index) const;

        [[nodiscard]]
        const T& Front() const;

        [[nodiscard]]
        T& Front();

        [[nodiscard]]
        const T& Back() const;

        [[nodiscard]]
        T& Back();

        [[nodiscard]]
        Iterator Begin();

        [[nodiscard]]
        Iterator End();

        [[nodiscard]]
        ConstIterator CBegin() const;

        [[nodiscard]]
        ConstIterator CEnd() const;

        [[nodiscard]]
        ReverseIterator RBegin();

        [[nodiscard]]
        ReverseIterator REnd();

        [[nodiscard]]
        ConstReverseIterator CrBegin() const;

        [[nodiscard]]
        ConstReverseIterator CrEnd() const;

        [[nodiscard]]
        Iterator begin();

        [[nodiscard]]
        ConstIterator begin() const;

        [[nodiscard]]
        Iterator end();

        [[nodiscard]]
        ConstIterator end() const;

    private:
        std::vector<T> m_Vector;
    };
}

#include "Mountain/utils/list.inl"