id.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <commons/config.hpp>
#include <commons/types.hpp>
 
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <format>
#include <functional>
#include <ostream>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
 
#if COMMONS_WITH_ULID
#include <ulid/ulid.h>
#endif
 
namespace comms {
 
// -- repr gating -------------------------------------------------------------
 
// The trait names follow the STL's `std::is_*` lower_case convention so they
// read naturally alongside the standard type traits — overriding the project's
// CamelCase rule for these specific predicates.
// NOLINTBEGIN(readability-identifier-naming)
 
template <class T>
struct is_allowed_id_repr : std::false_type {};
 
template <>
struct is_allowed_id_repr<std::uint8_t> : std::true_type {};
template <>
struct is_allowed_id_repr<std::uint16_t> : std::true_type {};
template <>
struct is_allowed_id_repr<std::uint32_t> : std::true_type {};
template <>
struct is_allowed_id_repr<std::uint64_t> : std::true_type {};
template <>
struct is_allowed_id_repr<std::string> : std::true_type {};
 
#if COMMONS_WITH_ULID
template <>
struct is_allowed_id_repr<::ulid::Ulid> : std::true_type {};
#endif
 
// NOLINTEND(readability-identifier-naming)
 
template <class T>
concept AllowedIdRepr = is_allowed_id_repr<std::remove_cvref_t<T>>::value;
 
template <class Tag>
concept NamedIdTag = requires {
    { Tag::name } -> std::convertible_to<std::string_view>;
};
 
namespace detail {
 
template <class T>
concept StdToStringable = requires(const T& v) {
    { std::to_string(v) } -> std::convertible_to<std::string>;
};
 
}  // namespace detail
 
// -- the type ----------------------------------------------------------------
 
template <class Tag, AllowedIdRepr Repr>
class Id {
public:
    using tag_type = Tag;
    using repr_type = Repr;
 
    Id()
        requires(!std::default_initializable<Repr>)
    = delete;
    Id()
        requires std::default_initializable<Repr>
    = default;
 
    template <class U>
        requires std::constructible_from<Repr, U&&> && (!std::is_same_v<std::remove_cvref_t<U>, Id>)
    explicit Id(U&& u) : value_(std::forward<U>(u)) {}
 
    explicit Id(std::string_view sv)
        requires std::is_same_v<Repr, std::string>
        : value_(sv) {}
 
    [[nodiscard]] const Repr& value() const& noexcept {
        return value_;
    }
    [[nodiscard]] Repr& value() & noexcept {
        return value_;
    }
    [[nodiscard]] Repr&& value() && noexcept {
        return std::move(value_);
    }
 
    [[nodiscard]] auto operator<=>(const Id&) const = default;
    [[nodiscard]] bool operator==(const Id&) const = default;
 
private:
    Repr value_{};
};
 
// -- aliases -----------------------------------------------------------------
 
template <class Tag>
using Uint8Id = Id<Tag, std::uint8_t>;
template <class Tag>
using Uint16Id = Id<Tag, std::uint16_t>;
template <class Tag>
using Uint32Id = Id<Tag, std::uint32_t>;
template <class Tag>
using Uint64Id = Id<Tag, std::uint64_t>;
 
template <class Tag>
using StringId = Id<Tag, std::string>;
 
#if COMMONS_WITH_ULID
template <class Tag>
using UlidId = Id<Tag, ::ulid::Ulid>;
#endif
 
// -- reflection --------------------------------------------------------------
// As with `is_allowed_id_repr`, these traits keep the STL `std::is_*` spelling.
// NOLINTBEGIN(readability-identifier-naming)
 
template <class T>
struct is_id : std::false_type {};
 
template <class Tag, class Repr>
struct is_id<Id<Tag, Repr>> : std::true_type {};
 
template <class T>
inline constexpr bool is_id_v = is_id<std::remove_cvref_t<T>>::value;
 
// NOLINTEND(readability-identifier-naming)
 
template <class T>
concept IdType = is_id_v<T>;
 
// -- free helpers ------------------------------------------------------------
 
template <class Tag, class Repr>
[[nodiscard]] const Repr& to_underlying(const Id<Tag, Repr>& id) noexcept {
    return id.value();
}
 
template <class Tag, class Repr>
    requires std::is_same_v<Repr, std::string>
[[nodiscard]] std::string to_string(const Id<Tag, Repr>& id) {
    return id.value();
}
 
template <class Tag, class Repr>
    requires(!std::is_same_v<Repr, std::string>) && detail::StdToStringable<Repr>
[[nodiscard]] std::string to_string(const Id<Tag, Repr>& id) {
    return std::to_string(id.value());
}
 
#if COMMONS_WITH_ULID
template <class Tag, class Repr>
    requires std::is_same_v<Repr, ::ulid::Ulid>
[[nodiscard]] std::string to_string(const Id<Tag, Repr>& id) {
    return id.value().string();
}
#endif
 
template <class Tag, class Repr>
[[nodiscard]] std::string display_string(const Id<Tag, Repr>& id) {
    if constexpr (NamedIdTag<Tag>) {
        std::string out{std::string_view{Tag::name}};
        out.push_back('/');
        out += to_string(id);
        return out;
    } else {
        return to_string(id);
    }
}
 
template <class Tag, class Repr>
std::ostream& operator<<(std::ostream& os, const Id<Tag, Repr>& id) {
    return os << to_string(id);
}
 
}  // namespace comms
 
// -- std::hash + std::formatter ---------------------------------------------
// Specializations live in namespace std (the primary templates are visible),
// matching the layout used by semver.hpp and the rest of commons.
 
template <class Tag, class Repr>
    requires requires(const Repr& r) {
        { std::hash<Repr>{}(r) } -> std::convertible_to<std::size_t>;
    }
struct std::hash<comms::Id<Tag, Repr>> {
    [[nodiscard]] std::size_t operator()(const comms::Id<Tag, Repr>& id) const noexcept {
        return std::hash<Repr>{}(id.value());
    }
};
 
template <class Tag, class Repr, class Char>
struct std::formatter<comms::Id<Tag, Repr>, Char> : std::formatter<Repr, Char> {
    template <class FormatContext>
    auto format(const comms::Id<Tag, Repr>& id, FormatContext& ctx) const {
        return std::formatter<Repr, Char>::format(id.value(), ctx);
    }
};
 
// -- macros ------------------------------------------------------------------
// Defined at file scope (after the std specializations) so they work from any
// namespace; the generated aliases fully qualify the commons types. `Name`
// appears as a `using`-declared identifier and inside a template argument, so
// it can't be parenthesized — silence the bugprone-macro-parentheses warning
// over the whole block.
// NOLINTBEGIN(bugprone-macro-parentheses)
 
#define COMMONS_DEFINE_ID_TAG(Name, NameStr)                                                       \
    struct Name##Tag {                                                                             \
        [[maybe_unused]] static constexpr ::std::string_view name = NameStr;                       \
    }
 
#define COMMONS_DEFINE_UINT8_ID(Name, NameStr)                                                     \
    COMMONS_DEFINE_ID_TAG(Name, NameStr);                                                          \
    using Name = ::comms::Uint8Id<Name##Tag>
 
#define COMMONS_DEFINE_UINT16_ID(Name, NameStr)                                                    \
    COMMONS_DEFINE_ID_TAG(Name, NameStr);                                                          \
    using Name = ::comms::Uint16Id<Name##Tag>
 
#define COMMONS_DEFINE_UINT32_ID(Name, NameStr)                                                    \
    COMMONS_DEFINE_ID_TAG(Name, NameStr);                                                          \
    using Name = ::comms::Uint32Id<Name##Tag>
 
#define COMMONS_DEFINE_UINT64_ID(Name, NameStr)                                                    \
    COMMONS_DEFINE_ID_TAG(Name, NameStr);                                                          \
    using Name = ::comms::Uint64Id<Name##Tag>
 
#define COMMONS_DEFINE_STRING_ID(Name, NameStr)                                                    \
    COMMONS_DEFINE_ID_TAG(Name, NameStr);                                                          \
    using Name = ::comms::StringId<Name##Tag>
 
#if COMMONS_WITH_ULID
#define COMMONS_DEFINE_ULID_ID(Name, NameStr)                                                      \
    COMMONS_DEFINE_ID_TAG(Name, NameStr);                                                          \
    using Name = ::comms::UlidId<Name##Tag>
#endif
 
// NOLINTEND(bugprone-macro-parentheses)