tb_string.hpp

 
#ifndef TurtleBrains_String_hpp
#define TurtleBrains_String_hpp
 
#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_types.hpp>
#include <turtle_brains/core/tb_error.hpp>
 
#include <sstream>
#include <string>
#include <vector>
 
 
#define tb_string(object)  TurtleBrains::Core::ToString((object))
 
 
namespace TurtleBrains::Core
{
 
    template<typename Type> std::string ToStdString(const Type& object)
    {
        std::stringstream ss;
        ss << object;
        return ss.str();
    }
 
    inline std::string ToStdString(const std::string& object)
    {
        return object;
    }
 
    inline std::string ToStdString(const std::wstring& object)
    {
        std::stringstream stream;
        const std::ctype<char>& ctfacet = std::use_facet< std::ctype<char> >(stream.getloc());
        for (size_t i = 0; i < object.size(); ++i)
        {
            stream << static_cast<char>(ctfacet.narrow(static_cast<char>(object[i]), '?'));
        }
        return stream.str();
    }
 
    inline std::string ToStdString(const wchar_t* object)
    {
        return ToStdString(std::wstring(object));
    }
 
    inline std::string ToStdString(float value, int precision = -1)
    {
        std::stringstream ss;
        if (precision >= 0)
        {
            ss.precision(precision);
            ss << std::fixed;
        }
        ss << value;
        return ss.str();
    }
 
    inline std::string ToStdString(double value, int precision = -1)
    {
        std::stringstream ss;
        if (precision >= 0)
        {
            ss.precision(precision);
            ss << std::fixed;
        }
        ss << value;
        return ss.str();
    }
 
    template<typename Type> Type FromStdString(const std::string& input)
    {
        // 2026-01-02: This was added 2025-11-15 for an unknown reason. I don't have the context on that anymore but I
        //   would assume it was because something crashed deeper when the input was empty. However, the overloaded
        //   operator<<() function should be handling error conditions when building the Type, such as a UUID returning
        //   an invalid uuid key; expected by TrackBuilder, so the error check is now removed again.
        //
        //tb_error_if(true == input.empty(), "Invalid value for parameter: input, expected valid, non-empty, string.");
        Type object;
        std::stringstream ss(input);
        ss >> object;
        return object;
    }
 
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
 
    template<typename Type> std::wstring ToWideString(const Type& object)
    {
        std::wstringstream wss;
        wss << object;
        return wss.str();
    }
 
    inline std::wstring ToWideString(const std::wstring& object)
    {
        return object;
    }
 
    inline std::wstring ToWideString(const std::string& object)
    {
        std::wostringstream stream;
        const std::ctype<wchar_t>& ctfacet = std::use_facet< std::ctype<wchar_t> >(stream.getloc());
        for (size_t i = 0; i < object.size(); ++i)
        {
            stream << ctfacet.widen(object[i]);
        }
        return stream.str();
    }
 
    inline std::wstring ToWideString(const char* object)
    {
        return ToWideString(std::string(object));
    }
 
    inline std::wstring ToWideString(float value, int precision = -1)
    {
        std::wstringstream wss;
        if (precision >= 0)
        {
            wss.precision(precision);
            wss << std::fixed;
        }
        wss << value;
        return wss.str();
    }
 
    inline std::wstring ToWideString(double value, int precision = -1)
    {
        std::wstringstream wss;
        if (precision >= 0)
        {
            wss.precision(precision);
            wss << std::fixed;
        }
        wss << value;
        return wss.str();
    }
 
    template<typename Type> Type FromWideString(const std::wstring& input)
    {
        // 2026-01-02: This was added 2025-11-15 for an unknown reason. I don't have the context on that anymore but I
        //   would assume it was because something crashed deeper when the input was empty. However, the overloaded
        //   operator<<() function should be handling error conditions when building the Type, such as a UUID returning
        //   an invalid uuid key; expected by TrackBuilder, so the error check is now removed again.
        //
        //tb_error_if(true == input.empty(), "Invalid value for parameter: input, expected valid, non-empty, string.");
        Type object;
        std::wstringstream wss(input);
        wss >> object;
        return object;
    }
 
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
 
#ifdef tb_with_wide_string
    typedef std::wstring String;
#else
    typedef std::string String;
#endif /* tb_with_wide_string */
 
    template<typename Type> String ToString(const Type& object)
    {
#ifdef tb_with_wide_string
        return TurtleBrains::Core::ToWideString(object);
#else
        return TurtleBrains::Core::ToStdString(object);
#endif /* tb_with_wide_string */
    }
 
    inline String ToString(float value, int precision = -1)
    {
#ifdef tb_with_wide_string
        return TurtleBrains::Core::ToWideString(value, precision);
#else
        return TurtleBrains::Core::ToStdString(value, precision);
#endif /* tb_with_wide_string */
    }
 
    inline String ToString(double value, int precision = -1)
    {
#ifdef tb_with_wide_string
        return TurtleBrains::Core::ToWideString(value, precision);
#else
        return TurtleBrains::Core::ToStdString(value, precision);
#endif /* tb_with_wide_string */
    }
 
    template<typename Type> Type FromString(const std::string& input)
    {
        return TurtleBrains::Core::FromStdString<Type>(input);
    }
 
    template<typename Type> Type FromString(const std::wstring& input)
    {
        return TurtleBrains::Core::FromWideString<Type>(input);
    }
 
}; /* namespace TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
namespace TurtleBrains
{
    using String = tbCore::String;
};
 
// 2025-11-11: Yea yea yea... We are trying to rip this out, but I need Rushcremental to remain the focus on 100 day game
//   days and not play with TurtleBrains for 5 hours removing the rest of the tbString from macOS and Linux etc. So remove
//   this once we get to it in the api cleanup.
namespace TurtleBrains::Core
{
    using tbString = String;
};
 
#endif /* TurtleBrains_String_hpp */