Container.hpp

Go to the documentation of this file.

#pragma once
#include <array>
#include <bitset>
#include <list>
#include <map>
#include <numeric>
#include <optional>
#include <queue>
#include <set>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include "Allocator.hpp"
namespace Foundation::Core {
 
    /* -- STL Value types -- */
 
    template<typename T>
    using Optional = std::optional<T>;
 
    template <typename First, typename Second>
    using Pair = std::pair<First, Second>;
 
    template<typename ...Args>
    using Tuple = std::tuple<Args...>;
 
    template<typename T, size_t Size>
    using Array = std::array<T, Size>;
 
    template<size_t Size>
    using Bitset = std::bitset<Size>;
 
    using StringView = std::basic_string_view<char>;
 
    template<typename T>
    class Span : public std::span<T> {
    public:
        using std::span<T>::span;
        Span() = default;
        template<typename U> requires
            (sizeof(std::remove_reference<T>) == sizeof(std::remove_reference<U>) &&
            std::is_convertible_v<U*, T*>)
        Span(U* data, size_t size) : std::span<T>(static_cast<T*>(data), size) {}
 
 
        template<typename U, size_t Size>
        Span(U(&array)[Size]) : Span(array, Size) {}
 
        template<typename U>
        requires requires (U a) { a.data(); a.size(); }
        Span(U& array) : Span(array.data(), array.size())
        {}
 
        template<typename U> requires std::is_convertible_v<U*, T*>
        Span(U& item) : Span(&item, 1) {}
 
        [[nodiscard]] Span<const char> AsBytes() const {
            return Span<const char>{ reinterpret_cast<const char*>(this->data()), this->size_bytes()  };
        }
    };
    template <typename T, typename ...Args>
    Span<T> ConstructSpan(Allocator* resource, size_t size, Args&& ...args) {
        T* data = static_cast<T*>(resource->Allocate(size * sizeof(T), alignof(T)));
        if constexpr (!std::is_trivially_constructible_v<T> || sizeof...(Args) > 0)
        {
            for (size_t i = 0; i < size; i++)
                std::construct_at(&data[i], std::forward<Args>(args)...);
        }
        return Span<T>(data, size);
    }
    template<typename T>
    void DestructSpan(Allocator* resource, Span<T> span) {
        if constexpr (!std::is_trivially_destructible_v<T>)
        {
            for (T& item : span)
                std::destroy_at(&item);
        }
        resource->Deallocate(span.data(), span.size() * sizeof(T));
    }
    /* -- STL Containers -- */
 
    using String = std::basic_string<char>;
    using StringAlloc = std::basic_string<char, std::char_traits<char>, StlAllocator<char>>;
 
    template<typename T>
    using Vector = std::vector<T, StlAllocator<T>>;
 
    template<typename T, typename Predicate = std::less<T>>
    using Set = std::set<T, Predicate, StlAllocator<T>>;
    template<typename K, typename V, typename Predicate = std::less<K>>
    using Map = std::map<K, V, Predicate, StlAllocator<Pair<const K, V>>>;
    template<typename T>
    using Deque = std::deque<T, StlAllocator<T>>;
    template<typename T>
    using List = std::list<T, StlAllocator<T>>;
    template<typename T, typename Container = Deque<T>>
    using Queue = std::queue<T, Container>;
    template<typename T, typename Predicate = std::less<T>, typename Container = Vector<T>>
    using PriorityQueue = std::priority_queue<T, Container, Predicate>;
}