String.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2013-2024  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGen_Utils_String_h
#define CepGen_Utils_String_h
 
#include <algorithm>
#include <functional>
#include <numeric>
#include <set>
#include <string>
#include <vector>
 
namespace cepgen {
  class Limits;
  class ParametersList;
}  // namespace cepgen
namespace cepgen::utils {
  template <typename T>
  inline std::string toString(const T& obj) {
    return std::to_string(obj);
  }
  inline std::string toString(const T& obj) {…}
  template <>
  std::string toString(const Limits&);
  template <>
  std::string toString(const ParametersList&);
  template <>
  inline std::string toString(const std::string& obj) {
    return obj;
  }
  inline std::string toString(const std::string& obj) {…}
  template <>
  std::string toString(const double&);
  template <>
  std::string toString(const std::wstring&);       
  std::wstring toWstring(const std::string& str);  
  std::string toCamelCase(const std::string&, bool lower = true);  
  bool isInt(const std::string&);                                  
  bool isFloat(const std::string&);  
 
  template <typename... Args>
  inline std::string format(const std::string& fmt, Args... args) {
    // first check how much space is required for output buffer
    size_t size = snprintf(nullptr, 0, fmt.data(), args...) + 1;  // extra space for last '\0'
    if (size <= 0)
      return fmt;
    std::vector<char> buffer(size);
    snprintf(buffer.data(), size, fmt.data(), args...);
    return std::string(buffer.data(), buffer.data() + size - 1);  // strip last '\0'
  }
  inline std::string format(const std::string& fmt, Args... args) {…}
  template <typename... Args>
  inline std::string format(const std::wstring& fmt, Args... args) {
    return format(toString(fmt), args...);
  }
  inline std::string format(const std::wstring& fmt, Args... args) {…}
  std::string demangle(const char*);           
  std::string timeAs(const std::string& fmt);  
  std::string yesno(bool test);                
  template <typename T>
  std::string boldify(T str);
  enum class Colour {
    none = -1,
    reset = 0,
    black = 30,
    red = 31,
    green = 32,
    yellow = 33,
    blue = 34,
    magenta = 35,
    cyan = 36,
    white = 37
  };
  enum class Colour {…};
  std::ostream& operator<<(std::ostream&, const Colour&);
  enum struct Modifier : int16_t {
    none = -1,
    reset = 0,
    bold = 1,
    dimmed = 1 << 1,
    italic = 1 << 2,
    underline = 1 << 3,
    blink = 1 << 4,
    reverse = 1 << 6
  };
  enum struct Modifier : int16_t {…};
  std::ostream& operator<<(std::ostream&, const Modifier&);
  Modifier operator|(const Modifier&, const Modifier&);
  std::string colourise(const std::string&, const Colour&, const Modifier& = Modifier::none);
  std::string sanitise(const std::string&);
  std::string parseSpecialChars(const std::string&);
  size_t replaceAll(std::string& str, const std::string& from, const std::string& to);
  std::string replaceAll(const std::string& str, const std::string& from, const std::string& to);
  std::string replaceAll(const std::string& str, const std::vector<std::pair<std::string, std::string> >& keys);
  std::vector<std::string> split(const std::string&, char, bool trim_parts = false);
  template <typename T>
  inline std::string merge(const T& val, const std::string&) {
    return toString(val);
  }
  inline std::string merge(const T& val, const std::string&) {…}
  template <typename T>
  std::string merge(const std::vector<T>&, const std::string&);
  template <typename T>
  std::string merge(const std::vector<std::vector<T> >&, const std::string&);
  template <typename T, size_t N>
  inline std::string merge(const std::array<T, N>& arr, const std::string& delim) {
    return merge(std::vector<T>(arr.begin(), arr.end()), delim);
  }
  inline std::string merge(const std::array<T, N>& arr, const std::string& delim) {…}
  inline std::string merge(const std::string& val, const std::string&) { return val; }
  std::string merge(const ParametersList&, const std::string&);
  std::string merge(const Limits&, const std::string&);
 
  std::string toUpper(const std::string&);  
  std::string toLower(const std::string&);  
 
  std::vector<std::string> between(const std::string& str, const std::string& beg, const std::string& end);
  std::string s(const std::string&, float, bool = true);  
 
  template <class T>
  inline std::string repr(const std::vector<T>& vec,
                          const std::function<std::string(const T&)>& printer,
                          const std::string& sep = ",") {
    if (vec.empty())
      return "{}";
    return std::accumulate(
        std::next(vec.begin()), vec.end(), printer(*vec.begin()), [&printer, &sep](std::string str, const T& xv) {
          return std::move(str) + sep + printer(xv);
        });
  }
  inline std::string repr(const std::vector<T>& vec, {…}
  template <class T>
  inline std::string repr(const std::vector<T>& vec, const std::string& sep = ",") {
    return repr<T>(vec, [](const T& xv) { return toString(xv); }, sep);
  }
  inline std::string repr(const std::vector<T>& vec, const std::string& sep = ",") {…}
  template <class T>
  inline std::string repr(const std::set<T>& vec, const std::string& sep = ",") {
    return repr<T>(std::vector(vec.begin(), vec.end()), sep);
  }
  inline std::string repr(const std::set<T>& vec, const std::string& sep = ",") {…}
  std::string randomString(size_t size);      
  std::string ltrim(const std::string& str);  
  std::string rtrim(const std::string& str);  
  inline std::string trim(const std::string& str) { return ltrim(rtrim(str)); }  
  std::string strip(const std::string&);                    
  bool startsWith(const std::string&, const std::string&);  
  bool endsWith(const std::string&, const std::string&);    
  std::string describeError(int error_number);              
 
}  // namespace cepgen::utils
 
#endif
  std::string strip(const std::string&);                     {…}