MCDV/util.h

   1 #pragma once
   2 #include <vector>
   3 #include <string>
   4 #include <sstream>
   5 #include <algorithm>
   6
   7 #include <regex>
   8
   9
  10 // Attach to a class for verbosity debug message control
  11 namespace util {
  12         class verboseControl {
  13         public:
  14                 bool use_verbose = false;
  15
  16                 //Variadic print
  17                 void debug() {
  18                         std::cout << std::endl;
  19                 }
  20                 template<typename First, typename ... Strings>
  21                 void debug(First arg, const Strings&... rest) {
  22                         if (this->use_verbose) {
  23                                 std::cout << arg << " ";
  24                                 debug(rest...);
  25                         }
  26                 }
  27         };
  28 }
  29
  30 std::vector<std::string> split(std::string string, char delim)
  31 {
  32         std::stringstream cStream(string);
  33         std::string seg;
  34         std::vector<std::string> sgts;
  35
  36         while (std::getline(cStream, seg, delim))
  37                 sgts.push_back(seg);
  38
  39         return sgts;
  40 }
  41
  42 std::vector<std::string> split(std::string s, std::string delimiter)
  43 {
  44         std::vector<std::string> sgts;
  45         size_t pos = 0;
  46         std::string token;
  47         while ((pos = s.find(delimiter)) != std::string::npos) {
  48                 token = s.substr(0, pos);
  49                 sgts.push_back(token);
  50                 s.erase(0, pos + delimiter.length());
  51         }
  52         sgts.push_back(s);
  53         return sgts;
  54 }
  55
  56 namespace sutil
  57 {
  58         std::string trimspace(std::string const& str)
  59         {
  60                 if (str.empty())
  61                         return str;
  62
  63                 std::size_t firstScan = str.find_first_not_of(' ');
  64                 std::size_t first = firstScan == std::string::npos ? str.length() : firstScan;
  65                 std::size_t last = str.find_last_not_of(' ');
  66                 return str.substr(first, last - first + 1);
  67         }
  68
  69         std::string trimbt(std::string const& str)
  70         {
  71                 if (str.empty())
  72                         return str;
  73
  74                 std::size_t firstScan = str.find_first_not_of('\t');
  75                 std::size_t first = firstScan == std::string::npos ? str.length() : firstScan;
  76                 std::size_t last = str.find_last_not_of('\t');
  77                 return str.substr(first, last - first + 1);
  78         }
  79
  80         std::string trim(std::string str)
  81         {
  82                 return trimspace(trimbt(str));
  83         }
  84
  85         std::string removeChar(std::string str, char ch)
  86         {
  87                 str.erase(std::remove(str.begin(), str.end(), ch), str.end());
  88                 return str;
  89         }
  90
  91         std::vector<std::string> regexmulti(std::string src, std::string pattern)
  92         {
  93                 const std::regex r(pattern);
  94
  95                 std::smatch res;
  96
  97                 std::vector<std::string> matches;
  98                 while (std::regex_search(src, res, r)) {
  99                         matches.push_back(res[0]);
 100                         src = res.suffix();
 101                 }
 102
 103                 return matches;
 104         }
 105
 106         std::vector<std::string> regexmulti(std::string src, const std::regex pattern)
 107         {
 108                 std::smatch res;
 109
 110                 std::vector<std::string> matches;
 111                 while (std::regex_search(src, res, pattern)) {
 112                         matches.push_back(res[0]);
 113                         src = res.suffix();
 114                 }
 115
 116                 return matches;
 117         }
 118 }