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 <list>
#include <cstdarg>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <string>
 
namespace tkn {
}
 
using namespace tkn;
 
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
{
    const char* cp = data();
    size_t len = length();
    if (len == 0) return false;
    int b = 0, d = 0;
    for (size_t i = 0; i < len; ++i) {
        if (cp[i] != ' ' && !isdigit(cp[i])) return false;
        if (cp[i] == ' ') b++;
        if (isdigit(cp[i])) d++;
    }
    return !(b && !d);
}

 
bool tkstring::is_float() const
{
    //we first check if we have an integer, in this case, IsDigit() will be true straight away
    if (is_digit()) return true;
 
    tkstring tmp = *this;
    //now we look for occurrences of '.', ',', e', 'E', '+', '-' and replace each
    //with ' '. if it is a floating point, IsDigit() will then return kTRUE
    int i_dot, i_e, i_plus, i_minus, i_comma;
 
    i_dot = tmp.index(".");
    if (i_dot > -1) tmp.replace(i_dot, 1, " ", 1);
    i_comma = tmp.index(",");
    if (i_comma > -1) tmp.replace(i_comma, 1, " ", 1);
    i_e = tmp.index("e");
    if (i_e > -1)
        tmp.replace(i_e, 1, " ", 1);
    else {
        //try for a capital "E"
        i_e = tmp.index("E");
        if (i_e > -1) tmp.replace(i_e, 1, " ", 1);
    }
    i_plus = tmp.index("+");
    if (i_plus > -1) tmp.replace(i_plus, 1, " ", 1);
    i_minus = tmp.index("-");
    if (i_minus > -1) tmp.replace(i_minus, 1, " ", 1);
 
    //test if it is now uniquely composed of numbers
    return tmp.is_digit();
}
 
//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
{
    int end = index(" ");
    //if no whitespaces in string, just use atoi()
    if (end == -1)
        return std::atoi(data());
 
    tkstring tmp = *this;
    tmp.erase(end,1);
    return std::atoi(tmp.data());
}

double tkstring::atof() const
{
    //look for a comma and some whitespace
    int comma = index(",");
    int end = index(" ");
    //if no commas & no whitespace in string, just use atof()
    if (comma == -1 && end == -1)
        return std::atof(data());
    tkstring tmp = *this;
    if (comma > -1) {
        //replace comma with full stop
        tmp.replace(comma, 1, ".");
    }
    //no whitespace ?
    if (end == -1)
        return std::atof(tmp.data());
    //remove whitespace
    tmp.erase(end,1);
 
    return std::atof(tmp.data());
}

size_t tkstring::index(const char *_s, size_t _pos, ECaseCompare _cmp) const
{
    if(_cmp == ECaseCompare::kExact) return find(_s,_pos);
 
    tkstring tmp_copy = *this;
    tmp_copy.to_lower();
    tkstring test(_s);
    test.to_lower();
    return tmp_copy.find(test,_pos);
}

 
bool tkstring::equal_to(const char *_s, ECaseCompare _cmp) const
{
    if (_cmp == kExact)
        return strcmp(_s, data()) == 0;
    return strcasecmp(_s, data()) == 0;
}
 
bool tkstring::ends_with(const char *_s, ECaseCompare _cmp) const
{
    if (!_s) return true;
 
    size_t l = strlen(_s);
    if (l > length()) return false;
    const char *s2 = data() + length() - l;
 
    if (_cmp == kExact)
        return strcmp(_s, s2) == 0;
    return strcasecmp(_s, s2) == 0;
}
 
std::vector<tkstring> tkstring::tokenize(const tkstring &_delim) const
{
    std::vector<tkstring> tokens;
    std::list<int> splitIndex;
 
    size_t i, start, nrDiff = 0;
 
    for (i = 0; i < _delim.length(); i++) {
        start = 0;
        while (start < length()) {
            size_t pos = find(_delim.at(i), start);
            if (pos == npos) break;
            splitIndex.push_back(pos);
            start = pos + 1;
        }
        if (start > 0) nrDiff++;
    }
    splitIndex.push_back(length());
 
    if (nrDiff > 1)
        splitIndex.sort();
 
    start = -1;
    std::list<int>::const_iterator it;
#ifndef R__HPUX
    for (it = splitIndex.begin(); it != splitIndex.end(); ++it) {
#else
    for (it = splitIndex.begin(); it != (std::list<int>::const_iterator) splitIndex.end(); ++it) {
#endif
        size_t stop = *it;
        if (stop - 1 >= start + 1) {
            tkstring tok(substr(start+1, stop-start-1));
            if(tok.length()) tokens.push_back(tok);
        }
        start = stop;
    }
 
    return tokens;
}
 
std::vector<tkstring> tkstring::tokenize_from_string(const tkstring &_delim) const {
    std::vector<tkstring> 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, ...)
{
    static char *buffer;
    static size_t buffer_size;
 
    va_list argptr;
    va_start(argptr, _format);
    size_t length = vsnprintf(buffer, buffer_size, _format, argptr);
    va_end(argptr);
 
    if (length + 1 > buffer_size) {
        buffer_size = length + 1;
        char *tmp = static_cast<char*>(realloc(buffer, buffer_size));
        if(tmp) buffer = tmp;
 
        va_start(argptr, _format);
        vsnprintf(buffer, buffer_size, _format, argptr);
        va_end(argptr);
    }
 
    tkstring result(buffer);
 
    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 (isalpha(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 (!isalpha(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 (!isalpha(cp[i]))
            return false;
    return true;
}
 
const char* tkstring::form(const char * _format, ...)
{
    static char *buffer;
    static size_t buffer_size;
 
    va_list argptr;
    va_start(argptr, _format);
    size_t length = vsnprintf(buffer, buffer_size, _format, argptr);
    va_end(argptr);
 
    if (length + 1 > buffer_size) {
        buffer_size = length + 1;
        char *tmp = static_cast<char*>(realloc(buffer, buffer_size));
        if(tmp) buffer = tmp;
 
        va_start(argptr, _format);
        vsnprintf(buffer, buffer_size, _format, argptr);
        va_end(argptr);
    }
 
    return buffer;
}
 
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"
 
    tkstring tmp = *this;
    tkstring tmp2;
 
    for(const auto &s: tmp.tokenize(" \n\t")) {
        if (tmp2.length()) tmp2 += " ";
        tmp2 += s;
    }
 
    if(tmp2.begins_with(' ')) tmp2.erase(1);
 
    *this = tmp2;
 
    return *this;
}
 
int tkstring::count_string(const tkstring &_st) const
{
    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 tmp = *this;
    tkstring tmp2;
 
    for(const auto &s: tmp.tokenize(" \n\t")) {
        if (tmp2.length()) tmp2 += " ";
        tmp2 += s;
    }
 
    if(tmp2.begins_with(' ')) tmp2.erase(1);
 
    return tmp2;
}
 
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