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 <ranges>
#include <algorithm>
 
#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> using Span = std::span<T>;
 
    template<typename T> Span<const char> AsBytes(Span<T> data)
    {
        return { reinterpret_cast<const char*>(data.data()), data.size_bytes() };
    }
    template <typename T> Span<const T> AsSpan(T const& data) requires std::is_trivially_copyable_v<T>
    {
        return { &data, 1 };
    }
    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 T, typename Predicate = std::less<T>>
    using MultiSet = std::multiset<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 K, typename V, typename Predicate = std::less<K>>
    using MultiMap = std::multimap<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>;
 
    namespace Ranges
    {
        using namespace std::ranges;
        template <typename Range>
        struct ContainedBy
        {
            Range const& range;
            ContainedBy(Range const& range) : range(range) {}
            constexpr bool operator()(auto&& value) const
            {
                return std::ranges::find(range, value) != std::ranges::end(range);
            }
        };
        template <typename T>
        constexpr Optional<range_value_t<T>> FirstOf(T&& range)
        {
            if (auto it = std::ranges::begin(range); it != std::ranges::end(range))
                return *it;
            return {};
        }
    } // namespace Ranges
    namespace Views
    {
        using namespace std::views;
    } // namespace Views
}