tkstring.cpp

/********************************************************************************
 *   Copyright (c) : Université de Lyon 1, CNRS/IN2P3, UMR5822,                 *
 *                   IP2I, F-69622 Villeurbanne Cedex, France                   *
 *                   Normandie Université, ENSICAEN, UNICAEN, CNRS/IN2P3,       *
 *                   LPC Caen, F-14000 Caen, France                             *
 *   Contibutor(s) :                                                            *
 *      Jérémie Dudouet jeremie.dudouet@cnrs.fr [2020]                          *
 *      Diego Gruyer    diego.gruyer@cnrs.fr    [2020]                          *
 *                                                                              *
 *   Licensed under the MIT License <http://opensource.org/licenses/MIT>.       *   
 *   SPDX-License-Identifier: MIT                                               *
 ********************************************************************************/
#include "tkstring.h"
 
#include <array>
#include <cctype>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <string>
#include <string_view>
 
namespace tkn {
}
 
using namespace tkn;
 
namespace {
 
std::string format_string(const char *_format, va_list _arguments)
{
    if (!_format) return {};
 
    va_list arguments_copy;
    va_copy(arguments_copy, _arguments);
    const int required_size = std::vsnprintf(nullptr, 0, _format, arguments_copy);
    va_end(arguments_copy);
    if (required_size < 0) return {};
 
    std::string result(static_cast<std::size_t>(required_size) + 1, '\0');
    std::vsnprintf(result.data(), result.size(), _format, _arguments);
    result.resize(static_cast<std::size_t>(required_size));
    return result;
}
 
unsigned char unsigned_character(char _character)
{
    return static_cast<unsigned char>(_character);
}
 
tkstring normalized_number(const tkstring &_input, bool _replace_comma)
{
    tkstring normalized;
    normalized.reserve(_input.size());
    for (const char character : _input) {
        if (character == ' ') continue;
        normalized += (_replace_comma && character == ',') ? '.' : character;
    }
    return normalized;
}
 
}
 
std::string tkn::wrap_text(const tkstring &_text, size_t _first_content_col, size_t _continuation_col, size_t _max_line_width)
{
    const size_t min_content_width = 20;
    const size_t first_avail = _first_content_col < _max_line_width ? _max_line_width - _first_content_col : min_content_width;
    const size_t continuation_avail = _continuation_col < _max_line_width ? _max_line_width - _continuation_col : min_content_width;
    const std::string continuation_indent(_continuation_col, ' ');
 
    auto wrap_paragraph = [&](const std::string &_paragraph, size_t _first_avail) {
        std::string result;
        size_t pos = 0;
        bool first_chunk = true;
        while (pos < _paragraph.size()) {
            if (!first_chunk) result += "\n" + continuation_indent;
            const size_t content_avail = first_chunk ? _first_avail : continuation_avail;
            if (_paragraph.size() - pos <= content_avail) {
                result += _paragraph.substr(pos);
                break;
            }
            size_t wrap_at = _paragraph.rfind(' ', pos + content_avail);
            if (wrap_at == std::string::npos || wrap_at <= pos) {
                result += _paragraph.substr(pos, content_avail);
                pos += content_avail;
            } else {
                result += _paragraph.substr(pos, wrap_at - pos);
                pos = wrap_at + 1;
                while (pos < _paragraph.size() && _paragraph[pos] == ' ') pos++;
            }
            first_chunk = false;
        }
        return result;
    };
 
    auto paragraphs = _text.tokenize_from_string("\n");
    std::string wrapped;
    bool first_para = true;
    for (auto &para : paragraphs) {
        if (!first_para) wrapped += "\n" + continuation_indent;
        wrapped += wrap_paragraph(para, first_para ? first_avail : continuation_avail);
        first_para = false;
    }
    return wrapped;
}
 
tkstring&  tkstring::to_lower()
{
    std::transform(begin(), end(), begin(),[](unsigned char _c){ return std::tolower(_c); });
    return *this;
}
 
tkstring& tkstring::to_upper()
{
    std::transform(begin(), end(), begin(),[](unsigned char _c){ return std::toupper(_c); });
    return *this;
}

 
bool tkstring::is_digit() const
{
    bool has_digit = false;
    if (empty()) return false;
    for (const char character : *this) {
        if (character == ' ') continue;
        if (!std::isdigit(unsigned_character(character))) return false;
        has_digit = true;
    }
    return has_digit;
}

 
bool tkstring::is_float() const
{
    const tkstring normalized = normalized_number(*this, true);
    if (normalized.empty()) return false;
    char *end = nullptr;
    const double value = std::strtod(normalized.c_str(), &end);
    return end != normalized.c_str() && *end == '\0' && std::isfinite(value);
}
 
//tkstring tkstring::energy_to_string(double _val, int _precision)
//{
//    int exp_value = (_val == 0) ? 0 : 1 + (int)std::floor(std::log10(std::fabs(_val) ) );
//    int exp_error = (_precision == 0) ? 0 : 1 + (int)std::floor(std::log10(std::fabs(_precision) ) );
 
//    std::ostringstream os;
 
//    if(_precision<0) os.precision(exp_value+exp_error);
//    else os.precision(exp_value);
//    os << _val;
 
//    tkstring result = os.str();
//    return result;
//}
 
//tkstring tkstring::energy_error_to_string(double _val, int _precision)
//{
//    int exp_error = (_precision == 0) ? 0 : 1 + (int)std::floor(std::log10(std::fabs(_precision) ) );
//    if(_precision>0) exp_error = 1 + (int)std::floor(std::log10(std::fabs(_val) ) );
//    std::ostringstream os;
 
//    os.precision(exp_error);
//    os << _val;
 
//    tkstring result = os.str();
//    return result;
//}
 

 
int tkstring::atoi() const
{
    if (find(' ') == npos) return std::atoi(data());
    return std::atoi(normalized_number(*this, false).data());
}
 
int64_t tkstring::atoll() const
{
    if (find(' ') == npos) return std::atoll(data());
    return std::atoll(normalized_number(*this, false).data());
}

double tkstring::atof() const
{
    if (find(',') == npos && find(' ') == npos) return std::atof(data());
    return std::atof(normalized_number(*this, true).data());
}

size_t tkstring::index(const char *_s, size_t _pos, ECaseCompare _cmp) const
{
    if (!_s || _pos > size()) return npos;
    if(_cmp == ECaseCompare::kExact) return find(_s,_pos);
 
    const std::string_view pattern(_s);
    if (pattern.empty()) return _pos;
    const auto match_position = std::search(
        begin() + static_cast<std::ptrdiff_t>(_pos), end(),
        pattern.begin(), pattern.end(),
        [](char left, char right) {
            return std::tolower(unsigned_character(left)) ==
                   std::tolower(unsigned_character(right));
        });
    return match_position == end() ? npos : static_cast<size_t>(match_position - begin());
}

 
bool tkstring::equal_to(const char *_s, ECaseCompare _cmp) const
{
    if (!_s) return false;
    if (_cmp == kExact) return compare(_s) == 0;
    const std::string_view other(_s);
    return size() == other.size() && std::equal(
        begin(), end(), other.begin(),
        [](char left, char right) {
            return std::tolower(unsigned_character(left)) ==
                   std::tolower(unsigned_character(right));
        });
}
 
bool tkstring::ends_with(const char *_s, ECaseCompare _cmp) const
{
    if (!_s) return false;
 
#if defined(__cpp_lib_starts_ends_with) && __cpp_lib_starts_ends_with >= 201711L
    if (_cmp == kExact) return std::string::ends_with(_s);
#endif
 
    size_t l = strlen(_s);
    if (l > length()) return false;
    const auto offset = length() - l;
    if (_cmp == kExact) return compare(offset, l, _s) == 0;
    return std::equal(
        begin() + static_cast<std::ptrdiff_t>(offset), end(), _s,
        [](char left, char right) {
            return std::tolower(unsigned_character(left)) ==
                   std::tolower(unsigned_character(right));
        });
}
 
std::vector<tkstring> tkstring::tokenize(const tkstring &_delim) const
{
    std::vector<tkstring> tokens;
    if (empty()) return tokens;
    if (_delim.empty()) {
        tokens.push_back(*this);
        return tokens;
    }
 
    size_t start = find_first_not_of(_delim);
    while (start != npos) {
        const size_t stop = find_first_of(_delim, start);
        tokens.emplace_back(std::string::substr(start, stop - start));
        if (stop == npos) break;
        start = find_first_not_of(_delim, stop);
    }
 
    return tokens;
}
 
std::vector<tkstring> tkstring::tokenize_from_string(const tkstring &_delim) const {
    std::vector<tkstring> tokens;
    if (empty()) return tokens;
    if (_delim.empty()) {
        tokens.push_back(*this);
        return tokens;
    }
    size_t start = 0, pos = 0;
 
    // Boucle tant qu'on trouve le délimiteur complet
    while ((pos = find(_delim, start)) != npos) {
        tkstring token = substr(start, pos - start);
        if (token.length()) {
            tokens.push_back(token);
        }
        // On avance de la longueur du délimiteur
        start = pos + _delim.length();
    }
 
    // Ajoute le dernier segment (après le dernier délimiteur)
    tkstring token = substr(start);
    if (token.length()) {
        tokens.push_back(token);
    }
 
    return tokens;
}
 
tkstring& tkstring::replace_all(const char *_s1, size_t _ls1, const char *_s2, size_t _ls2)
{
    if (_s1 && _ls1 > 0) {
        size_t pos = 0;
        while ((pos = find(_s1,pos,_ls1)) != npos) {
            replace(pos, _ls1, _s2, _ls2);
            pos += _ls2;
        }
    }
    return *this;
}
 
tkstring tkstring::get_last_occurence(const char *_s1)
{
    std::size_t found = find_last_of(_s1);
    tkstring name = substr(found+1);
 
    return name;
}
 
tkstring tkstring::remove_last_occurence(const char *_s1)
{
    std::size_t found = find_last_of(_s1);
    tkstring name = substr(0,found);
 
    return  name;
}
 
tkstring tkstring::Form(const char * _format, ...)
{
    va_list argptr;
    va_start(argptr, _format);
    tkstring result(format_string(_format, argptr));
    va_end(argptr);
    return result;
}
 
tkstring tkstring::copy() const
{
    tkstring temp(*this);
    return temp;
}
 
tkstring& tkstring::capitalize()
{
    for(size_t i=0 ; i<length() ; i++) {
        if ((*this)[i] >= 'a' && (*this)[i] <= 'z') {
            (*this)[i] -= ('a' - 'A');
            return *this;
        }
    }
    return *this;
}
 
tkstring tkstring::extract_alpha()
{
    tkstring result{};
 
    const char *cp = data();
    size_t len = length();
 
    for (size_t i = 0; i < len; ++i)
        if (std::isalpha(unsigned_character(cp[i])))
            result += cp[i];
    return result;
}
 
 
tkstring tkstring::remove_alpha()
{
    tkstring result{};
 
    const char *cp = data();
    size_t len = length();
 
    for (size_t i = 0; i < len; ++i)
        if (!std::isalpha(unsigned_character(cp[i])))
            result += cp[i];
    return result;
}

 
bool tkstring::is_alpha() const
{
    const char *cp = data();
    size_t len = length();
    if (len == 0) return false;
    for (size_t i = 0; i < len; ++i)
        if (!std::isalpha(unsigned_character(cp[i])))
            return false;
    return true;
}
 
const char* tkstring::form(const char * _format, ...)
{
    // A small per-thread ring preserves several results used in the same
    // expression while retaining the historical const char* API.
    thread_local std::array<std::string, 8> buffers;
    thread_local std::size_t next_buffer = 0;
    std::string &result = buffers[next_buffer++ % buffers.size()];
 
    va_list argptr;
    va_start(argptr, _format);
    result = format_string(_format, argptr);
    va_end(argptr);
    return result.c_str();
}
 
tkstring::tkstring(double _value, double _error): std::string("")
{
    double y  = _value;
    double ey = _error;
 
    tkstring sy = Form("%1.2e", y);
    tkstring sey = Form("%1.1e", ey);
 
    tkstring sy_dec, sy_exp, sey_dec, sey_exp;
    double y_dec, ey_dec;
    int y_exp, ey_exp;
 
    //Recup de la valeur y
    std::vector<tkstring> loa_y = sy.tokenize("e");
    sy_dec = loa_y.front();
    sy_exp = loa_y.back();
 
    y_dec = sy_dec.atof();
    y_exp = sy_exp.atoi();
 
    //Recup de la valeur ey
    std::vector<tkstring> loa_ey = sey.tokenize("e");
 
    sey_dec = loa_ey.front();
    sey_exp = loa_ey.back();
 
    ey_dec = sey_dec.atof();
    ey_exp = sey_exp.atoi();
 
    double err = ey_dec * pow(10., ey_exp - y_exp);
    tkstring s;
 
    if (!Form("%1.2g", y_dec).contains(".") && err >= 1) {
 
        if (!Form("%1.2g", err).contains(".")) {
            if (y_exp == ey_exp) s = Form("%1.2g.0(%g.0).10$^{%d}$", y_dec, ey_dec, y_exp);
            else s = Form("%1.3g.0(%g.0).10$^{%d}$", y_dec, err, y_exp);
        } else if (Form("%1.2g", err) == Form("%1.1g", err) && Form("%1.2g", err).contains(".")) {
            if (y_exp == ey_exp) s = Form("%1.2g.0(%g0).10$^{%d}$", y_dec, ey_dec, y_exp);
            else s = Form("%1.3g.0(%g0).10$^{%d}$", y_dec, err, y_exp);
        } else {
            if (y_exp == ey_exp) s = Form("%1.2g.0(%g).10$^{%d}$", y_dec, ey_dec, y_exp);
            else s = Form("%1.3g.0(%g).10$^{%d}$", y_dec, err, y_exp);
        }
    } else if (Form("%1.3g", y_dec) == Form("%1.2g", y_dec) && Form("%1.2g", y_dec).contains(".") && err < 1) {
        if (!Form("%1.2g", err).contains(".")) {
            if (y_exp == ey_exp) s = Form("%1.2g0(%g.0).10$^{%d}$", y_dec, ey_dec, y_exp);
            else s = Form("%1.3g0(%g.0).10$^{%d}$", y_dec, err, y_exp);
        } else if (Form("%1.2g", err) == Form("%1.1g", err) && Form("%1.2g", err).contains(".")) {
            if (y_exp == ey_exp) s = Form("%1.2g0(%g0).10$^{%d}$", y_dec, ey_dec, y_exp);
            else s = Form("%1.3g0(%g0).10$^{%d}$", y_dec, err, y_exp);
        } else {
            if (y_exp == ey_exp) s = Form("%1.2g0(%g).10$^{%d}$", y_dec, ey_dec, y_exp);
            else s = Form("%1.3g0(%g).10$^{%d}$", y_dec, err, y_exp);
        }
    } else if (!Form("%1.2g", err).contains(".")) {
        if (y_exp == ey_exp) s = Form("%1.2g(%g.0).10$^{%d}$", y_dec, ey_dec, y_exp);
        else s = Form("%1.3g(%g.0).10$^{%d}$", y_dec, err, y_exp);
    } else if (Form("%1.2g", err) == Form("%1.1g", err) && Form("%1.2g", err).contains(".")) {
        if (y_exp == ey_exp) s = Form("%1.2g(%g0).10$^{%d}$", y_dec, ey_dec, y_exp);
        else s = Form("%1.3g(%g0).10$^{%d}$", y_dec, err, y_exp);
    } else {
        if (y_exp == ey_exp) s = Form("%1.2g(%g).10$^{%d}$", y_dec, ey_dec, y_exp);
        else s = Form("%1.3g(%g).10$^{%d}$", y_dec, err, y_exp);;
    }
 
    s.replace_all(".10$^{0}$", "");
    s.replace_all("0)", ")");
 
    *this = s;
}
 
tkstring& tkstring::remove_all_extra_white_space()
{
    // Remove any superfluous whitespace (or tabs or newlines) from string (modify string)
    // i.e. transform "   Mary               Had\tA   Little \n          Laaaaaaaaaaaaaaaaaamb"
    // into "Mary Had A Little Lamb"
 
    *this = strip_all_extra_white_space();
 
    return *this;
}
 
int tkstring::count_string(const tkstring &_st) const
{
    if (_st.empty()) return 0;
    int count = 0;
    size_t pos=0;
 
    while ((pos = find(_st,pos)) != npos) {
        pos += _st.length();
        count++;
    }
 
    return count;
}
 
tkstring tkstring::strip_all_extra_white_space() const
{
    // Remove any superfluous whitespace (or tabs or newlines) from string (does not modify string)
    // i.e. transform "   Mary               Had\tA   Little \n          Laaaaaaaaaaaaaaaaaamb"
    // into "Mary Had A Little Lamb"
 
    tkstring result;
    result.reserve(size());
    bool pending_space = false;
    for (const char character : *this) {
        const bool whitespace = character == ' ' || character == '\n' || character == '\t';
        if (whitespace) {
            pending_space = !result.empty();
            continue;
        }
        if (pending_space) result += ' ';
        result += character;
        pending_space = false;
    }
    return result;
}
 
bool tkstring::match(const char *_pattern) const
{
    // Check if pattern fit the considered string
    // As in ls shell command the * symbol represents the non discriminant part
    // of the pattern
    // if no * is present in the pattern, the result correspond to TString::Contains method
    // Example KVString st(file_R45.dat);
    // st.Match("*") -> kTRUE
    // st.Match("file") ->kTRUE
    // st.Match("*file*R*") ->kTRUE
    // etc ....
 
    tkstring pat(_pattern);
 
    if (!pat.contains("*")) return this->contains(pat);
    if (pat == "*") return true;
 
    std::vector<tkstring> tok = pat.tokenize("*");
    int n_tok = tok.size();
    if (!pat.begins_with("*"))
        if (!begins_with(tok.front())) {
            return false;
        }
    if (!pat.ends_with("*"))
        if (!ends_with(tok.back())) {
            return false;
        }
 
    int idx = 0, num = 0;
    for (int ii = 0; ii < n_tok; ii += 1) {
        idx = index(tok.at(ii), idx);
        if (idx != -1) {
            num += 1;
            idx++;
        } else break;
    }
    return (num == n_tok);
}

std::istream& tkstring::read_line(std::istream& _strm, bool _skip_white)
{
    if(_skip_white) getline(_strm >> std::ws, *this);
    else getline(_strm, *this);
 
    return _strm;
}
 
double tkstring::get_absolute_error(tkstring val, tkstring error)
{
    if(error.is_empty()) return -1.;
    return error.atof()*tkstring::get_precision(val);
}

double tkstring::get_precision(tkstring st)
{
    double precision = 1.0; int expo; size_t l1,l2;
 
    l1 = st.index(".",0,tkstring::kIgnoreCase);
    l2 = st.index("e",0,tkstring::kIgnoreCase);
 
    if ( l1 == std::string::npos ) { // no point
        if ( l2 == std::string::npos ) // no exponant
            precision = 1.0;
        else { // exponant
            st.erase(0,l2+1);
            expo = st.atoi();
            precision = pow(10.,expo);
        }
    } else { // one point
        if ( l2 == std::string::npos ) { // no exponant
            expo = - (st.size() - l1 - 1);
            precision = pow(10.0,expo);
        }
        else { // exponant
            st.erase(0,l2+1);
            expo = st.atoi();
            expo = - (l2 - l1 - 1) + expo;
            precision = pow(10.0,expo);
        }
    }
    if ( precision < 0 ) precision = -1.0 * precision;
 
    return precision;
}
 
#ifdef HAS_ROOT
ClassImp(tkstring);
#endif