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 <unordered_map>
#include <vector>
 
namespace cepgen {
  class Limits;
  class ParametersList;
  namespace utils {
    template <typename T>
    inline std::string toString(const T& obj) {
      return std::to_string(obj);
    }
    template <>
    std::string toString(const Limits&);
    template <>
    std::string toString(const ParametersList&);
    template <>
    inline std::string toString(const std::string& obj) {
      return 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'
    }
    template <typename... Args>
    inline std::string format(const std::wstring& fmt, Args... args) {
      return format(toString(fmt), 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
    };
    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
    };
    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 = false);
    template <typename T>
    inline std::string merge(const T& val, const std::string&) {
      return toString(val);
    }
    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::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);
          });
    }
    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);
    }
    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 errnum);                    
 
  }  // namespace utils
}  // namespace cepgen
 
#endif