propertyconvert.h

Go to the documentation of this file.

#pragma once
#include "chrono.h"
#include "property_intf.h"
#include "adtf_base_type_traits.h"
#include "string_conversion.h"
 
#include <string>
#include <limits>
 
#ifdef max
    #undef max
#endif
 
namespace adtf
{
namespace base
{
template<typename TYPE>
struct property_type_conversion
{
    static tResult Convert(const IPropertyValue& oPropertyType, TYPE& oToValue)
    {
        static_assert(adtf::base::penguin::detail::always_false<TYPE>,
                      "Unsupported type! Use bool, int8_t, uint8_t, .. float, double or adtf_util::cString."
                      "Otherwise specialize this property_type_conversion template!");
        return ERR_NOT_IMPL;
    }
    static tResult ToString(const adtf_util::cString& oFromValue, TYPE& strToString)
    {
        static_assert(adtf::base::penguin::detail::always_false<TYPE>,
                      "Unsupported type! Use bool, int8_t, uint8_t, .. float, double or adtf_util::cString."
                      "Otherwise specialize this property_type_conversion template!");
        return ERR_NOT_IMPL;
    }
    static tResult FromString(const adtf_util::cString& strFromString, TYPE& oToValue)
    {
        static_assert(adtf::base::penguin::detail::always_false<TYPE>,
                      "Unsupported type! Use bool, int8_t, uint8_t, .. float, double or adtf_util::cString."
                      "Otherwise specialize this property_type_conversion template!");
        return ERR_NOT_IMPL;
    }
    static tResult ToRaw(const void* pData, const size_t szDataSize, IRawMemory& oToMem)
    {
        static_assert(adtf::base::penguin::detail::always_false<TYPE>,
                      "Unsupported type! Use bool, int8_t, uint8_t, .. float, double or adtf_util::cString."
                      "Otherwise specialize this property_type_conversion template!");
        return ERR_NOT_IMPL;
    }
    static tResult FromRaw(const IRawMemory& oFromMem, void* pData, const size_t szDataSize)
    {
        static_assert(adtf::base::penguin::detail::always_false<TYPE>,
                      "Unsupported type! Use bool, int8_t, uint8_t, .. float, double or adtf_util::cString."
                      "Otherwise specialize this property_type_conversion template!");
        return ERR_NOT_IMPL;
    }
};

struct cPropertyConvert
{
    static tResult FromString(const adtf_util::cString& strValue, bool& bValue)
    {
        adtf::util::cStringUtil::ToType(strValue, bValue);
        RETURN_NOERROR;
    }
 
    template<typename T>
    static tResult FromString(const adtf_util::cString& strValue, T& oValue)
    {
        std::string_view strHelper(strValue.GetPtr());
        if (strHelper.empty())
        {
            oValue = T{};
        }
        else
        {
            try
            {
                oValue = string_conversion::to_number<T>(strHelper, 0);
            }
            catch (const std::overflow_error&)
            {
                if (strHelper.front() != '-')
                {
                    oValue = std::numeric_limits<T>::max();
                }
                else
                {
                    oValue = std::numeric_limits<T>::lowest();
                }
            }
            catch (const std::exception&)
            {
                bool bHelper = false;
                adtf::util::cStringUtil::ToType(strValue.GetPtr(), bHelper);
                oValue = static_cast<T>(bHelper);
            }
        }
        RETURN_NOERROR;
    }
 
    static tResult ToString(const bool& oValue, adtf_util::cString& strValue)
    {
        strValue.Set(adtf_util::cString::FromType(oValue));
        RETURN_NOERROR;
    }
 
    template<typename TYPE>
    static tResult ToString(const TYPE& oValue, adtf_util::cString& strValue)
    {
        strValue.Set(string_conversion::to_string(oValue).c_str());
        RETURN_NOERROR;
    }
 
    static tResult FromString(const adtf_util::cString& strValue, adtf_util::cString& oValue)
    {
        oValue.Set(strValue);
        RETURN_NOERROR;
    }
 
    static tResult ToString(const adtf_util::cString& oValue, adtf_util::cString& strValue)
    {
        strValue.Set(oValue);
        RETURN_NOERROR;
    }
    static tResult ToRaw(const void* pData, const size_t szSizeOfData, IRawMemory& oToMem);
    static tResult FromRaw(const IRawMemory& oFromMem, void* pData, const size_t szSizeOfData);
 
    static tResult Convert(const IPropertyValue& oProp, bool& oValue);
    static tResult Convert(const IPropertyValue& oProp, uint64_t& oValue);
    static tResult Convert(const IPropertyValue& oProp, int64_t& oValue);
    static tResult Convert(const IPropertyValue& oProp, uint32_t& oValue);
    static tResult Convert(const IPropertyValue& oProp, int32_t& oValue);
    static tResult Convert(const IPropertyValue& oProp, uint16_t& oValue);
    static tResult Convert(const IPropertyValue& oProp, int16_t& oValue);
    static tResult Convert(const IPropertyValue& oProp, uint8_t& oValue);
    static tResult Convert(const IPropertyValue& oProp, int8_t& oValue);
    static tResult Convert(const IPropertyValue& oProp, float& oValue);
    static tResult Convert(const IPropertyValue& oProp, double& oValue);
};

template<typename TYPE>
struct property_type_default_conversion
{
    static tResult Convert(const IPropertyValue& oProp, TYPE& oValue)
    {
        return cPropertyConvert::Convert(oProp, oValue);
    }
 
    static tResult ToString(const TYPE& oValue, adtf_util::cString& strValue)
    {
        return cPropertyConvert::ToString(oValue, strValue);
    }
 
    static tResult FromString(const adtf_util::cString& strValue, TYPE& oValue)
    {
        return cPropertyConvert::FromString(strValue, oValue);
    }
 
    static tResult ToRaw(const void* pData, const size_t szSizeOfData, IRawMemory& oToMem)
    {
        return cPropertyConvert::ToRaw(pData, szSizeOfData, oToMem);
    }
 
    static tResult FromRaw(const IRawMemory& oFromMem, void* pData, const size_t szSizeOfData)
    {
        return cPropertyConvert::FromRaw(oFromMem, pData, szSizeOfData);
    }
};

struct cPropertyStringConversion
{
    static tResult Convert(const IPropertyValue& oPropertyType, adtf_util::cString& oToValue);
    static tResult ToString(const adtf_util::cString& oFromValue, adtf_util::cString& strToString);
    static tResult FromString(const adtf_util::cString& strFromString, adtf_util::cString& oToValue);
    static tResult ToRaw(const void* pData, const size_t szDataSize, IRawMemory& oToMem);
    static tResult FromRaw(const IRawMemory& oFromMem, void* pData, const size_t szDataSize);
};

struct cFilenameConversion
{
    static tResult Convert(const IPropertyValue& oProp, adtf_util::cFilename& oValue);
    static tResult FromString(const adtf_util::cString& oFromValue, adtf_util::cFilename& strToString);
    static tResult ToString(const adtf_util::cFilename& strFromString, adtf_util::cString& oToValue);
    static tResult ToRaw(const void* pData, const size_t szSizeOfData, adtf::base::ant::IRawMemory& oToMem);
    static tResult FromRaw(const IRawMemory& oFromMem, void* pData, const size_t szSizeOfData);
};

struct cFilenameListConversion
{
    static tResult Convert(const IPropertyValue& oProp, adtf_util::cFilenameList& oValue);
    static tResult FromString(const adtf_util::cString& oFromValue, adtf_util::cFilenameList& strToString);
    static tResult ToString(const adtf_util::cFilenameList& strFromString, adtf_util::cString& oToValue);
 
    static tResult Convert(const IPropertyValue& oProp, adtf_util::cFilepathList& oValue);
    static tResult FromString(const adtf_util::cString& oFromValue, adtf_util::cFilepathList& strToString);
    static tResult ToString(const adtf_util::cFilepathList& strFromString, adtf_util::cString& oToValue);
 
    static tResult ToRaw(const void* pData, const size_t szSizeOfData, IRawMemory& oToMem);
    static tResult FromRaw(const IRawMemory& oFromMem, void* pData, const size_t szSizeOfData);
};

template<typename TYPE>
struct property_type_conversion_nothing
{
    static tResult Convert(const IPropertyValue& /* oPropertyType */, TYPE& oToValue)
    {
        oToValue = TYPE();
        RETURN_NOERROR;
    }
    static tResult ToString(const TYPE& /* oFromValue */, adtf_util::cString& strToString)
    {
        strToString.Set("");
        RETURN_NOERROR;
    }
    static tResult FromString(const adtf_util::cString& /* strFromString */, TYPE& oToValue)
    {
        oToValue = TYPE();
        RETURN_NOERROR;
    }
    static tResult ToRaw(const void* /* pData */, const size_t /* szDataSize */, IRawMemory& /* oToMem */)
    {
        RETURN_NOERROR;
    }
    static tResult FromRaw(const IRawMemory& /* oFromMem */, void* /* pData */, const size_t /* szDataSize */)
    {
        RETURN_NOERROR;
    }
};

struct cPropertyNanoSecondsConversion
{
    static tResult Convert(const IPropertyValue& oPropertyType, flash::tNanoSeconds& oToValue);
    static tResult ToString(const flash::tNanoSeconds& tmNanoSeconds, adtf_util::cString& strToString);
    static tResult FromString(const adtf_util::cString& strFromString, flash::tNanoSeconds& tmNanoSeconds);
    static tResult ToRaw(const void* pData, size_t szDataSize, IRawMemory& oToMem);
    static tResult FromRaw(const IRawMemory& oFromMem, void* pData, size_t szDataSize);
};

struct cPropertyStdStringConversion
{
    static tResult Convert(const IPropertyValue& oPropertyType, std::string& oToValue);
    static tResult ToString(const std::string& strFrom, adtf_util::cString& strToString);
    static tResult FromString(const adtf_util::cString& strFromString, std::string& strToString);
    static tResult ToRaw(const void* pData, size_t szDataSize, IRawMemory& oToMem);
    static tResult FromRaw(const IRawMemory& oFromMem, void* pData, size_t szDataSize);
};
 
} // namespace base
} // namespace adtf