tkstring.h

/********************************************************************************
 *   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                                               *
 ********************************************************************************/
 
#ifndef tkstring_H
#define tkstring_H
 
#include <iomanip>
#include <string>
#include <vector>
#include <strings.h>
#include <cstring>
 
#include "tkn_config.h"
 
#ifdef HAS_ROOT
#include "TClass.h"
#endif
 
namespace tkn {
 
class tkstring : public std::string
{
 
public:
    enum ECaseCompare { kExact, kIgnoreCase };
 
public:
    tkstring() : std::string() {}
    tkstring(const char *_c) : std::string(_c) {;}
    tkstring(const unsigned char *_c) : std::string(reinterpret_cast< const char* >(_c)) {;}
    tkstring(const std::string &_s) : std::string(_s.data()) {;}
//    tkstring(const tkstring &_s) : std::string(_s.data()) {;}
    tkstring(double _value, double _error);
    tkstring(char _c) : std::string(&_c) {;}
 
    virtual ~tkstring() {}
 
    tkstring substr(size_type __pos = 0, size_type __n = npos) const;

    bool is_digit() const;
    bool is_float() const;

    bool         is_alpha() const;
    tkstring     extract_alpha();
    tkstring     remove_alpha();

    int atoi() const;
    double atof() const;
    int64_t atoll() const { return std::atoll(data());}
 
//    //! Returns a string formated energy with error
//    static tkstring energy_to_string(double _val, int _precision);
//    //! Returns a string formated energy with error
//    static tkstring energy_error_to_string(double _val, int _precision);

    static double get_precision(tkstring _st);

    static double get_absolute_error(tkstring val, tkstring error);

    std::vector<tkstring> tokenize(const tkstring &_delim = " ") const;

    std::vector<tkstring> tokenize_from_string(const tkstring &_delim) const;

    tkstring     copy() const;

    tkstring&    capitalize();

    tkstring&    to_upper();
    tkstring&    to_lower();

    size_t       index(const char *_s, size_t _pos=0, ECaseCompare _cmp=kExact) const;
    size_t       index(const tkstring &_pat, size_t _pos=0, ECaseCompare _cmp=kExact) const;

    bool         equal_to(const char *_s, ECaseCompare _cmp = kExact) const;
    bool         equal_to(const tkstring &_pat, ECaseCompare _cmp = kExact) const;
 
    bool         begins_with(const char *_s, ECaseCompare _cmp = kExact) const;
    bool         begins_with(const tkstring &_pat, ECaseCompare _cmp = kExact) const;
    bool         ends_with(const char *_s, ECaseCompare _cmp = kExact) const;
    bool         ends_with(const tkstring &_pat, ECaseCompare _cmp = kExact) const;
 
    bool         contains(const char *_pat,    ECaseCompare _cmp = kExact) const;
    bool         contains(const tkstring &_pat, ECaseCompare _cmp = kExact) const;
 
    tkstring     &append(const tkstring &_st);
    tkstring     &prepend(const tkstring &_st);
 
    tkstring     &replace_all(const tkstring &_s1, const tkstring &_s2); // Find&Replace all s1 with s2 if any
    tkstring     &replace_all(const tkstring &_s1, const char *_s2);    // Find&Replace all s1 with s2 if any
    tkstring     &replace_all(const char *_s1, const tkstring &_s2); // Find&Replace all s1 with s2 if any
    tkstring     &replace_all(const char *_s1, const char *_s2);       // Find&Replace all s1 with s2 if any
    tkstring     &replace_all(const char *_s1, size_t _ls1, const char *_s2, size_t _ls2);  // Find&Replace all s1 with s2 if any
 
    tkstring     &remove_all(const tkstring &_s1);
    tkstring     &remove_all(const char *_s1);
 
    tkstring     remove_last_occurence(const char *_s1);
    tkstring     get_last_occurence(const char *_s1);
 
    static tkstring Form(const char * _format, ...);                 // return a string using the c printf method
    static const char* form(const char * _format, ...);                 // return a string using the c printf method
 
    tkstring     & remove_all_extra_white_space();
    tkstring     strip_all_extra_white_space() const;
 
    std::istream     &read_line(std::istream &_strm, bool _skip_white = true);      // Read to EOF or newline
 
    bool         match(const char *_pattern) const;
    bool         match(const tkstring &_pattern) const;
 
    // return true if empty or composed only of blank spaces
    bool         is_empty() const {
        if(length()==0) return true;
        else return (this->strip_all_extra_white_space() == "");
    }
 
    // count the number of occurences of the string _st
    int          count_string(const tkstring &_st) const;
 
#ifdef HAS_ROOT
    ClassDef(tkstring,0);
#endif
};

 
inline tkstring tkstring::substr(size_type __pos, size_type __n) const
{ tkstring tmp = std::string::substr(__pos,__n); return tmp;}
 
inline bool tkstring::equal_to(const tkstring &_pat, ECaseCompare _cmp) const
{ return equal_to(_pat.data(),_cmp); }
 
inline bool tkstring::begins_with(const char *_s, ECaseCompare _cmp) const
{ return index(_s, 0, _cmp) == 0; }
 
inline bool tkstring::begins_with(const tkstring &_pat, ECaseCompare _cmp) const
{ return index(_pat.data(), 0, _cmp) == 0; }
 
inline bool tkstring::ends_with(const tkstring &_pat, ECaseCompare _cmp) const
{ return ends_with(_pat.data(),_cmp); }
 
inline bool tkstring::contains(const tkstring &_pat, ECaseCompare _cmp) const
{ return index(_pat.data(), 0, _cmp) != npos; }
 
inline bool tkstring::contains(const char *_s, ECaseCompare _cmp) const
{ return index(_s, 0, _cmp) != npos; }
 
inline size_t tkstring::index(const tkstring &_pat, size_t _pos, ECaseCompare _cmp) const
{ return index(_pat.data(), _pos, _cmp); }
 
inline tkstring &tkstring::replace_all(const tkstring &_s1, const tkstring &_s2)
{ return replace_all(_s1.data(), _s1.length(), _s2.data(), _s2.length()) ; }
 
inline tkstring &tkstring::replace_all(const tkstring &_s1, const char *_s2)
{ return replace_all(_s1.data(), _s1.length(), _s2, _s2 ? strlen(_s2) : 0); }
 
inline tkstring &tkstring::replace_all(const char *_s1, const tkstring &_s2)
{ return replace_all(_s1, _s1 ? strlen(_s1) : 0, _s2.data(), _s2.length()); }
 
inline tkstring &tkstring::replace_all(const char *_s1,const char *_s2)
{ return replace_all(_s1, _s1 ? strlen(_s1) : 0, _s2, _s2 ? strlen(_s2) : 0); }
 
inline tkstring &tkstring::remove_all(const tkstring &_s1)
{ return replace_all(_s1, "") ; }
 
inline tkstring &tkstring::remove_all(const char *_s1)
{ return replace_all(_s1, "") ; }
 
inline bool tkstring::match(const tkstring &_pat) const
{ return match(_pat.data()); }
 
inline tkstring &tkstring::prepend(const tkstring &_st)
{ insert(0,_st); return *this;}
 
inline tkstring &tkstring::append(const tkstring &_st)
{ std::string::append(_st); return *this;}
 
tkstring     &append(const tkstring &_st);
tkstring     &preprend(const tkstring &_st);
 
std::string wrap_text(const tkstring &_text, size_t _first_content_col, size_t _continuation_col, size_t _max_line_width = 80);
 
}
#endif