ITypeInfo.h

Go to the documentation of this file.

#ifndef ZSERIO_I_TYPE_INFO_INC_H
#define ZSERIO_I_TYPE_INFO_INC_H
 
#include <string_view>
 
#include "zserio/IReflectableData.h"
#include "zserio/Span.h"
#include "zserio/Traits.h"
 
namespace zserio
{
 
enum class CppType
{
    BOOL, 
    INT8, 
    INT16, 
    INT32, 
    INT64, 
    UINT8, 
    UINT16, 
    UINT32, 
    UINT64, 
    FLOAT, 
    DOUBLE, 
    BYTES, 
    STRING, 
    BIT_BUFFER, 
    ENUM, 
    BITMASK, 
    STRUCT, 
    CHOICE, 
    UNION, 
    SQL_TABLE, 
    SQL_DATABASE, 
    SERVICE, 
    PUBSUB 
};
 
// TODO[Mi-L@]: Do we still need STD integers?
// Currently not used since runtime won't recognize bit:16 and uint16.
enum class SchemaType
{
    BOOL, 
    INT1, 
    INT2, 
    INT3, 
    INT4, 
    INT5, 
    INT6, 
    INT7, 
    INT8, 
    INT9, 
    INT10, 
    INT11, 
    INT12, 
    INT13, 
    INT14, 
    INT15, 
    INT16, 
    INT17, 
    INT18, 
    INT19, 
    INT20, 
    INT21, 
    INT22, 
    INT23, 
    INT24, 
    INT25, 
    INT26, 
    INT27, 
    INT28, 
    INT29, 
    INT30, 
    INT31, 
    INT32, 
    INT33, 
    INT34, 
    INT35, 
    INT36, 
    INT37, 
    INT38, 
    INT39, 
    INT40, 
    INT41, 
    INT42, 
    INT43, 
    INT44, 
    INT45, 
    INT46, 
    INT47, 
    INT48, 
    INT49, 
    INT50, 
    INT51, 
    INT52, 
    INT53, 
    INT54, 
    INT55, 
    INT56, 
    INT57, 
    INT58, 
    INT59, 
    INT60, 
    INT61, 
    INT62, 
    INT63, 
    INT64, 
    UINT1, 
    UINT2, 
    UINT3, 
    UINT4, 
    UINT5, 
    UINT6, 
    UINT7, 
    UINT8, 
    UINT9, 
    UINT10, 
    UINT11, 
    UINT12, 
    UINT13, 
    UINT14, 
    UINT15, 
    UINT16, 
    UINT17, 
    UINT18, 
    UINT19, 
    UINT20, 
    UINT21, 
    UINT22, 
    UINT23, 
    UINT24, 
    UINT25, 
    UINT26, 
    UINT27, 
    UINT28, 
    UINT29, 
    UINT30, 
    UINT31, 
    UINT32, 
    UINT33, 
    UINT34, 
    UINT35, 
    UINT36, 
    UINT37, 
    UINT38, 
    UINT39, 
    UINT40, 
    UINT41, 
    UINT42, 
    UINT43, 
    UINT44, 
    UINT45, 
    UINT46, 
    UINT47, 
    UINT48, 
    UINT49, 
    UINT50, 
    UINT51, 
    UINT52, 
    UINT53, 
    UINT54, 
    UINT55, 
    UINT56, 
    UINT57, 
    UINT58, 
    UINT59, 
    UINT60, 
    UINT61, 
    UINT62, 
    UINT63, 
    UINT64, 
    VARINT16, 
    VARINT32, 
    VARINT64, 
    VARINT, 
    VARUINT16, 
    VARUINT32, 
    VARUINT64, 
    VARUINT, 
    VARSIZE, 
    DYNAMIC_SIGNED_BITFIELD, 
    DYNAMIC_UNSIGNED_BITFIELD, 
    FLOAT16, 
    FLOAT32, 
    FLOAT64, 
    BYTES, 
    STRING, 
    EXTERN, 
    ENUM, 
    BITMASK, 
    STRUCT, 
    CHOICE, 
    UNION, 
    SQL_TABLE, 
    SQL_DATABASE, 
    SERVICE, 
    PUBSUB 
};
 
// forward declarations
template <typename ALLOC>
struct BasicFieldInfo;
template <typename ALLOC>
struct BasicParameterInfo;
template <typename ALLOC>
struct BasicFunctionInfo;
template <typename ALLOC>
struct BasicCaseInfo;
template <typename ALLOC>
struct BasicColumnInfo;
template <typename ALLOC>
struct BasicTableInfo;
struct ItemInfo;
template <typename ALLOC>
struct BasicTemplateArgumentInfo;
template <typename ALLOC>
struct BasicMessageInfo;
template <typename ALLOC>
struct BasicMethodInfo;
 
template <typename ALLOC = std::allocator<uint8_t>>
class IBasicTypeInfo
{
public:
    virtual ~IBasicTypeInfo() = default;
 
    virtual std::string_view getSchemaName() const = 0;
 
    virtual SchemaType getSchemaType() const = 0;
 
    virtual CppType getCppType() const = 0;
 
    // method for fixed size integral types
 
    virtual uint8_t getBitSize() const = 0;
 
    // methods for compound types
 
    virtual Span<const BasicFieldInfo<ALLOC>> getFields() const = 0;
 
    virtual Span<const BasicParameterInfo<ALLOC>> getParameters() const = 0;
 
    virtual Span<const BasicFunctionInfo<ALLOC>> getFunctions() const = 0;
 
    // methods for choice type
 
    virtual std::string_view getSelector() const = 0;
 
    virtual Span<const BasicCaseInfo<ALLOC>> getCases() const = 0;
 
    // methods for enumeration and bitmask types
 
    virtual const IBasicTypeInfo<ALLOC>& getUnderlyingType() const = 0;
 
    virtual Span<const ItemInfo> getEnumItems() const = 0;
 
    virtual Span<const ItemInfo> getBitmaskValues() const = 0;
 
    // methods for SQL table types
 
    virtual Span<const BasicColumnInfo<ALLOC>> getColumns() const = 0;
 
    virtual std::string_view getSqlConstraint() const = 0;
 
    virtual std::string_view getVirtualTableUsing() const = 0;
 
    virtual bool isWithoutRowId() const = 0;
 
    // method for SQL database type
 
    virtual Span<const BasicTableInfo<ALLOC>> getTables() const = 0;
 
    // methods for templatable types
 
    virtual std::string_view getTemplateName() const = 0;
 
    virtual Span<const BasicTemplateArgumentInfo<ALLOC>> getTemplateArguments() const = 0;
 
    // method for pubsub type
 
    virtual Span<const BasicMessageInfo<ALLOC>> getMessages() const = 0;
 
    // method for service type
 
    virtual Span<const BasicMethodInfo<ALLOC>> getMethods() const = 0;
 
    virtual IBasicReflectableDataPtr<ALLOC> createInstance(const ALLOC& allocator) const = 0;
 
    virtual IBasicReflectableDataPtr<ALLOC> createInstance() const = 0;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicFieldInfo
{
    BasicFieldInfo(std::string_view schemaName_, const IBasicTypeInfo<ALLOC>& typeInfo_,
            Span<const std::string_view> typeArguments_, bool isExtended_, std::string_view alignment_,
            std::string_view offset_, std::string_view initializer_, bool isOptional_,
            std::string_view optionalCondition_, std::string_view constraint_, bool isArray_,
            std::string_view arrayLength_, bool isPacked_, bool isImplicit_) :
            schemaName(schemaName_),
            typeInfo(typeInfo_),
            typeArguments(typeArguments_),
            isExtended(isExtended_),
            alignment(alignment_),
            offset(offset_),
            initializer(initializer_),
            isOptional(isOptional_),
            optionalCondition(optionalCondition_),
            constraint(constraint_),
            isArray(isArray_),
            arrayLength(arrayLength_),
            isPacked(isPacked_),
            isImplicit(isImplicit_)
    {}
 
    std::string_view schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
    Span<const std::string_view> typeArguments; 
    bool isExtended; 
    std::string_view alignment; 
    std::string_view offset; 
    std::string_view initializer; 
    bool isOptional; 
    std::string_view optionalCondition; 
    std::string_view constraint; 
    bool isArray; 
    std::string_view arrayLength; 
    bool isPacked; 
    bool isImplicit; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicParameterInfo
{
    std::string_view schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicFunctionInfo
{
    std::string_view schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
    std::string_view functionResult; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicCaseInfo
{
    Span<const std::string_view> caseExpressions; 
    const BasicFieldInfo<ALLOC>* field; 
};
 
struct ItemInfo
{
    ItemInfo(std::string_view schemaName_, uint64_t value_, bool isDeprecated_, bool isRemoved_) :
            schemaName(schemaName_),
            value(value_),
            isDeprecated(isDeprecated_),
            isRemoved(isRemoved_)
    {}
 
    std::string_view schemaName; 
    uint64_t value; 
    bool isDeprecated; 
    bool isRemoved; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicColumnInfo
{
    BasicColumnInfo(std::string_view schemaName_, const IBasicTypeInfo<ALLOC>& typeInfo_,
            Span<const std::string_view> typeArguments_, std::string_view sqlTypeName_,
            std::string_view sqlConstraint_, bool isVirtual_) :
            schemaName(schemaName_),
            typeInfo(typeInfo_),
            typeArguments(typeArguments_),
            sqlTypeName(sqlTypeName_),
            sqlConstraint(sqlConstraint_),
            isVirtual(isVirtual_)
    {}
 
    std::string_view schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
    Span<const std::string_view> typeArguments; 
    std::string_view sqlTypeName; 
    std::string_view sqlConstraint; 
    bool isVirtual; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicTableInfo
{
    std::string_view schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicTemplateArgumentInfo
{
    const IBasicTypeInfo<ALLOC>& typeInfo; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicMessageInfo
{
    BasicMessageInfo(std::string_view schemaName_, const IBasicTypeInfo<ALLOC>& typeInfo_, bool isPublished_,
            bool isSubscribed_, std::string_view topic_) :
            schemaName(schemaName_),
            typeInfo(typeInfo_),
            isPublished(isPublished_),
            isSubscribed(isSubscribed_),
            topic(topic_)
    {}
 
    std::string_view schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
    bool isPublished; 
    bool isSubscribed; 
    std::string_view topic; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicMethodInfo
{
    std::string_view schemaName;
    const IBasicTypeInfo<ALLOC>& responseTypeInfo;
    const IBasicTypeInfo<ALLOC>& requestTypeInfo;
};
 
namespace detail
{
 
template <typename T, typename ALLOC>
struct TypeInfo;
 
template <typename T, typename V = void>
struct type_info_default_alloc
{
    using type = std::allocator<uint8_t>;
};
 
template <typename T>
struct type_info_default_alloc<T, std::enable_if_t<has_allocator_v<T>>>
{
    using type = RebindAlloc<typename T::allocator_type, uint8_t>;
};
 
template <typename T, typename V = void>
using type_info_default_alloc_t = typename type_info_default_alloc<T, V>::type;
 
} // namespace detail
 
template <typename T, typename ALLOC = detail::type_info_default_alloc_t<T>>
const IBasicTypeInfo<ALLOC>& typeInfo()
{
    return detail::TypeInfo<T, ALLOC>::get();
}
 
using ITypeInfo = IBasicTypeInfo<>;
using FieldInfo = BasicFieldInfo<>;
using ParameterInfo = BasicParameterInfo<>;
using FunctionInfo = BasicFunctionInfo<>;
using CaseInfo = BasicCaseInfo<>;
using ColumnInfo = BasicColumnInfo<>;
using TableInfo = BasicTableInfo<>;
using TemplateArgumentInfo = BasicTemplateArgumentInfo<>;
using MessageInfo = BasicMessageInfo<>;
using MethodInfo = BasicMethodInfo<>;
} // namespace zserio
 
#endif // ZSERIO_I_TYPE_INFO_INC_H