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
{
namespace ant
{
    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;
        }
    };
 
} //ant
 
namespace flash
{

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);
};
 
}
 
using ant::property_type_conversion;
using ant::property_type_default_conversion;
using ant::cPropertyStringConversion;
        
} //base
} //adtf
 
 
 
 
//*************************************************************************************************