|| || || || || ||

---

String.h

Go to the documentation of this file.

#ifndef Impala_Basis_String_h
#define Impala_Basis_String_h

#include <string>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <cctype>
#include <cstring>
#include "Basis/Std.h"

namespace Impala
{


typedef std::string String;
typedef const std::string& CString;

inline String
MakeString(const int i)
{
    std::ostringstream oss;
    oss << i;
    return oss.str();
}

inline String
MakeString(const int i, const int width, const char fill = ' ')
{
    std::ostringstream oss;
    oss << std::setw(width) << std::setfill(fill) << i;
    return oss.str();
}

inline String
MakeString(const long i)
{
    std::ostringstream oss;
    oss << i;
    return oss.str();
}

inline String
MakeString(const long i, const int width, const char fill = ' ')
{
    std::ostringstream oss;
    oss << std::setw(width) << std::setfill(fill) << i;
    return oss.str();
}

inline String
MakeString(const unsigned long ul)
{
    std::ostringstream oss;
    oss << ul;
    return oss.str();
}

inline String
MakeString(const unsigned long ul, const int width, const char fill = ' ')
{
    std::ostringstream oss;
    oss << std::setw(width) << std::setfill(fill) << ul;
    return oss.str();
}

inline String
MakeString(const long long i)
{
    std::ostringstream oss;
    oss << i;
    return oss.str();
}

inline String
MakeString(const long long i, int width, char fill = ' ')
{
    std::ostringstream oss;
    oss << std::setw(width) << std::setfill(fill) << i;
    return oss.str();
}

inline String
MakeString(const unsigned long long ull)
{
    std::ostringstream oss;
    oss << ull;
    return oss.str();
}

inline String
MakeString(const unsigned long long ull, int width, char fill = ' ')
{
    std::ostringstream oss;
    oss << std::setw(width) << std::setfill(fill) << ull;
    return oss.str();
}

inline String
MakeString(const double d)
{
    std::ostringstream oss;
    oss << d;
    return oss.str();
}

inline String
MakeString(const double d, const int width, const char fill = ' ')
{
    std::ostringstream oss;
    oss << std::setw(width) << std::setfill(fill) << d;
    return oss.str();
}

inline String
MakeString(CString s)
{
    return s;
}

inline String
MakeString(CString src, const int width, const char fill = ' ')
{
    if (src.length() >= width)
        return src.substr(0, width);
    String res = src;
    for (int i=src.length() ; i<width ; i++)
        res.push_back(fill);
    return res;
}

inline int
atoi(CString s)
{
    std::istringstream iss(s);
    int i = 0;
    iss >> i;
    return i;

}

inline long
atol(CString s)
{
    std::istringstream iss(s);
    long i = 0;
    iss >> i;
    return i;
}

inline long
atoul(CString s)
{
    std::istringstream iss(s);
    long i = 0;
    iss >> i;
    return i;
}

inline long long
atoll(CString s)
{
    std::istringstream iss(s);
    long long i = 0;
    iss >> i;
    return i;
}

inline unsigned long long
atoull(CString s)
{
    std::istringstream iss(s);
    unsigned long long i = 0;
    iss >> i;
    return i;
}

inline double
atof(CString s)
{
    std::istringstream iss(s);
    double d = 0.0;
    iss >> d;
    return d;
}

inline String
StringReplace(String src, CString subFrom,
              CString subTo)
{
    String::size_type start = src.find(subFrom);
    if (start == String::npos)
        return src;
    return src.replace(start, subFrom.size(), subTo);
}

inline String
StringReplaceAll(String src, CString subFrom, CString subTo,
                 const bool recursive = true, String::size_type startPos = 0)
{
    String::size_type subFromSize = subFrom.size();
    String::size_type subToSize = subTo.size();
    String::size_type start = src.find(subFrom, startPos);
    while (start != String::npos)
    {
        src = src.replace(start, subFromSize, subTo);
        start = src.find(subFrom, recursive ? startPos : start + subToSize);
    }
    return src;
}

inline String
StringHead(CString src, const char toChar, const bool includeChar)
{
    String::size_type p = src.find(toChar, 0);
    if (p == String::npos)
        return "";
    if (includeChar)
        p++;
    return src.substr(0, p);
}

inline String
StringTail(String src, char toChar, bool includeChar)
{
    String::size_type p = src.find(toChar, 0);
    if (p == String::npos)
        return "";
    if (!includeChar)
        p++;
    return src.substr(p, src.size() - p);
}

inline bool
StringStartsWith(CString src, CString sub)
{
    return src.compare(0, sub.size(), sub) == 0;
}

inline bool
StringEndsWith(String src, const String& sub)
{
    if (sub.size() > src.size())
        return false;
    return src.compare(src.size() - sub.size(), sub.size(), sub) == 0;
}

inline void
StringToLower(String& s)
{
    //String s = src;
    // 2006-07-03 Ork - fixed header and function for GCC compilation compliance.
    std::transform(s.begin(), s.end(), s.begin(), (int(*)(int))tolower);
    //return r;
}

inline void
StringToUpper(String& s)
{
    std::transform(s.begin(), s.end(), s.begin(), (int(*)(int))toupper);
}

inline bool
StringToBool(CString s)
{
    return ((s == "0") || (s == "false") || (s == "no")) ? false : true;
}

inline String
StringSplit(String& s, char delim = ' ')
{
    String result;
    String::size_type pos = s.find(delim);
    if(pos == String::npos)
    {
        result = s;
        s = "";
        return result;
    }
    result = s.substr(0, pos);
    s = s.substr(pos+1, s.size());
    return result;
}

inline String
StringResolveEnv(String src)
{
    String::size_type start = src.find("${");
    while (start != String::npos)
    {
        String::size_type end = src.find("}", start+2);
        String env = src.substr(start+2, end - (start+2));
        char* val = getenv(env.c_str());
        if (val)
            src = src.replace(start, env.size()+3, String(val));
        else
            src = src.replace(start, env.size()+3, env);
        start = src.find("${");
    }
    return src;
}

} // namespace Impala

#endif

---