streammetatypeplain.h

Go to the documentation of this file.

#pragma once
#include "streamtype.h"
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/adtf_base.h>
#include <adtf_base_deprecated.h>
#include <type_traits>
#include <vector>
#include <array>
 
namespace adtf
{
namespace streaming
{
namespace ant
{

struct stream_meta_type_plain
{
    static constexpr const tChar *const MetaTypeName         = "adtf/plaintype";
    static constexpr const tChar *const PlainTypeProperty    = "c-type";

    static void SetProperties(const adtf::ucom::iobject_ptr<adtf::base::IProperties>& pProperties)
    {
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>(PlainTypeProperty, ""));
    }

    static tResult IsCompatible(const adtf::streaming::IStreamType& oTypeToCheck,
                                const adtf::streaming::IStreamType& oTypeExpected)
    {
        adtf::ucom::object_ptr<const adtf::base::IProperties> pCheckProperties;
        RETURN_IF_FAILED(oTypeToCheck.GetConfig(pCheckProperties));
        adtf::ucom::object_ptr<const adtf::base::IProperties> pExpectedProperties;
        RETURN_IF_FAILED(oTypeExpected.GetConfig(pExpectedProperties));
 
        auto strCheckPlainType = adtf::base::get_property<adtf_util::cString>(*pCheckProperties, PlainTypeProperty);
        auto strExpectedPlainType = adtf::base::get_property<adtf_util::cString>(*pExpectedProperties, PlainTypeProperty);
 
        if (strCheckPlainType != strExpectedPlainType)
        {
            RETURN_ERROR_DESC(ERR_FAILED,
                              "The destination plain type '%s' differs from the source plain type '%s'",
                              strCheckPlainType.GetPtr(),
                              strExpectedPlainType.GetPtr());
        }
 
        RETURN_NOERROR;
    }
};

template <typename T>
class stream_type_plain
{
    static_assert(base::penguin::detail::always_false<T>, "Invalid type for stream_type_plain<T> used! "
                                                          "Use bool, uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t, float, double or plain array T[], std::array, std::vector of them");
};

#define ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR( _thetype_ , _propval_ ) \
template <> \
class stream_type_plain<_thetype_> : public cStreamType \
{ \
public: \
    static constexpr const char *const PlainTypeValue    = _propval_; \
    static constexpr const char* const PlainTypeName = #_thetype_; \
    stream_type_plain() : cStreamType(stream_meta_type_plain()) \
    { \
        adtf::ucom::object_ptr<adtf::base::ant::IProperties> pProperties; \
        THROW_IF_FAILED(GetConfig(pProperties)); \
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>(stream_meta_type_plain::PlainTypeProperty, PlainTypeValue)); \
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>("md_definitions",\
                                                adtf_util::cString::Format(R"(<struct name=")" _propval_ R"(" alignment="1" version="1">)" \
                                                                            R"(<element name="value" arraysize="1" type=")" #_thetype_ R"(">)" \
                                                                            R"(<deserialized alignment="1"/>)" \
                                                                            R"(<serialized bytepos="0" byteorder="%s"/>)" \
                                                                            "</element>" \
                                                                            "</struct>", \
                                                                            PLATFORM_BYTEORDER == PLATFORM_BIG_ENDIAN_8 ? "BE" : "LE"))); \
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>("md_struct", _propval_));\
    } \
}

ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tBool, "BOOL");

ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tInt8, "INT8");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tUInt8, "UINT8");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tInt16, "INT16");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tUInt16, "UINT16");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tInt32, "INT32");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tUInt32, "UINT32");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tInt64, "INT64");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tUInt64, "UINT64");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tFloat32, "FLOAT32");
ADTF_DEFINE_STREAM_TYPE_PLAIN_FOR(tFloat64, "FLOAT64");
 
} //namespace ant
 
namespace lucky
{
template<typename T>
ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_plain<T>>() instead.")
ucom::ant::object_ptr<ant::IStreamType> create_adtf_plain_stream_type()
{
    return ucom::ant::make_object_ptr<ant::stream_type_plain<T>>();
}
}
 
namespace penguin
{
struct stream_meta_type_plain : public ant::stream_meta_type_plain
{
    static constexpr const char* const ArraySize = "array_size";
    
    static constexpr const char* const DataEndianess = "data_endianess";
    static void SetProperties(const adtf::ucom::iobject_ptr<adtf::base::IProperties>& pProperties)
    {
        ant::stream_meta_type_plain::SetProperties(pProperties);
        pProperties->SetProperty(adtf::base::property<size_t>(ArraySize, 1));
        const auto ui8CurrentPlatformOrder = PLATFORM_BYTEORDER;
        if (ui8CurrentPlatformOrder != PLATFORM_LITTLE_ENDIAN_8)
        {
            pProperties->SetProperty(adtf::base::property<uint8_t>(DataEndianess, ui8CurrentPlatformOrder));
        }
    }

    static tResult IsCompatible(const adtf::streaming::IStreamType& oTypeToCheck,
                                const adtf::streaming::IStreamType& oTypeExpected)
    {
        adtf::ucom::object_ptr<const adtf::base::IProperties> pCheckProperties;
        RETURN_IF_FAILED(oTypeToCheck.GetConfig(pCheckProperties));
        adtf::ucom::object_ptr<const adtf::base::IProperties> pExpectedProperties;
        RETURN_IF_FAILED(oTypeExpected.GetConfig(pExpectedProperties));
 
        const auto strCheckPlainType = adtf::base::get_property<adtf_util::cString>(*pCheckProperties, PlainTypeProperty);
        const auto strExpectedPlainType = adtf::base::get_property<adtf_util::cString>(*pExpectedProperties, PlainTypeProperty);
 
        if (strCheckPlainType != strExpectedPlainType)
        {
            RETURN_ERROR_DESC(ERR_FAILED,
                              "The checked plain type '%s' differs from the expected plain type '%s'",
                              strCheckPlainType.GetPtr(),
                              strExpectedPlainType.GetPtr());
        }
        const auto uiCheckDataEndianess = adtf::base::get_property<uint8_t>(*pCheckProperties, DataEndianess, PLATFORM_LITTLE_ENDIAN_8);
        const auto uiExpectedDataEndianess
            = adtf::base::get_property<uint8_t>(*pExpectedProperties, DataEndianess, PLATFORM_LITTLE_ENDIAN_8);
        if (uiCheckDataEndianess != uiExpectedDataEndianess)
        {
            if (strCheckPlainType != "UINT8" && strCheckPlainType != "INT8" && strCheckPlainType != "BOOL" && strCheckPlainType != "UINT8_ARRAY" && strCheckPlainType != "INT8_ARRAY" && strCheckPlainType != "BOOL_ARRAY")
            {
                RETURN_ERROR_DESC(ERR_FAILED,
                                  "The checked plain type '%s' differs from the expected plain type '%s' in endianess",
                                  strCheckPlainType.GetPtr(),
                                  strExpectedPlainType.GetPtr());
            }
        }
 
        const auto uiCheckArraySize = adtf::base::get_property<size_t>(*pCheckProperties, ArraySize, 1);
        const auto uiExpectedArraySize = adtf::base::get_property<size_t>(*pExpectedProperties, ArraySize, 1);
        if (uiCheckArraySize < uiExpectedArraySize)
        {
            RETURN_ERROR_DESC(
                ERR_FAILED,
                "The checked plain type '%s' array size (%zu) is lower than the expected plain type '%s' array size (%zu)",
                strCheckPlainType.GetPtr(), uiCheckArraySize, strExpectedPlainType.GetPtr(), uiExpectedArraySize);
        }
 
        RETURN_NOERROR;
    }
};

template<typename T>
class stream_type_plain : public ant::stream_type_plain<T>
{
public:
    stream_type_plain():
        ant::stream_type_plain<T>()
    {
        adtf::ucom::object_ptr<adtf::base::ant::IProperties> pProperties;
        THROW_IF_FAILED(ant::stream_type_plain<T>::GetConfig(pProperties));
        pProperties->SetProperty(adtf::base::property<size_t>(stream_meta_type_plain::ArraySize, 1));
        const auto ui8CurrentPlatformOrder = PLATFORM_BYTEORDER;
        if (ui8CurrentPlatformOrder != PLATFORM_LITTLE_ENDIAN_8)
        {
            pProperties->SetProperty(
                adtf::base::property<uint8_t>(stream_meta_type_plain::DataEndianess, ui8CurrentPlatformOrder));
        }
    }
};

template<typename ValueType, size_t szArraySize, template<typename, size_t> class T>
class stream_type_plain<T<ValueType, szArraySize>> : public cStreamType
{
    static_assert(std::is_arithmetic_v<typename T<ValueType, szArraySize>::value_type>,
                  "std::array can only be used for arithmetic types");
 
public:
    stream_type_plain():
        cStreamType(stream_meta_type_plain())
    {
        adtf::ucom::object_ptr<adtf::base::ant::IProperties> pProperties;
        THROW_IF_FAILED(GetConfig(pProperties));
 
        const adtf_util::cString strPropValue = adtf_util::cString::Format(
            "%s_ARRAY", ant::stream_type_plain<typename T<ValueType, szArraySize>::value_type>::PlainTypeValue);        
        const adtf_util::cString strPropTypeName(ant::stream_type_plain<typename T<ValueType, szArraySize>::value_type>::PlainTypeName);
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>(stream_meta_type_plain::PlainTypeProperty, strPropValue));
        pProperties->SetProperty(adtf::base::property<size_t>(stream_meta_type_plain::ArraySize, szArraySize));
 
        // prepare for ddl usage
        const adtf_util::cString strMDDefValue = adtf_util::cString::Format(R"(<struct name="%s" alignment="1" version="1">
    <element name="value" arraysize="%zu" type="%s">
        <deserialized alignment="1"/>
        <serialized bytepos="0" byteorder="%s"/>
    </element>
</struct>)", strPropValue.GetPtr(), szArraySize,
             strPropTypeName.GetPtr(),
             PLATFORM_BYTEORDER == PLATFORM_BIG_ENDIAN_8 ? "BE" : "LE");
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>("md_definitions",
                                                                            strMDDefValue));
        pProperties->SetProperty(adtf::base::property<adtf_util::cString>("md_struct", strPropValue));
        
    }
};

template<class ValueType, size_t szArraySize>
class stream_type_plain<ValueType[szArraySize]> : public stream_type_plain<std::array<ValueType, szArraySize>>
{
};

template<typename T>
ADTF3_DEPRECATED("Use adtf::ucom::make_object_ptr<stream_type_plain<T>>() instead.")
ucom::ant::object_ptr<ant::IStreamType> create_adtf_plain_stream_type()
{
    return ucom::ant::make_object_ptr<penguin::stream_type_plain<T>>();
}
 
} // namespace penguin

using penguin::stream_meta_type_plain;

using penguin::stream_type_plain;

using penguin::create_adtf_plain_stream_type;
 
} //namespace streaming
} //namespace adtf