IntrospectableDataBase.h

Go to the documentation of this file.

#ifndef ZSERIO_INTROSPECTABLE_DATA_BASE_H_INC
#define ZSERIO_INTROSPECTABLE_DATA_BASE_H_INC
 
#include "zserio/TypeInfo.h"
 
namespace zserio
{
namespace detail
{
 
template <typename I, typename ALLOC>
class IntrospectableDataBase : public I
{
public:
    using ConstPtr = typename I::ConstPtr;
 
    using I::at;
    using I::getField;
    using I::operator[];
    using I::find;
    using I::getAnyValue;
 
    explicit IntrospectableDataBase(const IBasicTypeInfo<ALLOC>& typeInfo);
 
    ~IntrospectableDataBase() override = default;
 
    IntrospectableDataBase(const IntrospectableDataBase&) = delete;
    IntrospectableDataBase& operator=(const IntrospectableDataBase&) = delete;
 
    IntrospectableDataBase(const IntrospectableDataBase&&) = delete;
    IntrospectableDataBase& operator=(const IntrospectableDataBase&&) = delete;
    const IBasicTypeInfo<ALLOC>& getTypeInfo() const override;
    bool isArray() const override;
 
    ConstPtr getField(std::string_view name) const override;
    std::string_view getChoice() const override;
 
    size_t size() const override;
    ConstPtr at(size_t index) const override;
    ConstPtr operator[](size_t index) const override;
 
    BasicAny<ALLOC> getAnyValue(const ALLOC& allocator) const override;
    BasicAny<ALLOC> getAnyValue() const override;
 
    // exact checked getters
    bool getBool() const override;
    int8_t getInt8() const override;
    int16_t getInt16() const override;
    int32_t getInt32() const override;
    int64_t getInt64() const override;
    uint8_t getUInt8() const override;
    uint16_t getUInt16() const override;
    uint32_t getUInt32() const override;
    uint64_t getUInt64() const override;
    float getFloat() const override;
    double getDouble() const override;
    BytesView getBytes() const override;
    std::string_view getStringView() const override;
    const BasicBitBuffer<ALLOC>& getBitBuffer() const override;
 
    // convenience conversions
    int64_t toInt() const override;
    uint64_t toUInt() const override;
    double toDouble() const override;
    BasicString<RebindAlloc<ALLOC, char>> toString(const ALLOC& allocator) const override;
    BasicString<RebindAlloc<ALLOC, char>> toString() const override;
 
    ConstPtr find(std::string_view path) const override;
    ConstPtr operator[](std::string_view path) const override;
 
private:
    const IBasicTypeInfo<ALLOC>& m_typeInfo;
};
 
// implementation of base classes methods
 
template <typename I, typename ALLOC>
IntrospectableDataBase<I, ALLOC>::IntrospectableDataBase(const IBasicTypeInfo<ALLOC>& typeInfo) :
        m_typeInfo(typeInfo)
{}
 
template <typename I, typename ALLOC>
const IBasicTypeInfo<ALLOC>& IntrospectableDataBase<I, ALLOC>::getTypeInfo() const
{
    return m_typeInfo;
}
 
template <typename I, typename ALLOC>
bool IntrospectableDataBase<I, ALLOC>::isArray() const
{
    return false;
}
 
template <typename I, typename ALLOC>
typename IntrospectableDataBase<I, ALLOC>::ConstPtr IntrospectableDataBase<I, ALLOC>::getField(
        std::string_view) const
{
    throw CppRuntimeException("Type '") << m_typeInfo.getSchemaName() << "' has no fields to get!";
}
 
template <typename I, typename ALLOC>
std::string_view IntrospectableDataBase<I, ALLOC>::getChoice() const
{
    throw CppRuntimeException("Type '") << m_typeInfo.getSchemaName() << "' is neither choice nor union!";
}
 
template <typename I, typename ALLOC>
size_t IntrospectableDataBase<I, ALLOC>::size() const
{
    throw CppRuntimeException("Type '") << m_typeInfo.getSchemaName() << "' is not an array!";
}
 
template <typename I, typename ALLOC>
typename IntrospectableDataBase<I, ALLOC>::ConstPtr IntrospectableDataBase<I, ALLOC>::at(size_t) const
{
    throw CppRuntimeException("Type '") << m_typeInfo.getSchemaName() << "' is not an array!";
}
 
template <typename I, typename ALLOC>
typename IntrospectableDataBase<I, ALLOC>::ConstPtr IntrospectableDataBase<I, ALLOC>::operator[](size_t) const
{
    throw CppRuntimeException("Type '") << m_typeInfo.getSchemaName() << "' is not an array!";
}
 
template <typename I, typename ALLOC>
BasicAny<ALLOC> IntrospectableDataBase<I, ALLOC>::getAnyValue(const ALLOC&) const
{
    throw CppRuntimeException("Type '") << m_typeInfo.getSchemaName() << "' is not implemented!";
}
 
template <typename I, typename ALLOC>
BasicAny<ALLOC> IntrospectableDataBase<I, ALLOC>::getAnyValue() const
{
    return getAnyValue(ALLOC());
}
 
template <typename I, typename ALLOC>
bool IntrospectableDataBase<I, ALLOC>::getBool() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not boolean type!";
}
 
template <typename I, typename ALLOC>
int8_t IntrospectableDataBase<I, ALLOC>::getInt8() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not int8 type!";
}
 
template <typename I, typename ALLOC>
int16_t IntrospectableDataBase<I, ALLOC>::getInt16() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not int16 type!";
}
 
template <typename I, typename ALLOC>
int32_t IntrospectableDataBase<I, ALLOC>::getInt32() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not int32 type!";
}
 
template <typename I, typename ALLOC>
int64_t IntrospectableDataBase<I, ALLOC>::getInt64() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not int64 type!";
}
 
template <typename I, typename ALLOC>
uint8_t IntrospectableDataBase<I, ALLOC>::getUInt8() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not uint8 type!";
}
 
template <typename I, typename ALLOC>
uint16_t IntrospectableDataBase<I, ALLOC>::getUInt16() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not uint16 type!";
}
 
template <typename I, typename ALLOC>
uint32_t IntrospectableDataBase<I, ALLOC>::getUInt32() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not uint32 type!";
}
 
template <typename I, typename ALLOC>
uint64_t IntrospectableDataBase<I, ALLOC>::getUInt64() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not uint64 type!";
}
 
template <typename I, typename ALLOC>
float IntrospectableDataBase<I, ALLOC>::getFloat() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not float type!";
}
 
template <typename I, typename ALLOC>
double IntrospectableDataBase<I, ALLOC>::getDouble() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not double type!";
}
 
template <typename I, typename ALLOC>
BytesView IntrospectableDataBase<I, ALLOC>::getBytes() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not bytes type!";
}
 
template <typename I, typename ALLOC>
std::string_view IntrospectableDataBase<I, ALLOC>::getStringView() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not string type!";
}
 
template <typename I, typename ALLOC>
const BasicBitBuffer<ALLOC>& IntrospectableDataBase<I, ALLOC>::getBitBuffer() const
{
    throw CppRuntimeException("'") << m_typeInfo.getSchemaName() << "' is not an extern type!";
}
 
template <typename I, typename ALLOC>
int64_t IntrospectableDataBase<I, ALLOC>::toInt() const
{
    throw CppRuntimeException("Conversion from '")
            << m_typeInfo.getSchemaName() << "' to signed integer is not available!";
}
 
template <typename I, typename ALLOC>
uint64_t IntrospectableDataBase<I, ALLOC>::toUInt() const
{
    throw CppRuntimeException("Conversion from '")
            << m_typeInfo.getSchemaName() << "' to unsigned integer is not available!";
}
 
template <typename I, typename ALLOC>
double IntrospectableDataBase<I, ALLOC>::toDouble() const
{
    throw CppRuntimeException("Conversion from '")
            << m_typeInfo.getSchemaName() << "' to double is not available!";
}
 
template <typename I, typename ALLOC>
BasicString<RebindAlloc<ALLOC, char>> IntrospectableDataBase<I, ALLOC>::toString(const ALLOC&) const
{
    throw CppRuntimeException("Conversion from '")
            << m_typeInfo.getSchemaName() << "' to string is not available!";
}
 
template <typename I, typename ALLOC>
BasicString<RebindAlloc<ALLOC, char>> IntrospectableDataBase<I, ALLOC>::toString() const
{
    return toString(ALLOC());
}
 
template <typename I, typename ALLOC>
typename IntrospectableDataBase<I, ALLOC>::ConstPtr IntrospectableDataBase<I, ALLOC>::find(
        std::string_view) const
{
    throw CppRuntimeException("Find is not available for '") << m_typeInfo.getSchemaName() << "'!";
}
 
template <typename I, typename ALLOC>
typename IntrospectableDataBase<I, ALLOC>::ConstPtr IntrospectableDataBase<I, ALLOC>::operator[](
        std::string_view path) const
{
    return find(path);
}
 
} // namespace detail
} // namespace zserio
 
#endif // ZSERIO_INTROSPECTABLE_DATA_BASE_H_INC