StringUtil.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
 
#ifndef IMT_BASE_LIB_STRINGS_STRINGUTIL_H
#define IMT_BASE_LIB_STRINGS_STRINGUTIL_H
 
#include <Imt.Base.Core.Platform/Platform.h>
#include <Imt.Base.Core.Platform/StaticClass.h>
 
#ifdef USE_STL
 
namespace imt {
namespace base {
namespace lib {
namespace strings {
 
// AXIVION Next Construct AutosarC++19_03-M3.4.1: No definition in primary file to separate concerns.
class StringUtil final : private ::imt::base::core::platform::StaticClass {
 
public:
 
    template<typename Type>
    static inline bool stringToValue(std::wstring const& s, Type& returnValue, std::ios_base& (*const func)(std::ios_base&)) noexcept {
        std::wistringstream iss {s};
        // AXIVION Next Line AutosarC++19_03-A18.0.2
        return !((iss >> func >> returnValue).fail());
    }
 
    template<typename Type>
    static inline bool stringToValue(std::wstring const& s, Type& returnValue) noexcept {
        std::wistringstream iss {s};
        // AXIVION Next Line AutosarC++19_03-A18.0.2
        return !((iss >> returnValue).fail());
    }
 
    template<typename Type>
    static inline std::wstring valueToString(Type const& inputValue, std::ios_base& (*const func)(std::ios_base&)) noexcept {
        std::wostringstream oss {};
        oss << func << inputValue;
        return oss.str();
    }
 
    template<typename Type>
    static inline std::wstring valueToString(Type const& inputValue) noexcept {
        std::wostringstream oss {};
        oss << inputValue;
        return oss.str();
    }
 
    static inline std::wstring valueToString(float32_t const inputValue, uint8_t const precision) {
        std::wostringstream oss {};
        oss.precision(static_cast<int32_t>(precision)); // AXIVION Line AutosarC++19_03-A0.1.2 AutosarC++19_03-M0.3.2: required Construct
        oss << std::fixed;
        oss << inputValue;
        return oss.str();
    }
 
    static inline std::wstring valueToString(float64_t const inputValue, uint8_t const precision) {
        std::wostringstream oss {};
        oss.precision(static_cast<int32_t>(precision)); // AXIVION Line AutosarC++19_03-A0.1.2 AutosarC++19_03-M0.3.2: required Construct
        oss << std::fixed;
        oss << inputValue;
        return oss.str();
    }
 
    static int8_t compareNoCase(std::wstring const& str1, std::wstring const& str2);
 
    static bool equalsNoCase(std::wstring const& str1, std::wstring const& str2);
 
    static void trim(std::wstring& str);
 
    static void replace(std::wstring& str, std::wstring const& oldValue, std::wstring const& newValue);
 
    static void removeBlanks(std::wstring& str);
 
    static int32_t toInt(std::wstring const& str);
 
    static uint32_t toUInt(std::wstring const& str);
 
    static int32_t hexToInt(std::wstring const& str);
 
    static float32_t toFloat(std::wstring const& str);
 
    static float64_t toDouble(std::wstring const& str);
 
    static bool toBool(std::wstring const& str);
 
    static bool isDecLiteral(std::wstring const& str);
 
    static bool isHexLiteral(std::wstring const& str);
 
    static bool contains(std::wstring const& str, wchar_t const c);
 
    static bool contains(std::wstring const& str, std::wstring const& chars);
 
private:
 
    static void trimLeft(std::wstring& str);
    static void trimRight(std::wstring& str);
};
 
//Justification: Specialization of 8bit types, as these can not be converted by default
 
// AXIVION Next Construct AutosarC++19_03-A14.8.2: Specialization of 8bit types, as these can not be converted by default
// AXIVION Next Construct AutosarC++19_03-A8.4.8: Use output parameter for compatibility
// AXIVION Next Construct AutosarC++19_03-A8.4.4: Use output parameter instead of return value for compatibility
// AXIVION Next Construct AutosarC++19_03-A8.4.9: Is not an in-out parameter but only a output parameter so it is not read
template<>
inline bool StringUtil::stringToValue<uint8_t>(std::wstring const& s, uint8_t& returnValue, std::ios_base& (*const func)(std::ios_base&)) noexcept {
    uint16_t value {0U};
    bool const result {stringToValue<uint16_t>(s, value, func)};
    returnValue = static_cast<uint8_t>(value);
    return result;
}
 
// AXIVION Next Construct AutosarC++19_03-A14.8.2: Specialization of 8bit types, as these can not be converted by default
// AXIVION Next Construct AutosarC++19_03-A8.4.8: Use output parameter for compatibility
// AXIVION Next Construct AutosarC++19_03-A8.4.4: Use output parameter instead of return value for compatibility
// AXIVION Next Construct AutosarC++19_03-A8.4.9: Is not an in-out parameter but only a output parameter so it is not read
template<>
inline bool StringUtil::stringToValue<int8_t>(std::wstring const& s, int8_t& returnValue, std::ios_base& (*const func)(std::ios_base&)) noexcept {
    int16_t value {0};
    bool const result {stringToValue<int16_t>(s, value, func)};
    returnValue = static_cast<int8_t>(value);
    return result;
}
 
// AXIVION Next Construct AutosarC++19_03-A14.8.2: Specialization of 8bit types, as these can not be converted by default
// AXIVION Next Construct AutosarC++19_03-A8.4.8: Use output parameter for compatibility
// AXIVION Next Construct AutosarC++19_03-A8.4.4: Use output parameter instead of return value for compatibility
// AXIVION Next Construct AutosarC++19_03-A8.4.9: Is not an in-out parameter but only a output parameter so it is not read
template<>
inline bool StringUtil::stringToValue<uint8_t>(std::wstring const& s, uint8_t& returnValue) noexcept {
    uint16_t value {0U};
    bool const result {stringToValue<uint16_t>(s, value)};
    returnValue = static_cast<uint8_t>(value);
    return result;
}
 
// AXIVION Next Construct AutosarC++19_03-A14.8.2: Specialization of 8bit types, as these can not be converted by default
// AXIVION Next Construct AutosarC++19_03-A8.4.8: Use output parameter for compatibility
// AXIVION Next Construct AutosarC++19_03-A8.4.4: Use output parameter instead of return value for compatibility
// AXIVION Next Construct AutosarC++19_03-A8.4.9: Is not an in-out parameter but only a output parameter so it is not read
template<>
inline bool StringUtil::stringToValue<int8_t>(std::wstring const& s, int8_t& returnValue) noexcept {
    int16_t value {0};
    bool const result {stringToValue<int16_t>(s, value)};
    returnValue = static_cast<int8_t>(value);
    return result;
}
 
// AXIVION Next Routine AutosarC++19_03-A16.0.1: Disable precompiler decision rule
#if defined(__IAR_SYSTEMS_ICC__)
// Due to the IAR compiler, some conversion functions must be specialized
 
template<>
inline std::wstring StringUtil::valueToString<uint8_t>(uint8_t const& inputValue, std::ios_base& (*const func)(std::ios_base&)) {
    return valueToString<uint16_t>(inputValue, func);
}
 
template<>
inline std::wstring StringUtil::valueToString<int8_t>(int8_t const& inputValue, std::ios_base& (*const func)(std::ios_base&)) {
    return valueToString<int16_t>(inputValue, func);
}
 
template<>
inline std::wstring StringUtil::valueToString<uint8_t>(uint8_t const& inputValue) {
    return valueToString<uint16_t>(inputValue);
}
 
template<>
inline std::wstring StringUtil::valueToString<int8_t>(int8_t const& inputValue) {
    return valueToString<int16_t>(inputValue);
}
#endif //__IAR_SYSTEMS_ICC__
 
} // namespace strings
} // namespace lib
} // namespace base
} // namespace imt
 
#endif // USE_STL
#endif // IMT_BASE_LIB_STRINGS_STRINGUTIL_H