Collections.h

// Plik utworzony przez Piotra Chudzińskiego w dniu 15.04.2025
#pragma once
 
#include <foundation/DataTypes.h>
#include <foundation/Macro.h>
#include <algorithm>
#include <vector>

template<typename T>
concept Integral = std::is_integral_v<T>;

template<auto Nullable>
class PairedVector
{
public:
    template<typename K, typename V>
    FORCE_INLINE static void RemoveByKey(std::vector<std::pair<K, V>> &vector, const K &key)
    {
        std::erase_if(vector, [&key](const std::pair<K, V> &pair) { return pair.first == key; });
    }

    template<typename K, typename V>
    FORCE_INLINE static typename std::vector<std::pair<K, V>>::iterator
    GetIteratorByKey(std::vector<std::pair<K, V>> &vector, const K &key)
    {
        return std::find_if(vector.begin(), vector.end(),
                            [&key](const std::pair<K, V> &pair) { return pair.first == key; });
    }

    template<typename K, typename V>
    FORCE_INLINE static V GetByKey(std::vector<std::pair<K, V>> &vector, const K &key)
    {
        auto iterator = GetIteratorByKey(vector, key);
 
        if (iterator == vector.end())
            return Nullable;
 
        return iterator->second;
    }

    template<typename K, typename V>
    FORCE_INLINE static bool MoveToLastIndex(std::vector<std::pair<K, V>> &vector, const K &key)
    {
        auto iterator = GetIteratorByKey(vector, key);
 
        if (iterator == vector.end())
            return false;
 
 
        std::pair<K, V> element = *iterator;
        vector.erase(iterator);
        vector.push_back(element);
        return true;
    }
};

class Vector
{
public:
    template<typename T>
    FORCE_INLINE static int32 IndexOf(const std::vector<T> &vector, const T &element)
    {
        auto iterator = std::find(vector.begin(), vector.end(), element);
        if (iterator == vector.end())
            return -1;
 
        return static_cast<int32>(iterator - vector.begin());
    }

    template<Integral R = int64, typename T>
    FORCE_INLINE static R Size(const std::vector<T> &vector)
    {
        return static_cast<R>(vector.size());
    }

    template<typename T>
    FORCE_INLINE static bool Remove(std::vector<T> &vector, const T &element)
    {
        auto indexOf = IndexOf(vector, element);
        if (indexOf < 0)
            return false;
 
        vector.erase(vector.begin() + indexOf);
        return true;
    }

    template<typename T>
    FORCE_INLINE static bool Contains(const std::vector<T> &cards, const T &element)
    {
        return std::ranges::find(cards, element) != std::ranges::end(cards);
    }
};