primitives.hpp

#pragma once
 
#include <optional>
#include <string>
 
#include <userver/formats/json_fwd.hpp>
 
#include <userver/ydb/io/traits.hpp>
#include <userver/ydb/types.hpp>
 
namespace boost::uuids {
struct uuid;
}
 
USERVER_NAMESPACE_BEGIN
 
namespace ydb {
 
template <typename PrimitiveTrait>
struct OptionalPrimitiveTraits {
    static std::optional<typename PrimitiveTrait::Type> Parse(NYdb::TValueParser& parser, const ParseContext& context);
 
    static void Write(
        NYdb::TValueBuilderBase<NYdb::TValueBuilder>& builder,
        const std::optional<typename PrimitiveTrait::Type>& value
    );
 
    static void Write(
        NYdb::TValueBuilderBase<NYdb::TParamValueBuilder>& builder,
        const std::optional<typename PrimitiveTrait::Type>& value
    );
 
    static NYdb::TType MakeType();
};
 
template <typename PrimitiveTrait>
struct PrimitiveTraits {
    static typename PrimitiveTrait::Type Parse(NYdb::TValueParser& parser, const ParseContext& context);
 
    static void Write(
        NYdb::TValueBuilderBase<NYdb::TValueBuilder>& builder,
        const typename PrimitiveTrait::Type& value
    );
 
    static void Write(
        NYdb::TValueBuilderBase<NYdb::TParamValueBuilder>& builder,
        const typename PrimitiveTrait::Type& value
    );
 
    static NYdb::TType MakeType();
};
 
struct BoolTrait {
    using Type = bool;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct Int8Trait {
    using Type = std::int8_t;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct Uint8Trait {
    using Type = std::uint8_t;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct Int16Trait {
    using Type = std::int16_t;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct Uint16Trait {
    using Type = std::uint16_t;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct Int32Trait {
    using Type = std::int32_t;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct Uint32Trait {
    using Type = std::uint32_t;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct Int64Trait {
    using Type = std::int64_t;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct Uint64Trait {
    using Type = std::uint64_t;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct DoubleTrait {
    using Type = double;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct StringTrait {
    using Type = std::string;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, const Type& value);
};
 
struct Utf8Trait {
    using Type = Utf8;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, const Type& value);
};
 
struct TimestampTrait {
    using Type = Timestamp;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct UuidTrait {
    using Type = boost::uuids::uuid;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, Type value);
};
 
struct JsonTrait {
    using Type = formats::json::Value;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, const Type& value);
};
 
struct JsonDocumentTrait {
    using Type = JsonDocument;
    static Type Parse(const NYdb::TValueParser& value_parser);
    template <typename Builder>
    static void Write(NYdb::TValueBuilderBase<Builder>& builder, const Type& value);
};
 
template <>
struct ValueTraits<std::optional<JsonDocumentTrait::Type>> : OptionalPrimitiveTraits<JsonDocumentTrait> {};
 
template <>
struct ValueTraits<JsonDocument> : PrimitiveTraits<JsonDocumentTrait> {};
 
template <>
struct ValueTraits<std::optional<JsonTrait::Type>> : OptionalPrimitiveTraits<JsonTrait> {};
 
template <>
struct ValueTraits<formats::json::Value> : PrimitiveTraits<JsonTrait> {};
 
template <>
struct ValueTraits<std::optional<TimestampTrait::Type>> : OptionalPrimitiveTraits<TimestampTrait> {};
 
template <>
struct ValueTraits<TimestampTrait::Type> : PrimitiveTraits<TimestampTrait> {};
 
template <>
struct ValueTraits<std::optional<UuidTrait::Type>> : OptionalPrimitiveTraits<UuidTrait> {};
 
template <>
struct ValueTraits<UuidTrait::Type> : PrimitiveTraits<UuidTrait> {};
 
template <>
struct ValueTraits<std::optional<Utf8Trait::Type>> : OptionalPrimitiveTraits<Utf8Trait> {};
 
template <>
struct ValueTraits<Utf8Trait::Type> : PrimitiveTraits<Utf8Trait> {};
 
template <>
struct ValueTraits<std::optional<StringTrait::Type>> : OptionalPrimitiveTraits<StringTrait> {};
 
template <>
struct ValueTraits<StringTrait::Type> : PrimitiveTraits<StringTrait> {};
 
template <>
struct ValueTraits<std::optional<DoubleTrait::Type>> : OptionalPrimitiveTraits<DoubleTrait> {};
 
template <>
struct ValueTraits<DoubleTrait::Type> : PrimitiveTraits<DoubleTrait> {};
 
template <>
struct ValueTraits<std::optional<Uint64Trait::Type>> : OptionalPrimitiveTraits<Uint64Trait> {};
 
template <>
struct ValueTraits<Uint64Trait::Type> : PrimitiveTraits<Uint64Trait> {};
 
template <>
struct ValueTraits<std::optional<Int64Trait::Type>> : OptionalPrimitiveTraits<Int64Trait> {};
 
template <>
struct ValueTraits<Int64Trait::Type> : PrimitiveTraits<Int64Trait> {};
 
template <>
struct ValueTraits<std::optional<Uint32Trait::Type>> : OptionalPrimitiveTraits<Uint32Trait> {};
 
template <>
struct ValueTraits<Uint32Trait::Type> : PrimitiveTraits<Uint32Trait> {};
 
template <>
struct ValueTraits<std::optional<Int32Trait::Type>> : OptionalPrimitiveTraits<Int32Trait> {};
 
template <>
struct ValueTraits<Int32Trait::Type> : PrimitiveTraits<Int32Trait> {};
 
template <>
struct ValueTraits<std::optional<Uint16Trait::Type>> : OptionalPrimitiveTraits<Uint16Trait> {};
 
template <>
struct ValueTraits<Uint16Trait::Type> : PrimitiveTraits<Uint16Trait> {};
 
template <>
struct ValueTraits<std::optional<Int16Trait::Type>> : OptionalPrimitiveTraits<Int16Trait> {};
 
template <>
struct ValueTraits<Int16Trait::Type> : PrimitiveTraits<Int16Trait> {};
 
template <>
struct ValueTraits<std::optional<Uint8Trait::Type>> : OptionalPrimitiveTraits<Uint8Trait> {};
 
template <>
struct ValueTraits<Uint8Trait::Type> : PrimitiveTraits<Uint8Trait> {};
 
template <>
struct ValueTraits<std::optional<Int8Trait::Type>> : OptionalPrimitiveTraits<Int8Trait> {};
 
template <>
struct ValueTraits<Int8Trait::Type> : PrimitiveTraits<Int8Trait> {};
 
template <>
struct ValueTraits<std::optional<BoolTrait::Type>> : OptionalPrimitiveTraits<BoolTrait> {};
 
template <>
struct ValueTraits<BoolTrait::Type> : PrimitiveTraits<BoolTrait> {};
 
}  // namespace ydb
 
USERVER_NAMESPACE_END