string.hpp

Go to the documentation of this file.

/*
Copyright (c) 2025 acrion innovations GmbH
Authors: Stefan Zipproth, s.zipproth@acrion.ch
 
This file is part of Cbeam, see https://github.com/acrion/cbeam and https://cbeam.org
 
Cbeam is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://acrion.ch/sales. For AGPL licensing, see below.
 
AGPL licensing:
 
Cbeam is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Cbeam is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with Cbeam. If not, see <https://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include <cbeam/platform/compiler_compatibility.hpp>
 
#include <time.h> // for localtime, strftime, time_t
 
#include <cctype> // std::tolower
 
#include <algorithm> // for std::transform
#include <chrono>    // for std::chrono::duration_cast, std::chrono::milliseconds, std::chrono::seconds, std::chrono::time_point
#include <codecvt>   // for std::codecvt_utf8_utf16, note https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html
#include <cstdint>   // for std::uintptr_t
#include <iomanip>   // for std::operator<<, std::setfill, std::setw
#include <locale>    // for std::wstring_convert, std::locale
 
#include <sstream>     // for std::basic_ostream, std::operator<<, std::stringstream, std::basic_ios::imbue, std::hex, std::showbase, std::istringstream, std::ostream
#include <stdexcept>   // for std::range_error
#include <string>      // for std::basic_string, std::char_traits, std::string, std::wstring, std::allocator
#include <type_traits> // for std::declval, std::enable_if, std::false_type, std::true_type, std::void_t
 
namespace cbeam::convert
{
    inline std::string indent(int indentation)
    {
        return std::string(indentation, '\t');
    }

    inline std::string to_lower(std::string s)
    {
        std::transform(s.begin(),
                       s.end(),
                       s.begin(),
                       [](unsigned char c)
                       { return (char)std::tolower(c); });
        return s;
    }

    inline std::string escape_string(const std::string& input, const char escape_character, const std::string& characters_to_escape)
    {
        std::ostringstream escaped;
        for (char ch : input)
        {
            if (characters_to_escape.find(ch) != std::string::npos)
            {
                escaped << escape_character;
            }
            escaped << ch;
        }
        return escaped.str();
    }

    inline std::string unescape_string(const std::string& input, char escape_character, const std::string& characters_to_unescape)
    {
        std::string result;
        result.reserve(input.size());
 
        auto it = input.begin();
        while (it != input.end())
        {
            char c = *it;
            if (c == escape_character && it + 1 != input.end() && characters_to_unescape.find(*(it + 1)) != std::string::npos)
            {
                result.push_back(*(++it));
            }
            else
            {
                result.push_back(c);
            }
            ++it;
        }
 
        return result;
    }

    template <typename T>
    T from_string(const std::string& str)
    {
        T                  result;
        std::istringstream istr(str);
        istr.imbue(std::locale("C"));
        istr >> result;
        return result;
    }

    template <>
    inline std::wstring from_string<std::wstring>(const std::string& str)
    {
        try
        {
            CBEAM_SUPPRESS_WARNINGS_PUSH() // note https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2872r2.pdf
            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
            CBEAM_SUPPRESS_WARNINGS_POP()
            return converter.from_bytes(str);
        }
        catch (const std::range_error&)
        {
            // Fallback to element-wise conversion in case of invalid UTF-8 input.
            // CBEAM_LOG_DEBUG is not used because it relies on these conversion methods.
            std::wstring converted;
            for (char c : str)
            {
                converted.push_back(static_cast<unsigned char>(c));
            }
            return converted;
        }
    }

    template <typename T, typename = void>
    struct has_insertion_operator : std::false_type
    {
    };
 
    template <typename T>
    struct has_insertion_operator<T, std::void_t<decltype(std::declval<std::ostream&>() << std::declval<T>())>> : std::true_type
    {
    };

    template <typename T>
    inline typename std::enable_if<has_insertion_operator<T>::value, std::string>::type to_string(const T& value)
    {
        std::stringstream stream;
        stream.imbue(std::locale("C"));
        stream << value;
        return stream.str();
    }

    template <typename T>
    inline std::string to_string(T* const& val)
    {
        std::stringstream stream;
        stream << std::hex << std::showbase << reinterpret_cast<std::uintptr_t>(val);
        return stream.str();
    }

    inline std::string to_string(const std::wstring& str)
    {
        try
        {
            CBEAM_SUPPRESS_WARNINGS_PUSH() // note https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2872r2.pdf
            std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
            CBEAM_SUPPRESS_WARNINGS_POP()
            return converter.to_bytes(str);
        }
        catch (const std::range_error&)
        {
            // Fallback to element-wise conversion in case of invalid UTF-16 input.
            // CBEAM_LOG_DEBUG is not used because it relies on these conversion methods.
            std::string converted;
            for (wchar_t c : str)
            {
                if ((c >> 8) != 0)
                {
                    converted.push_back(static_cast<char>(c >> 8));
                }
                if ((c & 0xff) != 0)
                {
                    converted.push_back(static_cast<char>(c & 0xff));
                }
            }
            return converted;
        }
    }

    template <typename T>
    inline std::string to_string(std::chrono::time_point<T> time)
    {
        char sRep[100];
        {
            time_t curr_time = T::to_time_t(time);
//            struct tm buffer;
//            localtime_s(&buffer, &curr_time);
#pragma warning(suppress : 4996) // The implementation of localtime_s in Microsoft CRT is incompatible with the C standard since it has reversed parameter order and returns errno_t.
            struct tm* buffer = localtime(&curr_time);
            strftime(sRep, sizeof(sRep), "%Y-%m-%d %H:%M:%S", buffer);
        }
 
        typename T::duration t  = time.time_since_epoch();
        auto                 ms = std::chrono::duration_cast<std::chrono::milliseconds>(t - std::chrono::duration_cast<std::chrono::seconds>(t));
 
        std::stringstream result;
        result << sRep << "." << std::setfill('0') << std::setw(3) << ms.count(); // append milliseconds 000..999
        return result.str();
    }

    template <typename T>
    std::wstring to_wstring(T value)
    {
        return from_string<std::wstring>(to_string(value));
    }
}