hash_array.h

Go to the documentation of this file.

#ifndef KOUTIL_CONTAINER_HASH_ARRAY_H
#define KOUTIL_CONTAINER_HASH_ARRAY_H
 
#include "template_hash_array.h"
#include <cassert>
#include <concepts>
#include <cstddef>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace koutil::container {
 
template <typename T, typename Key>
concept is_hash = requires(T hash, const Key& key) {
    requires std::is_trivially_constructible_v<T>;
 
    { hash(key) } -> std::same_as<std::size_t>;
};
 
template <typename T, typename Key, typename KeyID>
concept is_key_adapter = requires(const Key& key, T adapter, const KeyID& index) {
    requires std::move_constructible<T> && std::is_trivially_copy_constructible_v<T>;
    { adapter.eql(key, index) } -> std::same_as<bool>;
};
 
template <
    typename Key,
    typename KeyID,
    is_key_adapter<Key, KeyID> KeyAdapter,
    is_hash<Key> Hash              = std::hash<Key>,
    is_bucket<KeyID> Bucket        = std::vector<std::pair<std::size_t, KeyID>>,
    is_allocator<Bucket> Allocator = std::allocator<Bucket>>
class hash_array {
private:
    using key_t       = Key;
    using key_id_t    = KeyID;
    using value_t     = std::size_t;
    using bucket_t    = Bucket;
    using hash_t      = Hash;
    using bucket_iter = bucket_t::iterator;
    using adapter_t   = KeyAdapter;
    using allocator_t = Allocator;
 
    struct AdapterWrapper {
        template <bool> bool eql(const key_t& key, const key_id_t& id) const { return adapter.eql(key, id); }
 
        adapter_t adapter;
    };
 
    struct HashWrapper {
        template <bool> std::size_t hash(const key_t& key) { return hasher(key); }
 
        hash_t hasher;
    };
 
    constexpr static bool comptime_value = true;
 
    using template_hash_array_t
        = template_hash_array<key_t, key_id_t, bool, AdapterWrapper, HashWrapper, bucket_t, allocator_t>;
 
public:
    using iterator_t       = template_hash_array_t::iterator_t;
    using const_iterator_t = template_hash_array_t::const_iterator_t;
 
    hash_array() = default;
 
    hash_array(std::size_t bucket_count)
        : m_storage(bucket_count) { }
 
    hash_array(const hash_array& other)
        : m_storage(other.m_storage) { }
 
    hash_array(hash_array&& other)
        : m_storage(std::move(other.m_storage))
 
    { }
 
    ~hash_array() = default;
 
    hash_array& operator=(const hash_array& other) = default;
    hash_array& operator=(hash_array&& other) = default;
 
    [[nodiscard]] bool empty() const { return m_storage.empty(); }
 
    [[nodiscard]] std::size_t size() const { return m_storage.size(); }
 
    [[nodiscard]] std::size_t bucket_count() const { return m_storage.bucket_count(); }
 
    [[nodiscard]] float max_load_factor() const { return m_storage.max_load_factor(); }
 
    void set_max_load_factor(float factor) {
        assert(factor > 0);
        m_storage.set_max_load_factor(factor);
    }
 
    void clear() { m_storage.clear(); }
 
    bool try_insert(const key_t& key, const key_id_t& key_id, adapter_t adapter) {
 
        return m_storage.template try_insert<comptime_value>(key, key_id, AdapterWrapper { adapter });
    }
 
    bool try_set(const key_t& key, const key_id_t& new_key_id, adapter_t adapter) {
        return m_storage.template try_set<comptime_value>(key, new_key_id, AdapterWrapper { adapter });
    }
 
    void erase(const key_t& key, adapter_t adapter) {
        m_storage.template erase<comptime_value>(key, AdapterWrapper { adapter });
    }
 
    iterator_t find(const key_t& key, adapter_t adapter) {
        return m_storage.template find<comptime_value>(key, AdapterWrapper { adapter });
    }
 
    const_iterator_t find(const key_t& key, adapter_t adapter) const {
        return m_storage.template find<comptime_value>(key, AdapterWrapper { adapter });
    }
 
    iterator_t begin() { return m_storage.begin(); }
 
    iterator_t end() { return m_storage.end(); }
 
    const_iterator_t begin() const { return m_storage.begin(); }
 
    const_iterator_t end() const { return m_storage.end(); }
 
    const_iterator_t cbegin() const { return m_storage.cbegin(); }
 
    const_iterator_t cend() const { return m_storage.cend(); }
 
private:
    template_hash_array_t m_storage;
};
}
 
#endif