utils_string.h

Go to the documentation of this file.

 
#ifndef CCGL_UTILS_STRING_H
#define CCGL_UTILS_STRING_H
 
#include <sstream>
#include <vector>
 
#include "basic.h"
 
using std::string;
using std::wstring;
using std::vector;
 
namespace ccgl {
namespace utils_string {
string GetUpper(const string& str);
 
bool StringMatch(const char* a, const char* b);
 
bool StringMatch(const string& text1, const string& text2);
 
void TrimSpaces(string& str);
 
string& Trim(string& s);
 
vector<string> SplitString(const string& item);
 
vector<string> SplitString(const string& item, char delimiter);
 
template <typename T>
string ValueToString(const T& val) {
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
 
void CopyStringMap(const STRING_MAP& in_opts, STRING_MAP& out_opts);
 
void UpdateStringMap(STRING_MAP& opts, const string& key, const string& value);
 
#if defined(CPP_GCC) || defined(CPP_ICC)
extern void _itoa_s(vint32_t value, char* buffer, size_t size, vint radix);
extern void _itow_s(vint32_t value, wchar_t* buffer, size_t size, vint radix);
extern void _i64toa_s(vint64_t value, char* buffer, size_t size, vint radix);
extern void _i64tow_s(vint64_t value, wchar_t* buffer, size_t size, vint radix);
extern void _uitoa_s(vuint32_t value, char* buffer, size_t size, vint radix);
extern void _uitow_s(vuint32_t value, wchar_t* buffer, size_t size, vint radix);
extern void _ui64toa_s(vuint64_t value, char* buffer, size_t size, vint radix);
extern void _ui64tow_s(vuint64_t value, wchar_t* buffer, size_t size, vint radix);
extern void _gcvt_s(char* buffer, size_t size, double value, vint numberOfDigits);
#endif
 
string itoa(vint number);
 
wstring itow(vint number);
 
string i64toa(vint64_t number);
 
wstring i64tow(vint64_t number);
 
string utoa(vuint number);
 
wstring utow(vuint number);
 
string u64toa(vuint64_t number);
 
wstring u64tow(vuint64_t number);
 
string ftoa(double number);
 
wstring ftow(double number);
 
string wtoa(const wstring& wstr);
 
vint _wtoa(const wchar_t* w, char* a, vint chars);
 
wstring atow(const string& astr);
vint _atow(const char* a, wchar_t* w, vint chars);
 
template <typename T>
bool SplitStringForValues(const string& items, const char delimiter, vector<T>& values);
 
vint IsInt(const string& num_str, bool& success);
 
vint IsInt(const wstring& num_str, bool& success);
 
vint64_t IsInt64(const string& num_str, bool& success);
 
vint64_t IsInt64(const wstring& num_str, bool& success);
 
vuint IsUInt(const string& num_str, bool& success);
 
vuint IsUInt(const wstring& num_str, bool& success);
 
vuint64_t IsUInt64(const string& num_str, bool& success);
 
vuint64_t IsUInt64(const wstring& num_str, bool& success);
 
double IsDouble(const string& num_str, bool& success);
 
double IsDouble(const wstring& num_str, bool& success);
 
 
template <typename STRING_T>
bool IsNumber(const STRING_T& num_str);
 
template <typename STRING_T>
vint ToInt(const STRING_T& num_str);
 
template <typename STRING_T>
vint64_t ToInt64(const STRING_T& num_str);
 
template <typename STRING_T>
vuint ToUInt(const STRING_T& num_str);
 
template <typename STRING_T>
vuint64_t ToUInt64(const STRING_T& num_str);
 
template <typename STRING_T>
double ToDouble(const STRING_T& num_str);
 
 
template <typename STRING_T>
vint ToInt(const STRING_T& num_str) {
    bool success = false;
    return IsInt(num_str, success);
}
 
template <typename STRING_T>
vint64_t ToInt64(const STRING_T& num_str) {
    bool success = false;
    return IsInt64(num_str, success);
}
 
template <typename STRING_T>
vuint ToUInt(const STRING_T& num_str) {
    bool success = false;
    return IsUInt(num_str, success);
}
 
template <typename STRING_T>
vuint64_t ToUInt64(const STRING_T& num_str) {
    bool success = false;
    return IsUInt64(num_str, success);
}
 
template <typename STRING_T>
double ToDouble(const STRING_T& num_str) {
    bool success = false;
    return IsDouble(num_str, success);
}
 
/************ Implementation of template functions ******************/
template <typename T>
bool SplitStringForValues(const string& items, const char delimiter, vector<T>& values) {
    vector<string> value_strs = SplitString(items, delimiter);
    if (value_strs.empty()) { return false; }
    values.clear();
    char* end = nullptr;
    for (auto it = value_strs.begin(); it != value_strs.end(); ++it) {
        if ((*it).find_first_of("0123456789") == string::npos) {
            continue;
        }
        values.emplace_back(static_cast<T>(strtod((*it).c_str(), &end)));
    }
    vector<T>(values).swap(values);
    return value_strs.size() == values.size();
}
 
template <typename STRING_T>
bool IsNumber(const STRING_T& num_str) {
    bool is_double = false;
    IsDouble(num_str, is_double);
    if (is_double) return true;
    return false;
}
} /* namespace: utils_string */
} /* namespace: ccgl */
 
#endif /* CCGL_UTILS_STRING_H */