StringTool.h

Go to the documentation of this file.

#pragma once
#pragma warning(disable : 4251)

#include <Base/GlobalId.h>
#include <Base/String.h>
#include <Base/base_defines.h>

#include <iomanip>
#include <sstream>
#include <string>

#if _MSC_VER >= 1600
#define BOOST_HAS_STDINT_H
#endif
#include <stdint.h>

class QString;

#if _MSC_VER >= 1800
class QUuid;
#else
struct QUuid;
#endif

namespace Base
{
class 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)
    {
        if (b)
            return std::string("true");
        else
            return std::string("false");
    }

    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 QString toQString(const Base::String& str);
    static Base::String toString(const QString& str);

    static std::string toMultiByteString(const Base::String& str);
};


}  // namespace Base