DiceHash.hpp

Go to the documentation of this file.

#ifndef DICE_HASH_DICEHASH_HPP
#define DICE_HASH_DICEHASH_HPP
 
#include "dice/hash/internal/Container_trait.hpp"
#include "dice/hash/internal/DiceHashPolicies.hpp"
#include <cstring>
#include <map>
#include <memory>
#include <set>
#include <span>
#include <string>
#include <string_view>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <variant>
#include <vector>
 
namespace dice::hash {
 
    template<Policies::HashPolicy Policy, typename T>
    struct dice_hash_overload {
        template<typename>
        struct AlwaysFalse : std::false_type {};
 
        static std::size_t dice_hash(T const &) noexcept {
            static_assert(AlwaysFalse<T>::value,
                          "The hash function is not defined for this type. You need to add an implementation yourself");
            return 0;
        }
    };
 
    template<Policies::HashPolicy Policy>
    class dice_hash_templates {
    private:
        template<typename Container>
        static std::size_t dice_hash_ordered_container(Container const &container) noexcept {
            typename Policy::HashState hash_state(container.size());
            std::size_t item_hash;
            for (const auto &item : container) {
                item_hash = dice_hash(item);
                hash_state.add(item_hash);
            }
            return hash_state.digest();
        }
 
        template<typename Container>
        static std::size_t dice_hash_unordered_container(Container const &container) noexcept {
            std::size_t h{};
            for (auto const &it : container) {
                h = Policy::hash_invertible_combine({h, dice_hash(it)});
            }
            return h;
        }
 
        template<typename... TupleArgs, std::size_t... ids>
        static std::size_t dice_hash_tuple(std::tuple<TupleArgs...> const &tuple, std::index_sequence<ids...> const &) {
            return Policy::hash_combine({dice_hash(std::get<ids>(tuple))...});
        }
 
        template<typename T>
        static constexpr bool is_fundamental = std::is_fundamental_v<T> || std::is_same_v<std::remove_cv_t<T>, std::byte>;
 
    public:
        template<typename T>
        static std::size_t dice_hash(T const &t) noexcept {
            return dice_hash_overload<Policy, T>::dice_hash(t);
        }
 
        template<typename T>
        requires is_fundamental<std::decay_t<T>> static std::size_t dice_hash(T const &fundamental) noexcept {
            return Policy::hash_fundamental(fundamental);
        }
 
        template<typename CharT>
        static std::size_t dice_hash(std::basic_string<CharT> const &str) noexcept {
            return Policy::hash_bytes(str.data(), sizeof(CharT) * str.size());
        }
 
        template<typename CharT>
        static std::size_t dice_hash(std::basic_string_view<CharT> const &sv) noexcept {
            return Policy::hash_bytes(sv.data(), sizeof(CharT) * sv.size());
        }
 
        template<typename T>
        static std::size_t dice_hash(T *ptr) noexcept {
            return Policy::hash_fundamental(ptr);
        }
 
        template<typename T>
        static std::size_t dice_hash(std::unique_ptr<T> const &ptr) noexcept {
            return dice_hash(ptr.get());
        }
 
        template<typename T>
        static std::size_t dice_hash(std::shared_ptr<T> const &ptr) noexcept {
            return dice_hash(ptr.get());
        }
 
        template<typename T, std::size_t N>
        static std::size_t dice_hash(std::array<T, N> const &arr) noexcept {
            if constexpr (is_fundamental<T>) {
                return Policy::hash_bytes(arr.data(), sizeof(T) * N);
            } else {
                return dice_hash_ordered_container(arr);
            }
        }
 
        template<typename T>
        static std::size_t dice_hash(std::vector<T> const &vec) noexcept {
            if constexpr (is_fundamental<T>) {
                static_assert(!std::is_same_v<std::decay_t<T>, bool>,
                              "vector of booleans has a special implementation which results in errors!");
                return Policy::hash_bytes(vec.data(), sizeof(T) * vec.size());
            } else {
                return dice_hash_ordered_container(vec);
            }
        }
 
        template<typename T, std::size_t Extent>
        static std::size_t dice_hash(std::span<T, Extent> const &span) noexcept {
            if constexpr (is_fundamental<T>) {
                return Policy::hash_bytes(span.data(), span.size_bytes());
            } else {
                return dice_hash_ordered_container(span);
            }
        }
 
        template<typename... TupleArgs>
        static std::size_t dice_hash(std::tuple<TupleArgs...> const &tpl) noexcept {
            return dice_hash_tuple(tpl, std::make_index_sequence<sizeof...(TupleArgs)>());
        }
 
        template<typename T, typename V>
        static std::size_t dice_hash(std::pair<T, V> const &p) noexcept {
            return Policy::hash_combine({dice_hash(p.first), dice_hash(p.second)});
        }
 
        static std::size_t dice_hash(std::monostate const &) noexcept {
            return Policy::ErrorValue;
        }
 
        template<typename... VariantArgs>
        static std::size_t dice_hash(std::variant<VariantArgs...> const &var) noexcept {
            try {
                return std::visit([]<typename T>(T &&arg) { return dice_hash(std::forward<T>(arg)); }, var);
            } catch (std::bad_variant_access const &) {
                return Policy::ErrorValue;
            }
        }
 
        template<typename T>
        requires is_ordered_container_v<T> static std::size_t dice_hash(T const &container) noexcept {
            return dice_hash_ordered_container(container);
        }
 
        template<typename T>
        requires is_unordered_container_v<T> static std::size_t dice_hash(T const &container) noexcept {
            return dice_hash_unordered_container(container);
        }
    };
 
    template<typename T, Policies::HashPolicy Policy = Policies::Martinus>
    struct DiceHash : private Policy {
        using Policy::hash_combine;
 
        using Policy::hash_invertible_combine;
 
        std::size_t operator()(T const &t) const noexcept {
            return dice_hash_templates<Policy>::dice_hash(t);
        }
 
        [[nodiscard]] static constexpr bool is_faulty(std::size_t to_check) noexcept {
            return to_check == Policy::ErrorValue;
        }
    };
 
    template <typename T>
    using DiceHashMartinus = DiceHash<T, Policies::Martinus>;
#ifdef __x86_64__
    template <typename T>
    using DiceHashxxh3 = DiceHash<T, Policies::xxh3>;
#endif
    template <typename T>
    using DiceHashwyhash = DiceHash<T, Policies::wyhash>;
}// namespace dice::hash
#endif//DICE_HASH_DICEHASH_HPP