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]                          *
 *                                                                              *
 *    This software is governed by the CeCILL-B license under French law and    *
 *    abiding by the  rules of distribution of free  software.  You can use,    *
 *    modify  and/ or  redistribute  the  software under  the  terms of  the    *
 *    CeCILL-B license as circulated by CEA, CNRS and INRIA at the following    *
 *    URL \"http://www.cecill.info\".                                           *
 *                                                                              *
 *    As a counterpart to the access  to the source code and rights to copy,    *
 *    modify  and redistribute granted  by the  license, users  are provided    *
 *    only with a limited warranty  and the software's author, the holder of    *
 *    the economic  rights, and the  successive licensors have  only limited    *
 *    liability.                                                                *
 *                                                                              *
 *    In this respect, the user's attention is drawn to the risks associated    *
 *    with loading,  using, modifying  and/or developing or  reproducing the    *
 *    software by the user in light of its specific status of free software,    *
 *    that  may mean that  it is  complicated to  manipulate, and  that also    *
 *    therefore  means that it  is reserved  for developers  and experienced    *
 *    professionals having in-depth  computer knowledge. Users are therefore    *
 *    encouraged  to load  and test  the software's  suitability  as regards    *
 *    their  requirements  in  conditions  enabling the  security  of  their    *
 *    systems  and/or data to  be ensured  and, more  generally, to  use and    *
 *    operate it in the same conditions as regards security.                    *
 *                                                                              *
 *    The fact that  you are presently reading this means  that you have had    *
 *    knowledge of the CeCILL-B license and that you accept its terms.          *
 ********************************************************************************/
 
#ifndef tkstring_H
#define tkstring_H
 
#include <iomanip>
#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);
 
}
#endif