StringTool.h

Go to the documentation of this file.

#pragma once
#include <Base/String.h>
#include <iomanip>
#include <sstream>
#include <QString>        // for QString
 
class QUuid;
 
namespace Base
{
class GlobalId;
class LX_BASE_EXPORT StringTool
{
public:
    template <typename T>
    static std::string toStlString(const T& t)
    {
        std::stringstream ss;
        ss << t;
        return ss.str();
    }
 
    template <typename T>
    static std::string toStlString(const T& t, int precision)
    {
        std::stringstream ss;
        ss.precision(precision);
        ss << t;
        return ss.str();
    }
 
    template <typename T>
    static std::string toStlString(const T& t, int fieldWidth, char fillChar)
    {
        std::stringstream ss;
        ss << std::setfill(fillChar) << std::setw(fieldWidth) << t;
        return ss.str();
    }
 
    static std::string toStlString(const bool& b, int fieldWidth, char fillChar)
    {
        std::string str;
        if (b)
            str = std::string("true");
        else
            str = std::string("false");
 
        std::stringstream ss;
        ss << std::setfill(fillChar) << std::setw(fieldWidth) << str;
        return ss.str();
    }
 
    static std::string toStlString(const bool& b) { return b ? "true" : "false"; }
 
    static std::string toStlString(const QString& str);
 
    template <typename T>
    static Base::String toString(const T& t)
    {
        std::wstringstream ss;
        ss << t;
        return ss.str();
    }
 
    template <typename T>
    static Base::String toString(const T& t, int precision)
    {
        std::wstringstream ss;
        ss.precision(precision);
        ss << t;
        return ss.str();
    }
 
    template <typename T>
    static Base::String toString(const T& t, int fieldWidth, wchar_t fillChar)
    {
        std::wstringstream ss;
        ss << std::setfill(fillChar) << std::setw(fieldWidth) << t;
        return ss.str();
    }
 
 
    static Base::String toString(const bool& b, int fieldWidth, wchar_t fillChar)
    {
        Base::String str;
        if (b)
            str = L"true";
        else
            str = L"false";
 
        std::wstringstream ss;
        ss << std::setfill(fillChar) << std::setw(fieldWidth) << str._utf16string;
        return ss.str();
    }
 
 
    static Base::String toString(const bool& b)
    {
        if (b)
            return L"true";
        else
            return L"false";
    }
 
    static std::string toUpper(const std::string& str);
    static std::string toLower(const std::string& str);
    static Base::String toUpper(const Base::String& str);
    static Base::String toLower(const Base::String& str);
 
    static std::string trimLeft(const std::string& str);
    static std::string trimRight(const std::string& str);
    static std::string trim(const std::string& str);
    static Base::String trimLeft(const Base::String& str);
    static Base::String trimRight(const Base::String& str);
    static Base::String trim(const Base::String& str);
 
    static std::string replace(const std::string& str, const std::string& src, const std::string& rpl);
    static Base::String replace(const Base::String& str, const Base::String& src, const Base::String& rpl);
 
    static bool isEmpty(const std::string& str);
    static bool isEmpty(const Base::String& str);
 
    static bool toBool(const std::string& str, bool* ok = 0);
    static bool toBool(const char* str, bool* ok = 0);
    static bool toBool(const Base::String& str, bool* ok = 0);
    static double toDouble(const std::string& str, bool* ok = 0);
    static double toDouble(const char* str, bool* ok = 0);
    static double toDouble(const Base::String& str, bool* ok = 0);
    static float toFloat(const std::string& str, bool* ok = 0);
    static uint8_t toUInt8(const std::string& str, bool* ok);
    static uint8_t toUInt8(const Base::String& str, bool* ok);
    static uint32_t toUInt32(const std::string& str, bool* ok);
    static uint32_t toUInt32(const Base::String& str, bool* ok);
    static uint64_t toUInt64(const std::string& str, bool* ok);
    static uint64_t toUInt64(const Base::String& str, bool* ok);
    static int toInt(const std::string& str, bool* ok = 0);
    static int toInt(const Base::String& str, bool* ok = 0);
    static char toChar(const std::string& str, bool* ok = 0);
    static Base::String toUtf16(const std::string& utf8string);
    static std::string toUtf8(const Base::String& widestring);
    static std::wstring toWString(const Base::String& str);
    static Base::String toString(const std::string& str);
    static std::string toStlString(const Base::String& str);
 
 
    static std::string toLegal(const std::string& str);
    static std::string createGuidString();
    static bool toUuid(const std::string& ifcguid, QUuid& uuid);
    static bool toGUID(const std::string& ifcguid, std::string& guid);
    static bool toBase64String(const std::string& in, std::string& out);
    static bool toBase64String(const QUuid& in, std::string& out);
    static bool toBase64String(const Base::GlobalId& in, Base::String& out);
    static bool isValidIfcBase64String(const std::string& ifcguid);
    static QString toQString(const Base::String& str);
    static Base::String toString(const QString& str);
 
    static std::string toMultiByteString(const Base::String& str);
};
 
 
}  // namespace Base