shard.hxx

Go to the documentation of this file.

 
#pragma once
#include <ice/base.hxx>
#include <ice/stringid.hxx>
 
namespace ice
{

    struct Shard;

    struct ShardID;

    struct ShardPayloadID;

    constexpr auto shardid(ice::Shard shard) noexcept -> ice::ShardID;

    constexpr auto shardid(std::string_view definition) noexcept -> ice::ShardID;

    constexpr auto shard(ice::ShardID id) noexcept -> ice::Shard;

    template<typename T>
    constexpr auto shard(std::string_view definition, T value);

    template<typename T>
    constexpr auto shard(ice::ShardID id, T payload) noexcept -> ice::Shard;

    template<typename T>
    constexpr bool shard_inspect(ice::Shard shard, T& payload) noexcept;

    template<typename T>
    constexpr auto shard_shatter(ice::Shard shard, T fallback) noexcept -> T;
 
    constexpr auto operator""_shard(ice::utf8 const* str, size_t size) noexcept -> ice::Shard;
    constexpr auto operator""_shardid(ice::utf8 const* str, size_t size) noexcept -> ice::ShardID;
 
 
    // IMPLEMENTATION DETAILS
 
    namespace detail
    {
 
        struct ShardName
        {
            using TypeTag = ice::StrongValue;
 
            ice::u32 value;
        };
 
        struct ShardPayload
        {
            using TypeTag = ice::StrongValue;
 
            ice::u64 value;
        };
 
    } // namespace detail
 
    struct ShardPayloadID
    {
        using TypeTag = ice::StrongValue;
 
        ice::u32 value;
    };
 
    struct ShardID
    {
        ice::detail::ShardName name;
        ice::ShardPayloadID payload;
    };
 
    struct Shard
    {
        ice::ShardID id;
        ice::detail::ShardPayload payload;
 
        constexpr operator ice::ShardID() const noexcept
        {
            return id;
        }
    };
 
    static constexpr ice::Shard Shard_Invalid{ .id = { }, .payload = { } };
 
    constexpr auto shard_payloadid(std::string_view sv)  noexcept -> ice::ShardPayloadID
    {
        namespace mm3 = ice::detail::murmur3_hash;
 
        mm3::mm3_x86_h32 const hash = mm3::cexpr_murmur3_x86_32(
            sv, ice::build::Constant_ShardPayloadID_DefaultSeed
        );
        return ice::ShardPayloadID{ hash.h[0] };
    }
 
    constexpr auto shardid(std::string_view sv) noexcept -> ice::ShardID
    {
        namespace mm3 = ice::detail::murmur3_hash;
 
        size_t const payload_id_pos = sv.find_first_of('`');
        if (payload_id_pos == std::string_view::npos)
        {
            mm3::mm3_x86_h32 const hash = mm3::cexpr_murmur3_x86_32(sv, ice::build::Constant_ShardName_DefaultSeed);
 
            return ice::ShardID{
                .name = { hash.h[0] },
                .payload = { }
            };
        }
        else
        {
            mm3::mm3_x86_h32 const name_hash = mm3::cexpr_murmur3_x86_32(
                sv.substr(0, payload_id_pos),
                ice::build::Constant_ShardName_DefaultSeed
            );
 
            return ice::ShardID{
                .name = { name_hash.h[0] },
                .payload = shard_payloadid(sv.substr(payload_id_pos + 1))
            };
        }
    }
 
    constexpr auto shardid(ice::Shard shard) noexcept -> ice::ShardID
    {
        return shard.id;
    }
 
    constexpr auto operator""_shardid(char const* str, size_t size) noexcept -> ice::ShardID
    {
        return ice::shardid({ str, size });
    }
 
    constexpr static ice::ShardPayloadID ShardPayloadID_NotSet = { 0 };
 
    template<typename T>
    concept AllowedAsShardPayloadID = std::is_trivially_copyable_v<T> && sizeof(T) <= 8;
 
    template<typename T> requires AllowedAsShardPayloadID<T>
    constexpr static ice::ShardPayloadID Constant_ShardPayloadID = ice::ShardPayloadID_NotSet;
 
    template<typename T>
    concept HasShardPayloadID = Constant_ShardPayloadID<T> != ice::ShardPayloadID_NotSet;
 
 
    namespace detail
    {
 
        template<typename T> requires HasShardPayloadID<T>
        constexpr auto shard_payload(T payload) noexcept -> ice::detail::ShardPayload
        {
            if constexpr (sizeof(T) == sizeof(ice::Shard::payload))
            {
                return std::bit_cast<ShardPayload>(payload);
            }
            else
            {
                struct PayloadBitCastHelper
                {
                    T value;
                    char bytes[sizeof(ice::Shard::payload) - sizeof(T)];
                } temp{ .value = payload, .bytes = { } };
 
                return std::bit_cast<ShardPayload>(temp);
            }
        }
 
        template<typename T> requires HasShardPayloadID<T>
        constexpr auto shard_value(ShardPayload payload) noexcept -> T
        {
            if constexpr (sizeof(T) == sizeof(ice::Shard::payload))
            {
                return std::bit_cast<T>(payload);
            }
            else
            {
                struct PayloadBitCastHelper
                {
                    T value;
                    char bytes[sizeof(ice::Shard::payload) - sizeof(T)];
                } temp{ std::bit_cast<PayloadBitCastHelper>(payload) };
 
                return temp.value;
            }
        }
 
    } // namespace detail
 
    // SHARD CREATION
 
    constexpr auto shard(ice::ShardID id) noexcept -> ice::Shard
    {
        return ice::Shard{ .id = id };
    }
 
    template<typename T> requires ice::HasShardPayloadID<T>
    constexpr auto shard(std::string_view definition, T value) noexcept -> ice::Shard
    {
        ice::Shard result{ };
        ice::ShardID const id = ice::shardid(definition);
 
        ICE_ASSERT_CORE(id.payload == ice::Constant_ShardPayloadID<T> || id.payload == ice::ShardPayloadID_NotSet);
        if (id.payload == ice::Constant_ShardPayloadID<T> || id.payload == ice::ShardPayloadID_NotSet)
        {
            result.id = id;
            result.id.payload = ice::Constant_ShardPayloadID<T>;
            result.payload = ice::detail::shard_payload(value);
        }
        return result;
    }
 
    template<typename T> requires ice::HasShardPayloadID<T>
    constexpr auto shard(ice::ShardID id, T value) noexcept -> ice::Shard
    {
        ice::Shard result{ };
 
        ICE_ASSERT_CORE(id.payload == ice::Constant_ShardPayloadID<T> || id.payload == ice::ShardPayloadID_NotSet);
        if (id.payload == ice::Constant_ShardPayloadID<T> || id.payload == ice::ShardPayloadID_NotSet)
        {
            result.id = id;
            result.id.payload = ice::Constant_ShardPayloadID<T>;
            result.payload = ice::detail::shard_payload(value);
        }
        return result;
    }
 
    constexpr auto operator""_shard(char const* str, size_t size) noexcept -> ice::Shard
    {
        return ice::shard(ice::shardid({ str, size }));
    }
 
    template<typename T> requires ice::HasShardPayloadID<T>
    constexpr auto operator|(ice::Shard shard, T payload) noexcept -> ice::Shard
    {
        return ice::shard(shard.id, payload);
    }
 
    template<typename T> requires ice::HasShardPayloadID<T>
    constexpr auto operator|(ice::ShardID shardid, T payload) noexcept -> ice::Shard
    {
        return ice::shard(shardid, payload);
    }
 
    constexpr auto operator==(ice::ShardID left, ice::ShardID right) noexcept -> bool
    {
        if (left.name == right.name)
        {
            return left.payload == ice::ShardPayloadID_NotSet
                || right.payload == ice::ShardPayloadID_NotSet
                || right.payload == left.payload;
        }
        return false;
    }
 
    constexpr auto operator==(ice::Shard left, ice::Shard right) noexcept -> bool
    {
        return left.id == right.id;
    }
 
    constexpr auto operator==(ice::Shard left, ice::ShardID right) noexcept -> bool
    {
        return left.id == right;
    }
 
    // SHARD INSPECTION
 
    template<typename T> requires ice::HasShardPayloadID<T>
    constexpr bool shard_inspect(ice::Shard shard, T& value) noexcept
    {
        if (ice::Constant_ShardPayloadID<T> == shard.id.payload)
        {
            value = ice::detail::shard_value<T>(shard.payload);
            return true;
        }
        return false;
    }
 
    template<typename T> requires ice::HasShardPayloadID<T>
    constexpr auto shard_shatter(ice::Shard shard, T fallback) noexcept -> T
    {
        if (ice::Constant_ShardPayloadID<T> == shard.id.payload)
        {
            return ice::detail::shard_value<T>(shard.payload);
        }
        return fallback;
    }
 
    // COMMON PAYLOAD TYPES
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<bool> = ice::shard_payloadid("bool");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<ice::i32> = ice::shard_payloadid("ice::i32");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<ice::u32> = ice::shard_payloadid("ice::u32");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<ice::f32> = ice::shard_payloadid("ice::f32");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<ice::i64> = ice::shard_payloadid("ice::i64");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<ice::u64> = ice::shard_payloadid("ice::u64");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<ice::f64> = ice::shard_payloadid("ice::f64");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<char const*> = ice::shard_payloadid("char const*");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<std::string_view const*> = ice::shard_payloadid("std::string_view const*");
 
    template<>
    constexpr inline ice::ShardPayloadID Constant_ShardPayloadID<ice::StringID_Hash> = ice::shard_payloadid("ice::StringID_Hash");
 
    template<>
    constexpr auto hash(ice::ShardID shardid) noexcept -> ice::u64
    {
        return ice::bit_cast<ice::u64>(shardid);
    }
 
    constexpr auto hash32(ice::ShardID shardid) noexcept -> ice::u32
    {
        return shardid.name.value ^ shardid.payload.value;
    }
 
    namespace _validate
    {
 
        static constexpr ice::Shard shard_without_payload = "test/shard"_shard;
        static constexpr ice::Shard shard_with_payload_u32 = "test/shard"_shard | ice::u32{ 42 };
        static constexpr ice::Shard shard_with_payload_i32 = "test/shard"_shard | ice::i32{ 42 };
 
        static constexpr ice::Shard shard2_without_payload = "test/shard2"_shard;
        static constexpr ice::Shard shard2_with_payload_u32 = "test/shard2"_shard | ice::u32{ 42 };
        static constexpr ice::Shard shard2_with_payload_i32 = "test/shard2"_shard | ice::i32{ 42 };
 
        static constexpr ice::ShardID shardid_test_1 = "test/shard`ice::u32"_shardid;
        static constexpr ice::ShardID shardid_test_1_from_shard = ice::shardid(shard_with_payload_u32);
 
        static_assert(shardid_test_1 == shardid_test_1_from_shard, "ShardID creation is not valid!");
 
        static_assert(shard_without_payload == shard_without_payload, "Assert: Shards are equal to themselfs.");
        static_assert(shard_with_payload_u32 == shard_with_payload_u32, "Assert: Shards are equal to themselfs.");
 
        static_assert(shard_without_payload == shard_with_payload_u32, "Assert: Shards without payload are equal to similar Shards with payload.");
        static_assert(shard_without_payload == shard_with_payload_i32, "Assert: Shards without payload are equal to similar Shards with payload.");
        static_assert(shard_with_payload_u32 == shard_without_payload, "Assert: Shards without payload are equal to similar Shards with payload.");
        static_assert(shard_with_payload_i32 == shard_without_payload, "Assert: Shards without payload are equal to similar Shards with payload.");
 
        static_assert(shard_with_payload_i32 != shard_with_payload_u32, "Assert: Shards with different payloads are not equal.");
        static_assert(shard_with_payload_u32 != shard_with_payload_i32, "Assert: Shards with different payloads are not equal.");
 
        static_assert(shard_without_payload != shard2_without_payload, "Assert: Different Shards are not equal.");
 
        static_assert(shard2_with_payload_u32 != shard_with_payload_u32, "Assert: Different Shards with same payloads are not equal.");
        static_assert(shard2_with_payload_i32 != shard_with_payload_i32, "Assert: Different Shards with same payloads are not equal.");
 
        static_assert(shard2_with_payload_u32 != shard_with_payload_i32, "Assert: Different Shards with different payloads are not equal.");
        static_assert(shard2_with_payload_i32 != shard_with_payload_u32, "Assert: Different Shards with different payloads are not equal.");
 
    } // namespace detail
 
 
} // namespace ice
 
template<>
constexpr auto ice::value_or_default<ice::ShardID, ice::ShardID>(
    ice::ShardID value,
    ice::ShardID default_value
) noexcept -> ice::ShardID
{
    return value != ice::Shard_Invalid.id ? value : default_value;
}