IReflectable.h

Go to the documentation of this file.

#ifndef ZSERIO_I_REFLECTABLE_H_INC
#define ZSERIO_I_REFLECTABLE_H_INC
 
#include <memory>
 
#include "zserio/AnyHolder.h"
#include "zserio/BitBuffer.h"
#include "zserio/BitStreamWriter.h"
#include "zserio/ParsingInfo.h"
#include "zserio/RebindAlloc.h"
#include "zserio/Span.h"
#include "zserio/String.h"
#include "zserio/StringView.h"
#include "zserio/Vector.h"
 
namespace zserio
{
 
// forward declaration
template <typename ALLOC>
class IBasicTypeInfo;
 
template <typename ALLOC = std::allocator<uint8_t>>
class IBasicReflectable
{
public:
    using Ptr = std::shared_ptr<IBasicReflectable>;
 
    using ConstPtr = std::shared_ptr<const IBasicReflectable>;
 
    virtual ~IBasicReflectable() = default;
 
    virtual const IBasicTypeInfo<ALLOC>& getTypeInfo() const = 0;
 
    virtual bool isArray() const = 0;
 
    virtual void initializeChildren() = 0;
 
    virtual void initialize(const vector<AnyHolder<ALLOC>, ALLOC>& typeArguments) = 0;
 
    virtual size_t initializeOffsets(size_t bitPosition) = 0;
 
    virtual size_t initializeOffsets() = 0;
 
    virtual size_t bitSizeOf(size_t bitPosition) const = 0;
 
    virtual size_t bitSizeOf() const = 0;
 
    virtual void write(BitStreamWriter& writer) const = 0;
 
    virtual ConstPtr getField(StringView name) const = 0;
    virtual Ptr getField(StringView name) = 0;
    virtual void setField(StringView name, const AnyHolder<ALLOC>& value) = 0;
 
    virtual Ptr createField(StringView name) = 0;
 
    virtual ConstPtr getParameter(StringView name) const = 0;
    virtual Ptr getParameter(StringView name) = 0;
    virtual ConstPtr callFunction(StringView name) const = 0;
    virtual Ptr callFunction(StringView name) = 0;
    virtual StringView getChoice() const = 0;
 
    virtual ConstPtr find(StringView path) const = 0;
    virtual Ptr find(StringView path) = 0;
    virtual ConstPtr operator[](StringView path) const = 0;
    virtual Ptr operator[](StringView path) = 0;
    virtual size_t size() const = 0;
 
    virtual void resize(size_t size) = 0;
 
    virtual ConstPtr at(size_t index) const = 0;
    virtual Ptr at(size_t index) = 0;
    virtual ConstPtr operator[](size_t index) const = 0;
    virtual Ptr operator[](size_t index) = 0;
    virtual void setAt(const AnyHolder<ALLOC>& value, size_t index) = 0;
 
    virtual void append(const AnyHolder<ALLOC>& value) = 0;
 
    virtual AnyHolder<ALLOC> getAnyValue(const ALLOC& allocator) const = 0;
    virtual AnyHolder<ALLOC> getAnyValue(const ALLOC& allocator) = 0;
    virtual AnyHolder<ALLOC> getAnyValue() const = 0;
    virtual AnyHolder<ALLOC> getAnyValue() = 0;
    virtual bool getBool() const = 0;
 
    virtual int8_t getInt8() const = 0;
 
    virtual int16_t getInt16() const = 0;
 
    virtual int32_t getInt32() const = 0;
 
    virtual int64_t getInt64() const = 0;
 
    virtual uint8_t getUInt8() const = 0;
 
    virtual uint16_t getUInt16() const = 0;
 
    virtual uint32_t getUInt32() const = 0;
 
    virtual uint64_t getUInt64() const = 0;
 
    virtual float getFloat() const = 0;
 
    virtual double getDouble() const = 0;
 
    virtual Span<const uint8_t> getBytes() const = 0;
 
    virtual StringView getStringView() const = 0;
 
    virtual const BasicBitBuffer<ALLOC>& getBitBuffer() const = 0;
 
    virtual int64_t toInt() const = 0;
 
    virtual uint64_t toUInt() const = 0;
 
    virtual double toDouble() const = 0;
 
    virtual string<ALLOC> toString(const ALLOC& allocator) const = 0;
    virtual string<ALLOC> toString() const = 0;
    virtual const ParsingInfo& parsingInfo() const = 0;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
using IBasicReflectablePtr = typename IBasicReflectable<ALLOC>::Ptr;
 
template <typename ALLOC = std::allocator<uint8_t>>
using IBasicReflectableConstPtr = typename IBasicReflectable<ALLOC>::ConstPtr;
using IReflectable = IBasicReflectable<>;
using IReflectablePtr = IBasicReflectablePtr<>;
using IReflectableConstPtr = IBasicReflectableConstPtr<>;
template <typename T, typename ALLOC = std::allocator<uint8_t>>
IBasicReflectablePtr<ALLOC> enumReflectable(T value, const ALLOC& allocator = ALLOC());
 
} // namespace zserio
 
#endif // ZSERIO_I_REFLECTABLE_H_INC