tb_string.hpp

#ifndef TurtleBrains_String_hpp
#define TurtleBrains_String_hpp

#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_error.hpp>

#include <sstream>
#include <string>


#define tb_string(object)  TurtleBrains::Core::ToString((object))


namespace TurtleBrains
{
    namespace Core
    {

        template <typename T> std::string ToStdString(const T& 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();
        }

        template <typename T> T FromStdString(const std::string& input)
        {
            tb_error_if(true == input.empty(), "Invalid value for parameter: input, expected valid, non-empty, string.");
            T object;
            std::stringstream ss(input);
            ss >> object;
            return object;
        }

        template <typename T> T FromString(const std::string& input)
        {
            return FromStdString<T>(input);
        }

//-------------------------------------------------------------------------------------------------------------------//
//-------------------------------------------------------------------------------------------------------------------//
//-------------------------------------------------------------------------------------------------------------------//

        template <typename T> std::wstring ToWideString(const T& 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();
        }

        template <typename T> T FromWideString(const std::wstring& input)
        {
            tb_error_if(true == input.empty(), "Invalid value for parameter: input, expected valid, non-empty, string.");
            T object;
            std::wstringstream wss(input);
            wss >> object;
            return object;
        }

        template <typename T> T FromString(const std::wstring& input)
        {
            return FromWideString<T>(input);
        }

//-------------------------------------------------------------------------------------------------------------------//
//-------------------------------------------------------------------------------------------------------------------//
//-------------------------------------------------------------------------------------------------------------------//

#ifdef tb_with_wide_string
        typedef std::wstring tbString;
//      class tbString : public std::wstring
//      {
//      public:
//          tbString(void) : std::wstring(L"") { }
//          tbString(const tbString& input) : std::wstring(input.c_str()) { }
//          tbString(const std::wstring& input) : std::wstring(input) { }
//          tbString(const std::string& input) : std::wstring(ToWideString(input)) { }
//          tbString(const wchar_t* input) : std::wstring(input) { }
//          tbString(const char* input) : std::wstring(ToWideString(input)) { }
//
//          tbString& operator=(const tbString& input) { std::wstring::operator=(input.c_str()); return *this; }
//          tbString& operator=(const std::wstring& input) { std::wstring::operator=(input); return *this; }
//          tbString& operator=(const std::string& input) { std::wstring::operator=(ToWideString(input)); return *this; }
//          tbString& operator=(const wchar_t* input) { std::wstring::operator=(input); return *this; }
//          tbString& operator=(const char* input) { std::wstring::operator=(ToWideString(input)); return *this; }
//
//          friend tbString operator+(const std::string& leftSide, const tbString& rightSide) { return ToWideString(leftSide) + rightSide.c_str(); }
//          friend tbString operator+(const char* leftSide, const tbString& rightSide) { return ToWideString(leftSide) + rightSide.c_str(); }
//
//      //          tbString operator+(const tbString& input) { return std::wstring::operator+(std::wstring(input.c_str())); }
//      //          tbString operator+(const std::wstring& input) { return std::wstring::operator+(input); }
//      //          tbString operator+(const std::string& input) { return std::wstring::operator+(ToWideString(input)); }
//      //          tbString operator+(const wchar_t* input) { return std::wstring::operator+(input); }
//      //          tbString operator+(const char* input) { return std::wstring::operator+(ToWideString(input.c_str())); }
//
//          operator const void*(void) const { return c_str(); }
//
//          //operator const wchar_t*(void) const { return c_str(); }
//
//          //std::istream& operator>>(std::istream& inputStream) { std::wstring s; inputStream >> s; *this = s; return inputStream; }
//      };
#else
        typedef std::string tbString;
//  class tbString : public std::string
//  {
//  public:
//      tbString(void) : std::string("") { }
//      tbString(const tbString& input) : std::string(input.c_str()) { }
//      tbString(const std::wstring& input) : std::string(ToStdString(input)) { }
//      tbString(const std::string& input) : std::string(input) { }
//      tbString(const wchar_t* input) : std::string(ToStdString(input)) { }
//      tbString(const char* input) : std::string(input) { }
//
//      tbString& operator=(const tbString& input) { std::string::operator=(input.c_str()); return *this; }
//      tbString& operator=(const std::wstring& input) { std::string::operator=(ToStdString(input)); return *this; }
//      tbString& operator=(const std::string& input) { std::string::operator=(input); return *this; }
//      tbString& operator=(const wchar_t* input) { std::string::operator=(ToStdString(input)); return *this; }
//      tbString& operator=(const char* input) { std::string::operator=(input); return *this; }
//
//      friend tbString operator+(const std::wstring& leftSide, const tbString& rightSide) { return ToStdString(leftSide) + rightSide.c_str(); }
//      friend tbString operator+(const wchar_t* leftSide, const tbString& rightSide) { return ToStdString(leftSide) + rightSide.c_str(); }
//
//      operator const void*(void) const { return c_str(); }
//  };

#endif /* tb_with_wide_string */

        template <typename T> tbString ToString(const T& object)
        {
#ifdef tb_with_wide_string
            return ToWideString(object);
#else
            return ToStdString(object);
#endif /* tb_with_wide_string */
        }

        inline tbString ToString(float value, int precision = 0)
        {
#ifdef tb_with_wide_string
            return ToWideString(value, precision);
#else
            return ToStdString(value, precision);
#endif /* tb_with_wide_string */
        }

        inline bool StringContains(const tbString& input, const tbString& contents)
        {
            return (tbCore::tbString::npos == input.find(contents)) ? false : true;
        }

        inline bool StringStartsWith(const tbString& input, const tbString& contents)
        {
            return (0 == input.find(contents)) ? true : false;
        }

    }; /* namespace Core */
}; /* namespace TurtleBrains */

//          inline operator float*(void) { return mFloatArray; }

//std::string& operator=(std::string& leftSide, const std::wstring& rightSide) { lhs = TurtleBrains::Core::ToStdString(rightSide); return leftSide; }
//std::wstring& operator=(std::wstring& leftSide, const std::string& rightSide) { lhs = TurtleBrains::Core::ToWideString(rightSide); return rightSide; }

//operator() std::string(const std::wstring& input) { return TurtleBrains::Core::ToStdString(input); }
//std::wstring operator(const std::string& input) { return TurtleBrains::Core::ToWideString(input); }

namespace tbCore = TurtleBrains::Core;

#endif /* TurtleBrains_String_hpp */