adtf_a_util_variant.h

Go to the documentation of this file.

 
#pragma once
 
#include <a_util/variant.h>
#include <adtf_utils.h>
 
namespace adtf_util
{
#define ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(_type_, _getter_functionname_) \
namespace detail \
{ \
    inline _type_ GetArrayValueByType(const a_util::variant::Variant& oValue, size_t nIdx, _type_ ) \
    { \
        return (&(oValue))->_getter_functionname_(nIdx); \
    } \
}
 
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(int8_t, getInt8)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(uint8_t, getUInt8)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(int16_t, getInt16)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(uint16_t, getUInt16)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(int32_t, getInt32)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(uint32_t, getUInt32)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(int64_t, getInt64)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(uint64_t, getUInt64)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(bool, getBool)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(float, getFloat)
ADTF_DEFINE_GET_AUTIL_VARIANT_VALUE_BY_TYPE(double, getDouble)
 
template<typename T, typename U = T>
cVariant ConvertToADTFVariantByType(const a_util::variant::Variant& oValue)
{
    cVariant oResultVariant;
    if (!oValue.isArray())
    {
        oResultVariant.Set(static_cast<T>(oValue));
    }
    else
    {
        std::vector<U> oValueArray;
        for (size_t nIdx = 0; nIdx < oValue.getArraySize(); ++nIdx)
        {
            oValueArray.push_back(detail::GetArrayValueByType(oValue, nIdx, U{}));
        }
        oResultVariant.Set(static_cast<U*>(oValueArray.data()), oValueArray.size());
    }
    return oResultVariant;
}
 
inline cVariant ConvertToADTFVariant(const a_util::variant::Variant& oValue)
{
    cVariant oResultVariant;
    switch (oValue.getType())
    {
        case a_util::variant::VT_Bool:
            oResultVariant = ConvertToADTFVariantByType<bool, uint8_t>(oValue);
            break;
        case a_util::variant::VT_Double:
            oResultVariant = ConvertToADTFVariantByType<double>(oValue);
            break;
        case a_util::variant::VT_Float:
            oResultVariant = ConvertToADTFVariantByType<float>(oValue);
            break;
        case a_util::variant::VT_Int8:
            oResultVariant = ConvertToADTFVariantByType<int8_t>(oValue);
            break;
        case a_util::variant::VT_UInt8:
            oResultVariant = ConvertToADTFVariantByType<uint8_t>(oValue);
            break;
        case a_util::variant::VT_Int16:
            oResultVariant = ConvertToADTFVariantByType<int16_t>(oValue);
            break;
        case a_util::variant::VT_UInt16:
            oResultVariant = ConvertToADTFVariantByType<uint16_t>(oValue);
            break;
        case a_util::variant::VT_Int32:
            oResultVariant = ConvertToADTFVariantByType<int32_t>(oValue);
            break;
        case a_util::variant::VT_UInt32:
            oResultVariant = ConvertToADTFVariantByType<uint32_t>(oValue);
            break;
        case a_util::variant::VT_Int64:
            oResultVariant = ConvertToADTFVariantByType<int64_t>(oValue);
            break;
        case a_util::variant::VT_UInt64:
            oResultVariant = ConvertToADTFVariantByType<uint64_t>(oValue);
            break;
        case a_util::variant::VT_String:
            oResultVariant.Set(oValue.asString().c_str());
            break;
        case a_util::variant::VT_Empty:
            break;
        default:
            //do nothing here
            //null is also empty, VTArray was handled before
            break;
    }
    return oResultVariant;
}
 
inline a_util::variant::Variant ConvertToAUtilVariant(const cVariant& oValue)
{
    a_util::variant::Variant oResultVariant;
    bool bIsArray = oValue.IsArray();
    switch (oValue.GetType())
    {
        case adtf_util::VT_Bool:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetBool());
            }
            else
            {
                oResultVariant.reset(oValue.GetBoolArray(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_Float64:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetFloat64());
            }
            else
            {
                oResultVariant.reset(oValue.GetFloat64Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_Float32:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetFloat32());
            }
            else
            {
                oResultVariant.reset(oValue.GetFloat32Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_Int8:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetInt8());
            }
            else
            {
                oResultVariant.reset(oValue.GetInt8Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_UInt8:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetUInt8());
            }
            else
            {
                oResultVariant.reset(oValue.GetUInt8Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_Int16:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetInt16());
            }
            else
            {
                oResultVariant.reset(oValue.GetInt16Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_UInt16:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetUInt16());
            }
            else
            {
                oResultVariant.reset(oValue.GetUInt16Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_Int32:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetInt32());
            }
            else
            {
                oResultVariant.reset(oValue.GetInt32Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_UInt32:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetUInt32());
            }
            else
            {
                oResultVariant.reset(oValue.GetUInt32Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_Int64:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetInt64());
            }
            else
            {
                oResultVariant.reset(oValue.GetInt64Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_UInt64:
            if (!bIsArray)
            {
                oResultVariant = a_util::variant::Variant(oValue.GetUInt64());
            }
            else
            {
                oResultVariant.reset(oValue.GetUInt64Array(), oValue.GetArraySize());
            }
            break;
        case adtf_util::VT_String:
            oResultVariant = a_util::variant::Variant(oValue.GetStringPtr());
            break;
        case adtf_util::VT_Empty:
            break;
        default:
            break;
    }
    return oResultVariant;
}
 
inline bool GetVariantInfoIsString(const cVariant& oValue)
{
    return oValue.GetType() == adtf_util::VT_String;
}
 
inline bool GetVariantInfoIsUnsignedInt(const cVariant& oValue)
{
    switch (oValue.GetType())
    {
        case adtf_util::VT_Bool:
        case adtf_util::VT_UInt8:
        case adtf_util::VT_UInt16:
        case adtf_util::VT_UInt32:
        case adtf_util::VT_UInt64:
        case adtf_util::VT_Empty:
            return true;
        default:
            break;
    }
    return false;
}
 
} // namespace adtf_util