value_access.h

Go to the documentation of this file.

 
#ifndef DDL_PREVIEW_VALUE_ACCESS_PRIVATE_CLASS_HEADER
#define DDL_PREVIEW_VALUE_ACCESS_PRIVATE_CLASS_HEADER
 
#include <a_util/result.h>
#include <ddl/codec/leaf_value_access.h>
 
#include <vector>
 
namespace ddl {
namespace codec {
 
#if defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
#pragma GCC diagnostic ignored                                                                     \
    "-Wattributes" // standard type attributes are ignored when used in templates
#endif             // defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
 
namespace detail {
 
template <typename ValueType>
struct SupportedGetterValueType
    : public std::is_convertible<a_util::variant::Variant,
                                 a_util::underlying_type_or_type_t<ValueType>> {
};
 
template <typename ValueType>
struct SupportedSetterValueType
    : public std::is_convertible<a_util::underlying_type_or_type_t<ValueType>,
                                 a_util::variant::Variant> {
};
 
} // namespace detail
 
#if defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
#pragma GCC diagnostic warning                                                                     \
    "-Wattributes" // standard type attributes are ignored when used in templates
#endif             // defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
 
template <typename DecoderType, typename ValueType>
struct ValueGetter {
    static void getValue(const DecoderType& decoder,
                         const CodecIndex& codec_index,
                         ValueType& value)
    {
        static_assert(detail::SupportedGetterValueType<ValueType>::value,
                      "Unsupported type for decode. "
                      "By default bool, all int types, float, double, std::string is supported. "
                      "To support your own data type, create a specialization of this template");
        a_util::variant::Variant variant_value;
        decoder.getElementVariantValue(codec_index, variant_value);
        value = static_cast<ValueType>(
            static_cast<a_util::underlying_type_or_type_t<ValueType>>(variant_value));
    }
};
 
template <typename DecoderType>
struct ValueGetter<DecoderType, std::string> {
    static void getValue(const DecoderType& decoder,
                         const CodecIndex& codec_index,
                         std::string& value)
    {
        value = decoder.getElementStringValue(codec_index);
    }
};
 
template <typename CodecType, typename ValueType>
struct ValueSetter {
    static void setValue(CodecType& codec, const CodecIndex& codec_index, const ValueType& value)
    {
        static_assert(detail::SupportedSetterValueType<ValueType>::value,
                      "Unsupported type for decode. "
                      "By default bool, all int types, float, double, std::string is supported. "
                      "To support your own data type, create a specialization of this template");
        codec.setElementVariantValue(
            codec_index,
            a_util::variant::Variant(
                static_cast<a_util::underlying_type_or_type_t<ValueType>>(value)));
    }
};
 
template <typename CodecType>
struct ValueSetter<CodecType, std::string> {
    static void setValue(CodecType& codec, const CodecIndex& codec_index, const std::string& value)
    {
        codec.setElementStringValue(codec_index, value);
    }
};
 
template <typename DecoderType,
          typename ValueType,
          bool is_supported_leaf_type = detail::SupportedLeafValueTypeExplicit<ValueType>::value>
struct ValueGetterSelect {
    static ValueType getValue(const DecoderType& decoder, const CodecIndex& codec_index)
    {
        ValueType value;
        ValueGetter<DecoderType, ValueType>::getValue(decoder, codec_index, value);
        return value;
    }
};
 
template <typename DecoderType, typename ValueType>
struct ValueGetterSelect<DecoderType, ValueType, true> {
    static ValueType getValue(const DecoderType& decoder, const CodecIndex& codec_index)
    {
        LeafLayout leaf_layout;
        if (LeafCodecIndex::convertToLeafLayout<false>(
                codec_index, leaf_layout, decoder.getRepresentation())) {
            return LeafValueGetter<ValueType>::getValue(
                decoder.getData(), decoder.getDataSize(), leaf_layout);
        }
        else {
            ValueType value;
            ValueGetter<DecoderType, ValueType>::getValue(decoder, codec_index, value);
            return value;
        }
    }
};
 
template <typename CodecType,
          typename ValueType,
          bool is_supported_leaf_type = detail::SupportedLeafValueTypeExplicit<ValueType>::value>
struct ValueSetterSelect {
    static void setValue(CodecType& codec, const CodecIndex& codec_index, const ValueType& value)
    {
        ValueSetter<CodecType, ValueType>::setValue(codec, codec_index, value);
    }
};
 
template <typename CodecType, typename ValueType>
struct ValueSetterSelect<CodecType, ValueType, true> {
    static void setValue(CodecType& codec, const CodecIndex& codec_index, const ValueType& value)
    {
        LeafLayout leaf_layout;
        if (LeafCodecIndex::convertToLeafLayout<false>(
                codec_index, leaf_layout, codec.getRepresentation())) {
            LeafValueSetter<ValueType>::setValue(
                codec.getData(), codec.getDataSize(), leaf_layout, value);
        }
        else {
            ValueSetter<CodecType, ValueType>::setValue(codec, codec_index, value);
        }
    }
};
 
} // namespace codec
} // namespace ddl
 
#endif // DDL_PREVIEW_VALUE_ACCESS_PRIVATE_CLASS_HEADER