Hasher.h

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2025 nfx
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

 
#pragma once
 
#include <array>
#include <cstdint>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
#include <tuple>
#include <variant>
#include <vector>
 
#include "Concepts.h"
 
#include "Constants.h"
 
namespace nfx::hashing
{
    //=====================================================================
    // Type trait helpers for SFINAE
    //=====================================================================
 
    template <typename T>
    struct is_std_pair : std::false_type
    {
    };
 
    template <typename T1, typename T2>
    struct is_std_pair<std::pair<T1, T2>> : std::true_type
    {
    };
 
    template <typename T>
    struct is_std_tuple : std::false_type
    {
    };
 
    template <typename... Ts>
    struct is_std_tuple<std::tuple<Ts...>> : std::true_type
    {
    };
 
    template <typename T>
    struct is_std_array : std::false_type
    {
    };
 
    template <typename T, std::size_t N>
    struct is_std_array<std::array<T, N>> : std::true_type
    {
    };
 
    template <typename T>
    struct is_std_vector : std::false_type
    {
    };
 
    template <typename T>
    struct is_std_vector<std::vector<T>> : std::true_type
    {
    };
 
    template <typename T>
    struct is_std_span : std::false_type
    {
    };
 
    template <typename T, std::size_t Extent>
    struct is_std_span<std::span<T, Extent>> : std::true_type
    {
    };
 
    template <typename T>
    struct is_std_optional : std::false_type
    {
    };
 
    template <typename T>
    struct is_std_optional<std::optional<T>> : std::true_type
    {
    };
 
    template <typename T>
    struct is_std_variant : std::false_type
    {
    };
 
    template <typename... Ts>
    struct is_std_variant<std::variant<Ts...>> : std::true_type
    {
    };
 
    //=====================================================================
    // General-purpose STL-compatible hash functor
    //=====================================================================

    template <Hash32or64 HashType = uint32_t, HashType Seed = ( sizeof( HashType ) == 4 ? constants::FNV_OFFSET_BASIS_32 : constants::FNV_OFFSET_BASIS_64 )>
    struct Hasher final
    {
        //----------------------------------------------
        // Transparent lookup support
        //----------------------------------------------

        using is_transparent = void;
 
        //----------------------------------------------
        // String type overloads
        //----------------------------------------------

        [[nodiscard]] inline HashType operator()( std::string_view key ) const noexcept;

        [[nodiscard]] inline HashType operator()( const std::string& key ) const noexcept;

        [[nodiscard]] inline HashType operator()( const char* key ) const noexcept;
 
        //----------------------------------------------
        // Integer type overloads
        //----------------------------------------------

        template <typename TKey>
        [[nodiscard]] inline std::enable_if_t<std::is_integral_v<TKey>, HashType> operator()( const TKey& key ) const noexcept;
 
        //----------------------------------------------
        // Floating-point type overloads
        //----------------------------------------------

        template <typename T>
        [[nodiscard]] inline std::enable_if_t<std::is_floating_point_v<T>, HashType> operator()( T value ) const noexcept;
 
        //----------------------------------------------
        // Pointer type overloads
        //----------------------------------------------

        template <typename T>
        [[nodiscard]] inline std::enable_if_t<std::is_pointer_v<T> && !std::is_same_v<T, const char*> && !std::is_same_v<T, char*>, HashType> operator()( T ptr ) const noexcept;
 
        //----------------------------------------------
        // Enum type overloads
        //----------------------------------------------

        template <typename TKey>
        [[nodiscard]] inline std::enable_if_t<std::is_enum_v<TKey>, HashType> operator()( const TKey& key ) const noexcept;
 
        //----------------------------------------------
        // std::array type overloads
        //----------------------------------------------

        template <typename T, size_t N>
        [[nodiscard]] inline HashType operator()( const std::array<T, N>& arr ) const noexcept;
 
        //----------------------------------------------
        // std::optional type overloads
        //----------------------------------------------

        template <typename T>
        [[nodiscard]] inline HashType operator()( const std::optional<T>& opt ) const noexcept;
 
        //----------------------------------------------
        // std::pair type overloads
        //----------------------------------------------

        template <typename T1, typename T2>
        [[nodiscard]] inline HashType operator()( const std::pair<T1, T2>& p ) const noexcept;
 
        //----------------------------------------------
        // std::span type overloads
        //----------------------------------------------

        template <typename T, std::size_t Extent = std::dynamic_extent>
        [[nodiscard]] inline HashType operator()( std::span<T, Extent> sp ) const noexcept;
 
        //----------------------------------------------
        // std::tuple type overloads
        //----------------------------------------------

        template <typename... Ts>
        [[nodiscard]] inline HashType operator()( const std::tuple<Ts...>& t ) const noexcept;
 
        //----------------------------------------------
        // std::variant type overloads
        //----------------------------------------------

        template <typename... Ts>
        [[nodiscard]] inline HashType operator()( const std::variant<Ts...>& var ) const noexcept;
 
        //----------------------------------------------
        // std::vector type overloads
        //----------------------------------------------

        template <typename T>
        [[nodiscard]] inline HashType operator()( const std::vector<T>& vec ) const noexcept;
 
        //----------------------------------------------
        // Custom type fallback
        //----------------------------------------------

        template <typename TKey>
        [[nodiscard]] inline std::enable_if_t<!std::is_same_v<std::decay_t<TKey>, std::string_view> &&
                                                  !std::is_same_v<std::decay_t<TKey>, std::string> &&
                                                  !std::is_same_v<std::decay_t<TKey>, const char*> &&
                                                  !std::is_integral_v<TKey> &&
                                                  !std::is_floating_point_v<TKey> &&
                                                  !std::is_pointer_v<TKey> &&
                                                  !std::is_enum_v<TKey> &&
                                                  !is_std_array<TKey>::value &&
                                                  !is_std_optional<TKey>::value &&
                                                  !is_std_pair<TKey>::value &&
                                                  !is_std_span<TKey>::value &&
                                                  !is_std_tuple<TKey>::value &&
                                                  !is_std_variant<TKey>::value &&
                                                  !is_std_vector<TKey>::value,
            HashType>
        operator()( const TKey& key ) const noexcept;
    };
} // namespace nfx::hashing
 
#include "nfx/detail/hashing/Hasher.inl"