convert_string.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <tuple>
#include <vector>
#include <string>
#include <cstdint>
#include <optional>
#include <algorithm>
#include <string_view>
 
namespace utility_module
{
    class convert_string
    {
    public:
        static auto to_string(const std::wstring& value)
            -> std::tuple<std::optional<std::string>, std::optional<std::string>>;
 
        static auto to_string(std::wstring_view value)
            -> std::tuple<std::optional<std::string>, std::optional<std::string>>;
 
        static auto to_wstring(const std::string& value)
            -> std::tuple<std::optional<std::wstring>, std::optional<std::string>>;
 
        static auto to_wstring(std::string_view value)
            -> std::tuple<std::optional<std::wstring>, std::optional<std::string>>;
 
        static auto get_system_code_page() -> int;
 
        static auto system_to_utf8(const std::string& value)
            -> std::tuple<std::optional<std::string>, std::optional<std::string>>;
 
        static auto utf8_to_system(const std::string& value)
            -> std::tuple<std::optional<std::string>, std::optional<std::string>>;
 
        static auto split(const std::string& source, const std::string& token)
            -> std::tuple<std::optional<std::vector<std::string>>, std::optional<std::string>>;
 
        static auto to_array(const std::string& value)
            -> std::tuple<std::optional<std::vector<uint8_t>>, std::optional<std::string>>;
 
        static auto to_string(const std::vector<uint8_t>& value)
            -> std::tuple<std::optional<std::string>, std::optional<std::string>>;
 
        static auto to_base64(const std::vector<uint8_t>& value)
            -> std::tuple<std::optional<std::string>, std::optional<std::string>>;
 
        static auto from_base64(const std::string& base64_str)
            -> std::tuple<std::vector<uint8_t>, std::optional<std::string>>;
 
        static auto replace(std::string& source,
                            const std::string& token,
                            const std::string& target) -> std::optional<std::string>;
 
        static auto replace2(const std::string& source,
                             const std::string& token,
                             const std::string& target)
            -> std::tuple<std::optional<std::string>, std::optional<std::string>>;
 
    private:
        enum class endian_types
        {
            little, 
            big,    
            unknown 
        };
 
        enum class encoding_types
        {
            utf8,  
            utf16, 
            utf32  
        };
 
        static auto get_code_page_name(int code_page) -> std::string;
 
        static auto get_encoding_name(encoding_types encoding,
                                      endian_types endian = endian_types::little) -> std::string;
 
        static auto get_wchar_encoding(endian_types endian = endian_types::little) -> std::string;
 
        template <typename FromType, typename ToType>
        static auto convert(const FromType& value,
                            const std::string& from_encoding,
                            const std::string& to_encoding)
            -> std::tuple<std::optional<ToType>, std::optional<std::string>>;
 
        static auto detect_endian(const std::u16string& value) -> endian_types;
 
        static auto detect_endian(const std::u32string& value) -> endian_types;
 
        static auto has_utf8_bom(const std::string& value) -> bool;
 
        static auto remove_utf8_bom(const std::string& value) -> std::string;
 
        static auto add_utf8_bom(const std::string& value) -> std::string;
 
        static auto base64_encode(const std::vector<uint8_t>& data) -> std::string;
 
        static auto base64_decode(const std::string& base64_str)
            -> std::tuple<std::vector<uint8_t>, std::optional<std::string>>;
    };
} // namespace utility_module