ITypeInfo.h

Go to the documentation of this file.

#ifndef ZSERIO_I_TYPE_INFO_INC_H
#define ZSERIO_I_TYPE_INFO_INC_H
 
#include "zserio/IReflectable.h"
#include "zserio/Span.h"
#include "zserio/StringView.h"
#include "zserio/Types.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 
};
 
enum class SchemaType
{
    BOOL, 
    INT8, 
    INT16, 
    INT32, 
    INT64, 
    UINT8, 
    UINT16, 
    UINT32, 
    UINT64, 
    VARINT16, 
    VARINT32, 
    VARINT64, 
    VARINT, 
    VARUINT16, 
    VARUINT32, 
    VARUINT64, 
    VARUINT, 
    VARSIZE, 
    FIXED_SIGNED_BITFIELD, 
    FIXED_UNSIGNED_BITFIELD, 
    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 StringView 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 StringView 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 StringView> getUnderlyingTypeArguments() 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 StringView getSqlConstraint() const = 0;
 
    virtual StringView 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 StringView 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 IBasicReflectablePtr<ALLOC> createInstance(const ALLOC& allocator) const = 0;
 
    virtual IBasicReflectablePtr<ALLOC> createInstance() const = 0;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicFieldInfo
{
    BasicFieldInfo(StringView schemaName_, const IBasicTypeInfo<ALLOC>& typeInfo_,
            Span<const StringView> typeArguments_, bool isExtended_, StringView alignment_, StringView offset_,
            StringView initializer_, bool isOptional_, StringView optionalCondition_, StringView constraint_,
            bool isArray_, StringView 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_)
    {}
 
    StringView schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
    Span<const StringView> typeArguments; 
    bool isExtended; 
    StringView alignment; 
    StringView offset; 
    StringView initializer; 
    bool isOptional; 
    StringView optionalCondition; 
    StringView constraint; 
    bool isArray; 
    StringView arrayLength; 
    bool isPacked; 
    bool isImplicit; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicParameterInfo
{
    StringView schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicFunctionInfo
{
    StringView schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
    StringView functionResult; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicCaseInfo
{
    Span<const StringView> caseExpressions; 
    const BasicFieldInfo<ALLOC>* field; 
};
 
struct ItemInfo
{
    ItemInfo(StringView schemaName_, uint64_t value_, bool isDeprecated_, bool isRemoved_) :
            schemaName(schemaName_),
            value(value_),
            isDeprecated(isDeprecated_),
            isRemoved(isRemoved_)
    {}
 
    StringView schemaName; 
    uint64_t value; 
    bool isDeprecated; 
    bool isRemoved; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicColumnInfo
{
    BasicColumnInfo(StringView schemaName_, const IBasicTypeInfo<ALLOC>& typeInfo_,
            Span<const StringView> typeArguments_, StringView sqlTypeName_, StringView sqlConstraint_,
            bool isVirtual_) :
            schemaName(schemaName_),
            typeInfo(typeInfo_),
            typeArguments(typeArguments_),
            sqlTypeName(sqlTypeName_),
            sqlConstraint(sqlConstraint_),
            isVirtual(isVirtual_)
    {}
 
    StringView schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
    Span<const StringView> typeArguments; 
    StringView sqlTypeName; 
    StringView sqlConstraint; 
    bool isVirtual; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicTableInfo
{
    StringView 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(StringView schemaName_, const IBasicTypeInfo<ALLOC>& typeInfo_, bool isPublished_,
            bool isSubscribed_, StringView topic_) :
            schemaName(schemaName_),
            typeInfo(typeInfo_),
            isPublished(isPublished_),
            isSubscribed(isSubscribed_),
            topic(topic_)
    {}
 
    StringView schemaName; 
    const IBasicTypeInfo<ALLOC>& typeInfo; 
    bool isPublished; 
    bool isSubscribed; 
    StringView topic; 
};
 
template <typename ALLOC = std::allocator<uint8_t>>
struct BasicMethodInfo
{
    StringView schemaName;
    const IBasicTypeInfo<ALLOC>& responseTypeInfo;
    const IBasicTypeInfo<ALLOC>& requestTypeInfo;
};
 
template <typename T, typename ALLOC = std::allocator<uint8_t>>
const IBasicTypeInfo<ALLOC>& enumTypeInfo();
 
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