ccstring.hpp

Go to the documentation of this file.

//
//  ccstring: useful functions for C++ strings
//  (C) Eric Lecolinet 2016/17 - https:www.telecom-paristech.fr/~elc
//

#ifndef ccuty_ccstring
#define ccuty_ccstring

#include <string>
#include <vector>
#include <sstream>
#include <cctype>
#include <cstdlib>
#include <cerrno>
#include <regex>

namespace ccuty {

  inline constexpr unsigned long long strid(const char* str,
                                            int last = 32767,
                                            unsigned long long id = 0) {
    return (!*str || last==0) ? id : ccuty::strid(str+1, last-1, (id<<8) + *str);
  }
  
  inline unsigned long long strid(const std::string& str, int last = 32767) {
    return ccuty::strid(str.c_str(), last, 0);
  }
  
  struct strdelim {
  
    strdelim() {}
  
    strdelim(const std::string& delimiters) {pattern(delimiters);}
    
    strdelim(const char* delimiters) {pattern(delimiters);}
    
    void reset() {pos_ = 0; size_ = 0;}

    void pattern(const std::string& delimiters) {
      pattern_ = delimiters;
      if (delimiters.empty()) spaces_ = true;
    }
    
    strdelim& spaces(bool val = true) {spaces_ = val; return *this;}
    
    strdelim& quotes(bool val = true) {quotes_ = val; return *this;}

    strdelim& trim(bool val = true) {trim_ = val; return *this;}
    
    void pos(size_t val) {pos_ = val;}
    
    size_t pos() const {return pos_;}
    
    char matched() const {return matched_;}
  
    // impl.
    size_t pos_{0}, size_{0};
    std::string pattern_;
    char matched_{0};
    bool spaces_{false}, quotes_{false}, trim_{true};
  };
  
  inline size_t strsplit(std::vector<std::string>& tokens,
                         const std::string& str, ccuty::strdelim delimiters, int limit = 0);
  
  inline size_t strsplit(std::string& left, std::string& right,
                         const std::string& str, ccuty::strdelim delimiters);
  
  inline size_t regsplit(std::vector<std::string>& tokens,
                         const std::string& str, ccuty::strdelim delimiters, int limit = 0);

  bool strtoken(std::string& token, const std::string& str, ccuty::strdelim& delimiters);
  
  inline void strtrim(std::string& str, ccuty::strdelim toremove);
  
  inline void strtrim(std::string& str) {
    ccuty::strtrim(str, ccuty::strdelim(""));
  }
  
  inline void unquote(std::string& str) {
    strtrim(str, ccuty::strdelim("").quotes());
  }
  
  inline std::string trimmed(const std::string& str) {
    std::string result(str);
    ccuty::strtrim(result, "");
    return result;
  }
  
  inline std::string unquoted(const std::string& str) {
    std::string result(str);
    ccuty::unquote(result);
    return result;
  }

  inline int icompare(const std::string& a, const std::string& b) {
    size_t len = a.length() < b.length() ? a.length() : b.length();
    for (size_t k=0; k<len; ++k) {
      if (::tolower(a[k]) < ::tolower(b[k])) return -1;
      else if (::tolower(a[k]) > ::tolower(b[k])) return +1;
    }
    return a.length()==b.length() ? 0 : a.length()<b.length() ? -1 : +1;
  }
  
  inline bool iequal(const std::string& str1, const std::string& str2) {
    return str1.length()!=str2.length() ? false : icompare(str1, str2)==0;
  }
  
  inline void lowerize(std::string& str) {
    for (auto& c : str) c = char(::tolower(c));
  }
  
  inline void upperize(std::string& str) {
    for (auto& c : str) c = char(::toupper(c));
  }
  
  inline std::string tolower(const std::string& str) {
    std::string s(str); ccuty::lowerize(s); return s;
  }
  
  inline std::string toupper(const std::string& str) {
    std::string s(str); ccuty::upperize(s); return s;
  }
  
  inline bool from_string(bool& var, const std::string& str) {
    if (str == "true") {var = true; return true;}
    else if (str == "false") {var = false; return true;}
    else {var = false; return false;}
  }
  
  inline bool from_string(long& var, const std::string& str) {
    char* p{nullptr};
    errno = 0;
    var = ::strtol(str.c_str(), &p, 0);
    if (p == nullptr || errno != 0) {var = 0; return false;} else return true;
  }
  
  inline bool from_string(unsigned long& var, const std::string& str) {
    char* p{nullptr};
    errno = 0;
    var = ::strtoul(str.c_str(), &p, 0);
    if (p == nullptr || errno != 0) {var = 0; return false;} else return true;
  }
  
  inline bool from_string(float& var, const std::string& str) {
    char* p{nullptr};
    errno = 0;
    var = ::strtof(str.c_str(), &p);
    if (p == nullptr || errno != 0) {var = 0; return false;} else return true;
  }
  
  inline bool from_string(double& var, const std::string& str) {
    char* p{nullptr};
    errno = 0;
    var = ::strtod(str.c_str(), &p);
    if (p == nullptr || errno != 0) {var = 0; return false;} else return true;
  }
  
  inline bool from_string(long double& var, const std::string& str) {
    char* p{nullptr};
    errno = 0;
    var = ::strtold(str.c_str(), &p);
    if (p == nullptr || errno != 0) {var = 0; return false;} else return true;
  }
  
  inline int system(const std::string& command) {
    return ::system(command.c_str());
  }
  
  // - - - implementation - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  inline void strtrim(std::string& str, ccuty::strdelim d) {
    if (str.empty()) return;
    if (d.size_ == 0) d.size_ = str.size();
    if (d.pos_ >= d.size_) return;
    
    const char *p = str.c_str() + d.pos_;
    const char *end = str.c_str() + d.size_;

    while (p < end   // trim left
           && ((d.spaces_ && ::isspace(*p))
               || d.pattern_.find(*p) != std::string::npos)
           ) ++p;
    if (p >= end) {str.clear(); return;}
    
    --end;
    while (end >= p   // trim right
           && ((d.spaces_ && ::isspace(*end))
               || d.pattern_.find(*end) != std::string::npos)
           ) --end;
    if (end < p) {str.clear(); return;}
    
    if (d.quotes_) {
      if (*p == '"' || *p == '\'') ++p;
      if (*end == '"'  || *end == '\'') --end;
      if (end < p) {str.clear(); return;}
    }
    str.assign(p, size_t(end-p+1));
  }
  
  inline bool strtoken(std::string& token, const std::string& str, ccuty::strdelim& d) {
    token.clear();
    d.matched_ = 0;
    if (d.size_ == 0) d.size_ = str.size();
    if (d.pos_ >= d.size_) {d.matched_ = 0; return false;}
    
    const char* p = str.c_str() + d.pos_;
    char delim = 0;
    
    if (d.trim_) {
      while (*p != 0 && ::isspace(*p)) ++p;  // skip spaces
      if (*p == 0) {d.pos_ = d.size_; d.matched_ = 0; return false;}
    }
    const char* begtok = p;
    
    if (d.quotes_ && (*p == '"' || *p == '\'')) {  // quoted token
      char quote = *p++;
      while (*p != 0 && *p != quote) ++p;
      if (*p == 0) {    // ending quote not found, taking rest
        token.assign(begtok+1, size_t(p-begtok));
        d.pos_ = d.size_; d.matched_ = 0; return true;
      }
      else {
        token.assign(begtok+1, size_t(p-begtok-1));
        ++p; // after quote
        delim = ::isspace(*p) ? ' ' : quote;
        goto after_token;
      }
    }
    else {   // unquoted string
      while (*p != 0       // find delim
             && (!d.spaces_ || !::isspace(*p))
             && (!d.quotes_ || (*p != '"' && *p != '\''))
             && d.pattern_.find(*p) == std::string::npos) ++p;
      
      if (d.spaces_ && ::isspace(*p)) {
        token.assign(begtok, size_t(p-begtok));
        delim = ' ';
        goto after_token;
      }
      else if (d.quotes_ && (*p == '"' || *p == '\'')) {
        token.assign(begtok, size_t(p-begtok));
        delim = *p;
        goto after_token;
      }
      else {
        const char* endtok = p-1;
        if (d.trim_) {
          while (endtok > begtok && ::isspace(*endtok)) --endtok;
        }
        token.assign(begtok, size_t(endtok-begtok+1));
        if (*p == 0) {
          d.pos_ = d.size_; d.matched_ = 0; return true;
        }
        else {
          d.pos_ = size_t(p - str.c_str() + 1);
          d.matched_ = *p;
          return true;
        }
      }
    }
    return false;
    
  after_token:
    if (d.trim_) {
      while (*p != 0 && ::isspace(*p)) ++p;
    }
    if (*p == 0) {
      d.pos_ = d.size_; d.matched_ = 0; return true;
    }
    // nb: returns delim rather then space when both conds apply
    else if (d.pattern_.find(*p) != std::string::npos) {
      d.pos_ = size_t(p - str.c_str() + 1);
      d.matched_ = *p;
      return true;
    }
    else {  // delim is quote or space
      d.pos_ = size_t(p - str.c_str() + (d.trim_ ? 0 : 1));
      d.matched_ = delim;
      return true;
    }
  }

  inline size_t strsplit(std::string& left, std::string& right, const std::string& str,
                         ccuty::strdelim delim) {
    std::string s(str);     // str may be the same string as left or right
    left.clear(); right.clear();
    size_t n{0};
    if (ccuty::strtoken(left, s, delim)) n++;
    delim.pattern_.clear();
    delim.spaces(false);
    if (n==0) {if (ccuty::strtoken(left, s, delim)) n++;}
    else {if (ccuty::strtoken(right, s, delim)) n++;}
    return n;
  }
  
  inline size_t strsplit(std::vector<std::string>& tokens, const std::string& str,
                         ccuty::strdelim delim, int limit) {
    tokens.clear();
    std::string tok;
    if (limit <= 0) limit = 32767;
    while (int(tokens.size()) < limit-1 && ccuty::strtoken(tok, str, delim)) tokens.push_back(tok);
    delim.pattern_.clear();
    delim.spaces(false);
    if (ccuty::strtoken(tok, str, delim) && !tok.empty()) tokens.push_back(tok);
    return tokens.size();
  }
  
  inline size_t regsplit(std::vector<std::string>& tokens, const std::string& str,
                         ccuty::strdelim delim, int limit) {
    tokens.clear();
    if (str.empty()) return 0;
    std::regex expr(delim.spaces_ ? "[:space:]"+delim.pattern_ : delim.pattern_);
    const char *p = str.c_str(), *prefix = p;
    
    auto trimRight = [&tokens](const char* beg, const char* end, bool atEnd) {
      while (end >= beg && ::isspace(*end)) --end;
      if (end < beg) {if (!atEnd) tokens.push_back("");}
      else tokens.push_back(std::string(beg, end-beg+1));
    };
    
    while (limit <= 0 || int(tokens.size()) < limit-1) {
      if (delim.trim_) { // trim left
        while (*p != 0 && ::isspace(*p)) ++p;
        if (*p == 0) {prefix = p; break;}
      }
      prefix = p;
      std::cmatch m;
      if (!std::regex_search(p, m, expr)) break;
      else {
        if (!delim.trim_) tokens.push_back(std::string(prefix, p-prefix+m.position()));
        else (trimRight)(prefix, p+m.position()-1, false);
        p += m.position() + m.length();
        prefix = p;
      }
    }
    
    if (*prefix) {
      if (!delim.trim_) tokens.push_back(std::string(prefix));
      else {
        while (*prefix != 0 && ::isspace(*prefix)) ++prefix;
        if (*prefix != 0) (trimRight)(prefix, prefix+::strlen(prefix)-1, true);
      }
    }
    return tokens.size();
  }
}

#endif