IReflectableData.h

Go to the documentation of this file.

#ifndef ZSERIO_I_REFLECTABLE_DATA_H_INC
#define ZSERIO_I_REFLECTABLE_DATA_H_INC
 
#include <memory>
#include <string_view>
 
#include "zserio/IIntrospectableData.h"
 
namespace zserio
{
 
template <typename ALLOC = std::allocator<uint8_t>>
class IBasicReflectableData : public IIntrospectableData<IBasicReflectableData<ALLOC>, ALLOC>
{
public:
    using Ptr = std::shared_ptr<IBasicReflectableData>;
 
    using ConstPtr = typename IIntrospectableData<IBasicReflectableData<ALLOC>, ALLOC>::ConstPtr;
 
    using IIntrospectableData<IBasicReflectableData<ALLOC>, ALLOC>::getField;
    using IIntrospectableData<IBasicReflectableData<ALLOC>, ALLOC>::at;
    using IIntrospectableData<IBasicReflectableData<ALLOC>, ALLOC>::operator[];
    using IIntrospectableData<IBasicReflectableData<ALLOC>, ALLOC>::getAnyValue;
    using IIntrospectableData<IBasicReflectableData<ALLOC>, ALLOC>::find;
 
    ~IBasicReflectableData() override = default;
 
    virtual Ptr getField(std::string_view name) = 0;
 
    virtual void setField(std::string_view name, const BasicAny<ALLOC>& value) = 0;
 
    virtual Ptr createField(std::string_view name) = 0;
 
    virtual void resize(size_t size) = 0;
 
    virtual Ptr at(size_t index) = 0;
 
    virtual Ptr operator[](size_t index) = 0;
 
    virtual void setAt(const BasicAny<ALLOC>& value, size_t index) = 0;
 
    virtual void append(const BasicAny<ALLOC>& value) = 0;
 
    virtual BasicAny<ALLOC> getAnyValue(const ALLOC& allocator) = 0;
    virtual BasicAny<ALLOC> getAnyValue() = 0;
    virtual Ptr find(std::string_view path) = 0;
 
    virtual Ptr operator[](std::string_view path) = 0;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
using IBasicReflectableDataPtr = typename IBasicReflectableData<ALLOC>::Ptr;
 
template <typename ALLOC = std::allocator<uint8_t>>
using IBasicReflectableDataConstPtr = typename IBasicReflectableData<ALLOC>::ConstPtr;
using IReflectableData = IBasicReflectableData<>;
using IReflectableDataPtr = IBasicReflectableDataPtr<>;
using IReflectableDataConstPtr = IBasicReflectableDataConstPtr<>;
namespace detail
{
 
template <typename T, typename ALLOC>
struct Reflectable;
 
} // namespace detail
 
template <typename T, typename ALLOC = typename T::allocator_type,
        std::enable_if_t<is_complete_v<View<T>> && has_allocator_v<std::decay_t<T>>, int> = 0>
IBasicReflectableDataConstPtr<ALLOC> reflectable(const T& value, const ALLOC& allocator = ALLOC())
{
    return detail::Reflectable<T, ALLOC>::create(value, allocator);
}
 
template <typename T, typename ALLOC = typename T::allocator_type,
        std::enable_if_t<is_complete_v<View<T>> && has_allocator_v<std::decay_t<T>>, int> = 0>
IBasicReflectableDataPtr<ALLOC> reflectable(T& value, const ALLOC& allocator = ALLOC())
{
    return detail::Reflectable<T, ALLOC>::create(value, allocator);
}
 
template <typename T, typename ALLOC = std::allocator<uint8_t>,
        std::enable_if_t<(std::is_enum_v<T> || is_bitmask_v<T>) && !has_allocator_v<std::decay_t<T>>, int> = 0>
IBasicReflectableDataPtr<ALLOC> reflectable(T value, const ALLOC& allocator = ALLOC())
{
    return detail::Reflectable<T, ALLOC>::create(value, allocator);
}
} // namespace zserio
 
#endif // ZSERIO_I_REFLECTABLE_DATA_H_INC