/builddir/build/BUILD/libutil++-1.4.0/src/sella/util/String.cpp

/*
** libutil++
** $Id: String.cpp 1230 2014-11-16 02:32:01Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: String.cpp 1230 2014-11-16 02:32:01Z sella $";

#include "String.h"

#include <math.h>
#include <string.h>
#include <sstream>

#include <cctype>
#include <algorithm>

#include <boost/algorithm/string/replace.hpp>

#define BUFFER_SIZE (1024 * 32)

using namespace sella::util;

std::string String::sprintf(const char* format, ...) throw () {
        va_list args;

        va_start(args, format);
        std::string buffer = vsprintf(format, args);
        va_end(args);

        return buffer;
}

std::string String::sprintf(const std::string &format, ...) throw () {
        va_list args;

        va_start(args, format);
        std::string buffer = vsprintf(format.c_str(), args);
        va_end(args);

        return buffer;
}

std::string String::vsprintf(const char* format, va_list args) throw () {
        char buffer[BUFFER_SIZE];

        vsnprintf(buffer, sizeof(buffer), format, args);

        return std::string(buffer);
}

std::string String::vsprintf(const std::string &format, va_list args) throw () {
        char buffer[BUFFER_SIZE];

        vsnprintf(buffer, sizeof(buffer), format.c_str(), args);

        return std::string(buffer);
}

std::string String::substr_replace(const std::string &src, const std::string &search, const std::string &replace, bool global) throw () {
        size_t i = 0, inc = (replace.length()) ? replace.length() : 1;
        std::string dst = src;

        while (true) {
                if ((i = dst.find(search, i)) == std::string::npos) {
                        break;
                }

                dst.replace(i, search.length(), replace);

                if (!global) break;

                i += inc;
        }

        return dst;
}

std::string& String::substr_replace(std::string &src, const std::string &search, const std::string &replace, bool global) throw () {
        size_t i = 0, inc = (replace.length()) ? replace.length() : 1;

        while (true) {
                if ((i = src.find(search, i)) == std::string::npos) {
                        break;
                }

                src.replace(i, search.length(), replace);

                if (!global) break;

                i += inc;
        }

        return src;
}

std::string String::substr_ireplace(const std::string &src, const std::string &search, const std::string &replace, bool global) throw () {
        if (global) {
                return boost::algorithm::ireplace_all_copy(src, search, replace);
        } else {
                return boost::algorithm::ireplace_first_copy(src, search, replace);
        }
}

std::string& String::substr_ireplace(std::string &src, const std::string &search, const std::string &replace, bool global) throw () {
        if (global) {
                boost::algorithm::ireplace_all(src, search, replace);
        } else {
                boost::algorithm::ireplace_first(src, search, replace);
        }

        return src;
}

std::string& String::substr_replace2(std::string &src, const std::string &search, const std::string &replace, bool global) throw () {
        return substr_replace(src, search, replace, global);
}

std::string& String::substr_ireplace2(std::string &src, const std::string &search, const std::string &replace, bool global) throw () {
        return substr_ireplace(src, search, replace, global);
}

std::string String::regex_replace(const std::string &src, const boost::regex &regex, const std::string &replace, MatchFlag mFlags) throw (RegexException) {
        try {
                return boost::regex_replace(src, regex, replace, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

std::string String::regex_replace(const std::string &src, const std::string &regex, const std::string &replace, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return boost::regex_replace(src, rx, replace, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

std::string& String::regex_replace(std::string &src, const boost::regex &regex, const std::string &replace, MatchFlag mFlags) throw (RegexException) {
        try {
                src = boost::regex_replace(src, regex, replace, mFlags);

                return src;
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

std::string& String::regex_replace(std::string &src, const std::string &regex, const std::string &replace, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                src = boost::regex_replace(src, rx, replace, mFlags);

                return src;
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

std::string String::regex_ireplace(const std::string &src, const boost::regex &regex, const std::string &replace, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_replace(src, rx, replace, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

std::string String::regex_ireplace(const std::string &src, const std::string &regex, const std::string &replace, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_replace(src, rx, replace, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

std::string& String::regex_ireplace(std::string &src, const boost::regex &regex, const std::string &replace, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_replace(src, rx, replace, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

std::string& String::regex_ireplace(std::string &src, const std::string &regex, const std::string &replace, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_replace(src, rx, replace, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_match(const std::string &src, const boost::regex &regex, MatchFlag mFlags) throw (RegexException) {
        try {
                return boost::regex_match(src, regex, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_match(const std::string &src, const std::string &regex, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return regex_match(src, rx, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_match(const std::string &src, const boost::regex &regex, boost::cmatch &matches, MatchFlag mFlags) throw (RegexException) {
        try {
                return boost::regex_match(src.c_str(), matches, regex);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_match(const std::string &src, const std::string &regex, boost::cmatch &matches, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return regex_match(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_match(const std::string &src, const boost::regex &regex, std::string &match, MatchFlag mFlags) throw (RegexException) {
        boost::cmatch m;

        if (regex_match(src, regex, m, mFlags)) {
                match = m[0];

                return true;
        }

        return false;
}

bool String::regex_match(const std::string &src, const std::string &regex, std::string &match, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return regex_match(src, rx, match, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_match(const std::string &src, const boost::regex &regex, std::vector<std::string> &matches, MatchFlag mFlags) throw (RegexException) {
        boost::cmatch m;

        if (regex_match(src, regex, m, mFlags)) {
                for (size_t i = 0; i < m.size(); i++) {
                        matches.push_back(m[i]);
                }

                return true;
        }

        return false;
}

bool String::regex_match(const std::string &src, const std::string &regex, std::vector<std::string> &matches, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return regex_match(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_imatch(const std::string &src, const boost::regex &regex, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_match(src, rx, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_imatch(const std::string &src, const std::string &regex, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_match(src, rx, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_imatch(const std::string &src, const boost::regex &regex, boost::cmatch &matches, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_match(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_imatch(const std::string &src, const std::string &regex, boost::cmatch &matches, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_match(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_imatch(const std::string &src, const boost::regex &regex, std::string &match, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_match(src, rx, match, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_imatch(const std::string &src, const std::string &regex, std::string &match, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_match(src, rx, match, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_imatch(const std::string &src, const boost::regex &regex, std::vector<std::string> &matches, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_match(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_imatch(const std::string &src, const std::string &regex, std::vector<std::string> &matches, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_match(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_search(const std::string &src, const boost::regex &regex, MatchFlag mFlags) throw (RegexException) {
        try {
                return boost::regex_search(src, regex, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_search(const std::string &src, const std::string &regex, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return regex_search(src, rx, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_search(const std::string &src, const boost::regex &regex, boost::cmatch &matches, MatchFlag mFlags) throw (RegexException) {
        try {
                return boost::regex_search(src.c_str(), matches, regex);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_search(const std::string &src, const std::string &regex, boost::cmatch &matches, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return regex_search(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_search(const std::string &src, const boost::regex &regex, std::string &match, MatchFlag mFlags) throw (RegexException) {
        boost::cmatch m;

        if (regex_search(src, regex, m, mFlags)) {
                match = m[0];

                return true;
        }

        return false;
}

bool String::regex_search(const std::string &src, const std::string &regex, std::string &match, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return regex_search(src, rx, match, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_search(const std::string &src, const boost::regex &regex, std::vector<std::string> &matches, bool global, bool subexp, MatchFlag mFlags) throw (RegexException) {
        try {
                const char *p = src.c_str();
                boost::cmatch m;

                while (boost::regex_search(p, m, regex)) {
                        if (subexp) {
                                for (size_t i = 0; i < m.size(); i++) {
                                        matches.push_back(m[i]);
                                }
                        } else {
                                matches.push_back(m[0]);
                        }
                        p = m.suffix().str().c_str();

                        if (!global) break;
                }

                return (!matches.empty());
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_search(const std::string &src, const std::string &regex, std::vector<std::string> &matches, bool global, bool subexp, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags);

                return regex_search(src, rx, matches, global, subexp, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_isearch(const std::string &src, const boost::regex &regex, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_search(src, rx, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_isearch(const std::string &src, const std::string &regex, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_search(src, rx, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_isearch(const std::string &src, const boost::regex &regex, boost::cmatch &matches, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_search(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_isearch(const std::string &src, const std::string &regex, boost::cmatch &matches, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_search(src, rx, matches, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_isearch(const std::string &src, const boost::regex &regex, std::string &match, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_search(src, rx, match, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_isearch(const std::string &src, const std::string &regex, std::string &match, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_search(src, rx, match, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_isearch(const std::string &src, const boost::regex &regex, std::vector<std::string> &matches, bool global, bool subexp, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex.str(), regex.flags() | boost::regex_constants::icase);

                return regex_search(src, rx, matches, global, subexp, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

bool String::regex_isearch(const std::string &src, const std::string &regex, std::vector<std::string> &matches, bool global, bool subexp, REFlag reFlags, MatchFlag mFlags) throw (RegexException) {
        try {
                const boost::regex rx(regex, reFlags | boost::regex_constants::icase);

                return regex_search(src, rx, matches, global, subexp, mFlags);
        } catch (boost::bad_expression &e) {
                RETHROW_CODE(RegexException, 0, e);
        } catch (std::exception &e) {
                RETHROW_CODE(RegexException, 0, e);
        }
}

std::vector<std::string> String::split(const std::string &str, const std::string &delim, bool exact, bool empty, size_t limit) throw () {
        std::vector<std::string> vector;
        std::size_t prev = 0, pos, chunks = 0;

        if (exact) {
                while (++chunks < limit && (pos = str.find(delim, prev)) != std::string::npos) {
                        if (pos > prev || (empty && pos == prev)) {
                                vector.push_back(str.substr(prev, pos - prev));
                        }

                        prev = pos + delim.length();
                }
        } else {
                while (++chunks < limit && (pos = str.find_first_of(delim, prev)) != std::string::npos) {
                        if (pos > prev || (empty && pos == prev)) {
                                vector.push_back(str.substr(prev, pos - prev));
                        }

                        prev = pos + 1;
                }

        }

        if (chunks >= limit || prev < str.length() || (empty && prev == str.length())) {
                vector.push_back(str.substr(prev, std::string::npos));
        }

        return vector;
}

std::vector<std::string> String::split(const std::string &str, char delim, bool empty, size_t limit) throw () {
        std::vector<std::string> vector;
        std::string s;
        std::stringstream ss(str);
        std::size_t chunks = 0;

        while (++chunks < limit && std::getline(ss, s, delim)) {
                if (empty || !s.empty()) {
                        vector.push_back(s);
                }
        }

        if (chunks >= limit) {
                if (std::getline(ss, s)) {
                        vector.push_back(s);
                }
        } else {
                if (empty && !str.empty() && str[str.length() - 1] == delim) {
                        vector.push_back(std::string());
                }
        }

        return vector;
}

std::string String::join(const std::vector<std::string> &src, const std::string &delim) throw () {
        std::string dst;

        if (!src.empty()) {
                for (auto it = src.cbegin(); it != src.cend(); ++it) {
                        dst.append(*it).append(delim);
                }

                dst.erase(dst.size() - delim.size());
        }

        return dst;
}

std::string String::join(const std::vector<std::string> &src, char delim) throw () {
        std::string dst;

        if (!src.empty()) {
                for (auto it = src.cbegin(); it != src.cend(); ++it) {
                        dst.append(*it).push_back(delim);
                }

                dst.erase(dst.size() - 1);
        }

        return dst;
}

std::string String::join(const std::list<std::string> &src, const std::string &delim) throw () {
        std::string dst;

        if (!src.empty()) {
                for (auto it = src.cbegin(); it != src.cend(); ++it) {
                        dst.append(*it).append(delim);
                }

                dst.erase(dst.size() - delim.size());
        }

        return dst;
}

std::string String::join(const std::list<std::string> &src, char delim) throw () {
        std::string dst;

        if (!src.empty()) {
                for (auto it = src.cbegin(); it != src.cend(); ++it) {
                        dst.append(*it).push_back(delim);
                }

                dst.erase(dst.size() - 1);
        }

        return dst;
}

std::string String::join(const std::set<std::string> &src, const std::string &delim) throw () {
        std::string dst;

        if (!src.empty()) {
                for (auto it = src.cbegin(); it != src.cend(); ++it) {
                        dst.append(*it).append(delim);
                }

                dst.erase(dst.size() - delim.size());
        }

        return dst;
}

std::string String::join(const std::set<std::string> &src, char delim) throw () {
        std::string dst;

        if (!src.empty()) {
                for (auto it = src.cbegin(); it != src.cend(); ++it) {
                        dst.append(*it).push_back(delim);
                }

                dst.erase(dst.size() - 1);
        }

        return dst;
}

std::string String::trim(const std::string &str, const std::string &space) throw () {
        return ltrim(rtrim(str, space), space);
}

std::string String::trim(const std::string &str, char space) throw () {
        return ltrim(rtrim(str, space), space);
}

std::string& String::trim(std::string &str, const std::string &space) throw () {
        return ltrim(rtrim(str, space), space);
}

std::string& String::trim(std::string &str, char space) throw () {
        return ltrim(rtrim(str, space), space);
}

std::string String::rtrim(const std::string &str, const std::string &space) throw () {
        size_t i;

        if ((i = str.find_last_not_of(space)) != std::string::npos) {
                return str.substr(0, i + 1);
        } else {
                return std::string();
        }

        return str;
}

std::string String::rtrim(const std::string &str, char space) throw () {
        size_t i;

        if ((i = str.find_last_not_of(space)) != std::string::npos) {
                return str.substr(0, i + 1);
        } else {
                return std::string();
        }

        return str;
}

std::string& String::rtrim(std::string &str, const std::string &space) throw () {
        size_t i;

        if ((i = str.find_last_not_of(space)) != std::string::npos) {
                str.substr(0, i + 1).swap(str);
        } else {
                str.clear();
        }

        return str;
}

std::string& String::rtrim(std::string &str, char space) throw () {
        size_t i;

        if ((i = str.find_last_not_of(space)) != std::string::npos) {
                str.substr(0, i + 1).swap(str);
        } else {
                str.clear();
        }

        return str;
}

std::string String::ltrim(const std::string &str, const std::string &space) throw () {
        size_t i;

        if ((i = str.find_first_not_of(space)) != std::string::npos) {
                return str.substr(i);
        } else {
                return std::string();
        }

        return str;
}

std::string String::ltrim(const std::string &str, char space) throw () {
        size_t i;

        if ((i = str.find_first_not_of(space)) != std::string::npos) {
                return str.substr(i);
        } else {
                return std::string();
        }

        return str;
}

std::string& String::ltrim(std::string &str, const std::string &space) throw () {
        size_t i;

        if ((i = str.find_first_not_of(space)) != std::string::npos) {
                str.substr(i).swap(str);
        } else {
                str.clear();
        }

        return str;
}

std::string& String::ltrim(std::string &str, char space) throw () {
        size_t i;

        if ((i = str.find_first_not_of(space)) != std::string::npos) {
                str.substr(i).swap(str);
        } else {
                str.clear();
        }

        return str;
}

std::string String::lower(const std::string &src) throw () {
        std::string dst(src);

        std::transform(dst.begin(), dst.end(), dst.begin(), ::tolower);

        return dst;
}

std::string& String::lower(std::string &src) throw () {
        std::transform(src.begin(), src.end(), src.begin(), ::tolower);

        return src;
}

std::string String::upper(const std::string &src) throw () {
        std::string dst(src);

        std::transform(dst.begin(), dst.end(), dst.begin(), ::toupper);

        return dst;
}

std::string& String::upper(std::string &src) throw () {
        std::transform(src.begin(), src.end(), src.begin(), ::toupper);

        return src;
}

std::string String::ucfirst(const std::string &src) throw () {
        std::string dst(lower(src));

        for (auto it = dst.begin(); it != dst.end(); ++it) {
                if (!isspace(*it)) {
                        *it = std::toupper(*it);

                        break;
                }
        }

        return dst;
}

std::string& String::ucfirst(std::string &src) throw () {
        lower(src);

        for (auto it = src.begin(); it != src.end(); ++it) {
                if (!isspace(*it)) {
                        *it = std::toupper(*it);

                        break;
                }
        }

        return src;
}

std::string String::ucword(const std::string &src) throw () {
        std::string dst(src);
        bool space = true;

        for (auto it = dst.begin(); it != dst.end(); ++it) {
                if (space) {
                        *it = std::toupper(*it);
                } else {
                        *it = std::tolower(*it);
                }

                space = isspace(*it);
        }

        return src;
}

std::string& String::ucword(std::string &src) throw () {
        bool space = true;

        for (auto it = src.begin(); it != src.end(); ++it) {
                if (space) {
                        *it = std::toupper(*it);
                } else {
                        *it = std::tolower(*it);
                }

                space = isspace(*it);
        }

        return src;
}

std::string String::bandwidth(int64_t bps, int decimals) throw () {
        if (decimals == 0) {
                if (bps % 1000000000000000LL == 0 && bps >= 1000000000000000LL) {
                        return String::sprintf("%"PRId64"Pbs", bps / 1000000000000000LL);
                } else if (bps % 1000000000000LL == 0 && bps >= 1000000000000LL) {
                        return String::sprintf("%"PRId64"Tbs", bps / 1000000000000LL);
                } else if (bps % 1000000000LL == 0 && bps >= 1000000000LL) {
                        return String::sprintf("%"PRId64"Gbs", bps / 1000000000LL);
                } else if (bps % 1000000LL == 0 && bps >= 1000000LL) {
                        return String::sprintf("%"PRId64"Mbs", bps / 1000000LL);
                } else if (bps % 1000LL == 0 && bps >= 1000LL) {
                        return String::sprintf("%"PRId64"Kbs", bps / 1000LL);
                }
        } else {
                double adj = pow(10, decimals);

                if (bps >= 1000000000000000LL) {
                        return String::sprintf("%gPbs", roundf((double) bps / 1000000000000000.0f * adj) / adj);
                } else if (bps >= 1000000000000LL) {
                        return String::sprintf("%gTbs", roundf((double) bps / 1000000000000.0f * adj) / adj);
                } else if (bps >= 1000000000LL) {
                        return String::sprintf("%gGbs", roundf((double) bps / 1000000000.0f * adj) / adj);
                } else if (bps >= 1000000LL) {
                        return String::sprintf("%gMbs", roundf((double) bps / 1000000.0f * adj) / adj);
                } else if (bps >= 1000LL) {
                        return String::sprintf("%gKbs", roundf((double) bps / 1000.0f * adj) / adj);
                }
        }
        
        return String::sprintf("%"PRId64"bps", bps);
}

std::string String::bandwidth(uint64_t bps, int decimals) throw () {
        if (decimals == 0) {
                if (bps % 1000000000000000LLU == 0 && bps >= 1000000000000000LLU) {
                        return String::sprintf("%"PRIu64"Pbs", bps / 1000000000000000LLU);
                } else if (bps % 1000000000000LLU == 0 && bps >= 1000000000000LLU) {
                        return String::sprintf("%"PRIu64"Tbs", bps / 1000000000000LLU);
                } else if (bps % 1000000000LLU == 0 && bps >= 1000000000LLU) {
                        return String::sprintf("%"PRIu64"Gbs", bps / 1000000000LLU);
                } else if (bps % 1000000LLU == 0 && bps >= 1000000LLU) {
                        return String::sprintf("%"PRIu64"Mbs", bps / 1000000LLU);
                } else if (bps % 1000LLU == 0 && bps >= 1000LLU) {
                        return String::sprintf("%"PRIu64"Kbs", bps / 1000LLU);
                }
        } else {
                double adj = pow(10, decimals);

                if (bps >= 1000000000000000LLU) {
                        return String::sprintf("%gPbs", roundf((double) bps / 1000000000000000.0f * adj) / adj);
                } else if (bps >= 1000000000000LLU) {
                        return String::sprintf("%gTbs", roundf((double) bps / 1000000000000.0f * adj) / adj);
                } else if (bps >= 1000000000LLU) {
                        return String::sprintf("%gGbs", roundf((double) bps / 1000000000.0f * adj) / adj);
                } else if (bps >= 1000000LLU) {
                        return String::sprintf("%gMbs", roundf((double) bps / 1000000.0f * adj) / adj);
                } else if (bps >= 1000LLU) {
                        return String::sprintf("%gKbs", roundf((double) bps / 1000.0f * adj) / adj);
                }
        }
        
        return String::sprintf("%"PRIu64"bps", bps);
}

#ifdef __LP64__
std::string String::bandwidth(long long bps, int decimals) throw () {
        return bandwidth((int64_t) bps, decimals);
}

std::string String::bandwidth(unsigned long long bps, int decimals) throw () {
        return bandwidth((uint64_t) bps,decimals);
}
#else
std::string String::bandwidth(long bps, int decimals) throw () {
        return bandwidth((int64_t) bps, decimals);
}

std::string String::bandwidth(unsigned long bps, int decimals) throw () {
        return bandwidth((uint64_t) bps, decimals);
}
#endif

std::string String::dataSize(int64_t bytes, int decimals) throw () {
        if (decimals == 0) {
                if (bytes % (int64_t) pow(2, 50) == 0 && bytes >= (int64_t) pow(2, 50)) {
                        return String::sprintf("%"PRId64"PB", bytes / (int64_t) pow(2, 50));
                } else if (bytes % (int64_t) pow(2, 40) == 0 && bytes >= (int64_t) pow(2, 40)) {
                        return String::sprintf("%"PRId64"TB", bytes / (int64_t) pow(2, 40));
                } else if (bytes % (int64_t) pow(2, 30) == 0 && bytes >= (int64_t) pow(2, 30)) {
                        return String::sprintf("%"PRId64"GB", bytes / (int64_t) pow(2, 30));
                } else if (bytes % (int64_t) pow(2, 20) == 0 && bytes >= (int64_t) pow(2, 20)) {
                        return String::sprintf("%"PRId64"MB", bytes / (int64_t) pow(2, 20));
                } else if (bytes % (int64_t) pow(2, 10) == 0 && bytes >= (int64_t) pow(2, 10)) {
                        return String::sprintf("%"PRId64"KB", bytes / (int64_t) pow(2, 10));
                }
        } else {
                double adj = pow(10, decimals);

                if (bytes >= (int64_t) pow(2, 50)) {
                        return String::sprintf("%gPB", roundf((double) bytes / pow(2, 50) * adj) / adj);
                } else if (bytes >= (int64_t) pow(2, 40)) {
                        return String::sprintf("%gTB", roundf((double) bytes / pow(2, 40) * adj) / adj);
                } else if (bytes >= (int64_t) pow(2, 30)) {
                        return String::sprintf("%gGB", roundf((double) bytes / pow(2, 30) * adj) / adj);
                } else if (bytes >= (int64_t) pow(2, 20)) {
                        return String::sprintf("%gMB", roundf((double) bytes / pow(2, 20) * adj) / adj);
                } else if (bytes >= (int64_t) pow(2, 10)) {
                        return String::sprintf("%gKB", roundf((double) bytes / pow(2, 10) * adj) / adj);
                }
        }

        return String::sprintf("%lldB", bytes);
}

std::string String::dataSize(uint64_t bytes, int decimals) throw () {
        if (decimals == 0) {
                if (bytes % (uint64_t) pow(2, 50) == 0 && bytes >= (uint64_t) pow(2, 50)) {
                        return String::sprintf("%"PRIu64"PB", bytes / (uint64_t) pow(2, 50));
                } else if (bytes % (uint64_t) pow(2, 40) == 0 && bytes >= (uint64_t) pow(2, 40)) {
                        return String::sprintf("%"PRIu64"TB", bytes / (uint64_t) pow(2, 40));
                } else if (bytes % (uint64_t) pow(2, 30) == 0 && bytes >= (uint64_t) pow(2, 30)) {
                        return String::sprintf("%"PRIu64"GB", bytes / (uint64_t) pow(2, 30));
                } else if (bytes % (uint64_t) pow(2, 20) == 0 && bytes >= (uint64_t) pow(2, 20)) {
                        return String::sprintf("%"PRIu64"MB", bytes / (uint64_t) pow(2, 20));
                } else if (bytes % (uint64_t) pow(2, 10) == 0 && bytes >= (uint64_t) pow(2, 10)) {
                        return String::sprintf("%"PRIu64"KB", bytes / (uint64_t) pow(2, 10));
                }
        } else {
                double adj = pow(10, decimals);

                if (bytes >= (uint64_t) pow(2, 50)) {
                        return String::sprintf("%gPB", roundf((double) bytes / pow(2, 50) * adj) / adj);
                } else if (bytes >= (uint64_t) pow(2, 40)) {
                        return String::sprintf("%gTB", roundf((double) bytes / pow(2, 40) * adj) / adj);
                } else if (bytes >= (uint64_t) pow(2, 30)) {
                        return String::sprintf("%gGB", roundf((double) bytes / pow(2, 30) * adj) / adj);
                } else if (bytes >= (uint64_t) pow(2, 20)) {
                        return String::sprintf("%gMB", roundf((double) bytes / pow(2, 20) * adj) / adj);
                } else if (bytes >= (uint64_t) pow(2, 10)) {
                        return String::sprintf("%gKB", roundf((double) bytes / pow(2, 10) * adj) / adj);
                }
        }

        return String::sprintf("%lluB", bytes);
}

#ifdef __LP64__
std::string String::dataSize(long long bytes, int decimals) throw () {
        return dataSize((int64_t) bytes, decimals);
}

std::string String::dataSize(unsigned long long bytes, int decimals) throw () {
        return dataSize((uint64_t) bytes, decimals);
}
#else
std::string String::dataSize(long bytes, int decimals) throw () {
        return dataSize((int64_t) bytes, decimals);
}

std::string String::dataSize(unsigned long bytes, int decimals) throw () {
        return dataSize((uint64_t) bytes, decimals);
}
#endif

std::string String::dataRate(int64_t bps, int decimals) throw () {
        if (decimals == 0) {
                if (bps % 1000000000000000LL == 0 && bps >= 1000000000000000LL) {
                        return String::sprintf("%gp", bps / 1000000000000000LL);
                } else if (bps % 1000000000000LL == 0 && bps >= 1000000000000LL) {
                        return String::sprintf("%"PRId64"t", bps / 1000000000000LL);
                } else if (bps % 1000000000LL == 0 && bps >= 1000000000LL) {
                        return String::sprintf("%"PRId64"g", bps / 1000000000LL);
                } else if (bps % 1000000LL == 0 && bps >= 1000000LL) {
                        return String::sprintf("%"PRId64"m", bps / 1000000LL);
                } else if (bps % 1000LL == 0 && bps >= 1000LL) {
                        return String::sprintf("%"PRId64"k", bps / 1000LL);
                }
        } else {
                double adj = pow(10, decimals);

                if (bps >= 1000000000000000LL) {
                        return String::sprintf("%gp", roundf((double) bps / 1000000000000000.0f * adj) / adj);
                } else if (bps >= 1000000000000LL) {
                        return String::sprintf("%gt", roundf((double) bps / 1000000000000.0f * adj) / adj);
                } else if (bps >= 1000000000LL) {
                        return String::sprintf("%gg", roundf((double) bps / 1000000000.0f * adj) / adj);
                } else if (bps >= 1000000LL) {
                        return String::sprintf("%gm", roundf((double) bps / 1000000.0f * adj) / adj);
                } else if (bps >= 1000LL) {
                        return String::sprintf("%gk", roundf((double) bps / 1000.0f * adj) / adj);
                }
        }

        return String::sprintf("%"PRId64"b", bps);
}

std::string String::dataRate(uint64_t bps, int decimals) throw () {
        if (decimals == 0) {
                if (bps % 1000000000000000LLU == 0 && bps >= 1000000000000000LLU) {
                        return String::sprintf("%"PRIu64"p", bps / 1000000000000000LLU);
                } else if (bps % 1000000000000LLU == 0 && bps >= 1000000000000LLU) {
                        return String::sprintf("%"PRIu64"t", bps / 1000000000000LLU);
                } else if (bps % 1000000000LLU == 0 && bps >= 1000000000LLU) {
                        return String::sprintf("%"PRIu64"g", bps / 1000000000LLU);
                } else if (bps % 1000000LLU == 0 && bps >= 1000000LLU) {
                        return String::sprintf("%"PRIu64"m", bps / 1000000LLU);
                } else if (bps % 1000LLU == 0 && bps >= 1000LLU) {
                        return String::sprintf("%"PRIu64"k", bps / 1000LLU);
                }
        } else {
                double adj = pow(10, decimals);

                if (bps >= 1000000000000000LLU) {
                        return String::sprintf("%gp", roundf((double) bps / 1000000000000000.0f * adj) / adj);
                } else if (bps >= 1000000000000LLU) {
                        return String::sprintf("%gt", roundf((double) bps / 1000000000000.0f * adj) / adj);
                } else if (bps >= 1000000000LLU) {
                        return String::sprintf("%gg", roundf((double) bps / 1000000000.0f * adj) / adj);
                } else if (bps >= 1000000LLU) {
                        return String::sprintf("%gm", roundf((double) bps / 1000000.0f * adj) / adj);
                } else if (bps >= 1000LLU) {
                        return String::sprintf("%gk", roundf((double) bps / 1000.0f * adj) / adj);
                }
        }

        return String::sprintf("%"PRIu64"", bps);
}

#ifdef __LP64__
std::string String::dataRate(long long bps, int decimals) throw () {
        return dataRate((int64_t) bps, decimals);
}

std::string String::dataRate(unsigned long long bps, int decimals) throw () {
        return dataRate((uint64_t) bps, decimals);
}
#else
std::string String::dataRate(long bps, int decimals) throw () {
        return dataRate((int64_t) bps, decimals);
}

std::string String::dataRate(unsigned long bps, int decimals) throw () {
        return dataRate((uint64_t) bps, decimals);
}
#endif

std::string String::duration(int64_t usec, int decimals) throw () {
        if (decimals == 0) {
                if (usec % (7LL * 86400LL * (int64_t) pow(10, 6)) == 0 && usec >= (7LL * 86400LL * (int64_t) pow(10, 6))) {
                        return String::sprintf("%"PRId64"w", usec / (7LL * 86400LL * (int64_t) pow(10, 6)));
                } else if (usec % (86400LL * (int64_t) pow(10, 6)) == 0 && usec >= (86400LL * (int64_t) pow(10, 6))) {
                        return String::sprintf("%"PRId64"d", usec / (86400LL * (int64_t) pow(10, 6)));
                } else if (usec % (3600LL * (int64_t) pow(10, 6)) == 0 && usec >= (3600LL * (int64_t) pow(10, 6))) {
                        return String::sprintf("%"PRId64"h", usec / (3600LL * (int64_t) pow(10, 6)));
                } else if (usec % (60LL * (int64_t) pow(10, 6)) == 0 && usec >= (60LL * (int64_t) pow(10, 6))) {
                        return String::sprintf("%"PRId64"min", usec / (60LL * (int64_t) pow(10, 6)));
                } else if (usec % (int64_t) pow(10, 6) == 0 && usec >= (int64_t) pow(10, 6)) {
                        return String::sprintf("%"PRId64"s", usec / (int64_t) pow(10, 6));
                } else if (usec % (int64_t) pow(10, 3) == 0 && usec >= (int64_t) pow(10, 3)) {
                        return String::sprintf("%"PRId64"ms", usec / (int64_t) pow(10, 3));
                }
        } else {
                double adj = pow(10, decimals);

                if (usec >= (7LL * 86400LL * (int64_t) pow(10, 6))) {
                        return String::sprintf("%gw", roundf((double) usec / 7.0f * 86400.0f * pow(10, 6) * adj) / adj);
                } else if (usec >= (86400LL * (int64_t) pow(10, 6))) {
                        return String::sprintf("%gd", roundf((double) usec / 86400.0f * pow(10, 6) * adj) / adj);
                } else if (usec >= (3600LL * (int64_t) pow(10, 6))) {
                        return String::sprintf("%gh", roundf((double) usec / 3600.0f * pow(10, 6) * adj) / adj);
                } else if (usec >= (60LL * (int64_t) pow(10, 6))) {
                        return String::sprintf("%gmin", roundf((double) usec / 60.0f * pow(10, 6) * adj) / adj);
                } else if (usec >= (int64_t) pow(10, 6)) {
                        return String::sprintf("%gs", roundf((double) usec / pow(10, 6) * adj) / adj);
                } else if (usec >= (int64_t) pow(10, 3)) {
                        return String::sprintf("%gms", roundf((double) usec / pow(10, 3) * adj) / adj);
                }
        }

        return String::sprintf("%"PRId64"us", usec);
}

std::string String::duration(uint64_t usec, int decimals) throw () {
        if (decimals == 0) {
                if (usec % (7LLU * 86400LLU * (uint64_t) pow(10, 6)) == 0 && usec >= (7LLU * 86400LLU * (uint64_t) pow(10, 6))) {
                        return String::sprintf("%"PRIu64"w", usec / (7LLU * 86400LLU * (uint64_t) pow(10, 6)));
                } else if (usec % (86400LLU * (uint64_t) pow(10, 6)) == 0 && usec >= (86400LLU * (uint64_t) pow(10, 6))) {
                        return String::sprintf("%"PRIu64"d", usec / (86400LLU * (uint64_t) pow(10, 6)));
                } else if (usec % (3600LLU * (uint64_t) pow(10, 6)) == 0 && usec >= (3600LLU * (uint64_t) pow(10, 6))) {
                        return String::sprintf("%"PRIu64"h", usec / (3600LLU * (uint64_t) pow(10, 6)));
                } else if (usec % (60LLU * (uint64_t) pow(10, 6)) == 0 && usec >= (60LLU * (uint64_t) pow(10, 6))) {
                        return String::sprintf("%"PRIu64"min", usec / (60LLU * (uint64_t) pow(10, 6)));
                } else if (usec % (uint64_t) pow(10, 6) == 0 && usec >= (uint64_t) pow(10, 6)) {
                        return String::sprintf("%"PRIu64"s", usec / (uint64_t) pow(10, 6));
                } else if (usec % (uint64_t) pow(10, 3) == 0 && usec >= (uint64_t) pow(10, 3)) {
                        return String::sprintf("%"PRIu64"ms", usec / (uint64_t) pow(10, 3));
                }
        } else {
                double adj = pow(10, decimals);

                if (usec >= (7LLU * 86400LLU * (uint64_t) pow(10, 6))) {
                        return String::sprintf("%gw", roundf((double) usec / 7.0f * 86400.0f * pow(10, 6) * adj) / adj);
                } else if (usec >= (86400LLU * (uint64_t) pow(10, 6))) {
                        return String::sprintf("%gd", roundf((double) usec / 86400.0f * pow(10, 6) * adj) / adj);
                } else if (usec >= (3600LLU * (uint64_t) pow(10, 6))) {
                        return String::sprintf("%gh", roundf((double) usec / 3600.0f * pow(10, 6) * adj) / adj);
                } else if (usec >= (60LLU * (uint64_t) pow(10, 6))) {
                        return String::sprintf("%gmin", roundf((double) usec / 60.0f * pow(10, 6) * adj) / adj);
                } else if (usec >= (uint64_t) pow(10, 6)) {
                        return String::sprintf("%gs", roundf((double) usec / pow(10, 6) * adj) / adj);
                } else if (usec >= (uint64_t) pow(10, 3)) {
                        return String::sprintf("%gms", roundf((double) usec / pow(10, 3) * adj) / adj);
                }
        }

        return String::sprintf("%"PRIu64"u", usec);
}

#ifdef __LP64__
std::string String::duration(long long usec, int decimals) throw () {
        return duration((int64_t) usec, decimals);
}

std::string String::duration(unsigned long long usec, int decimals) throw () {
        return duration((uint64_t) usec, decimals);
}
#else
std::string String::duration(long usec, int decimals) throw () {
        return duration((int64_t) usec, decimals);
}

std::string String::duration(unsigned long usec, int decimals) throw () {
        return duration((uint64_t) usec, decimals);
}
#endif

/*
** vim: noet ts=3 sw=3
*/

---