20 #include <boost/algorithm/string/classification.hpp>
21 #include <boost/algorithm/string/split.hpp>
32 #include <boost/filesystem.hpp>
37 const boost::regex& reg_expr,
38 const std::function<
void(std::string&,
const boost::smatch&)>& shim_fn) {
41 auto start_it = result.cbegin();
42 auto end_it = result.cend();
44 if (!boost::regex_search(start_it, end_it, what, reg_expr)) {
47 const auto next_start =
50 start_it = result.cbegin() + *next_start;
52 shim_fn(result, what);
54 start_it = result.cbegin();
55 end_it = result.cend();
61 boost::regex literal_string_regex{R
"(([^']+)('(?:[^']+|'')+'))", boost::regex::perl};
63 auto it = query.begin();
65 std::vector<std::pair<size_t, size_t>> positions;
68 if (!boost::regex_search(it, query.end(), what, literal_string_regex)) {
71 }
catch (
const std::exception& e) {
72 LOG(
WARNING) <<
"Error processing literals: " << e.what()
73 <<
"\nContinuing query parse...";
83 positions.emplace_back(prev_it + what[1].length() - query.begin(),
90 constexpr std::regex::flag_type flags =
91 std::regex::ECMAScript | std::regex::icase | std::regex::optimize;
92 static const std::initializer_list<std::pair<std::regex, std::string>> rules{
94 R
"(\b((?:password|s3_access_key|s3_secret_key|s3_session_token|username|credential_string)\s*=\s*)'.+?')",
97 {std::regex(R
"((\\set_license\s+)\S+)", flags), "$1XXXXXXXX"}};
99 rules.begin(), rules.end(), query_str, [](
auto& str,
auto& rule) {
100 return std::regex_replace(str, rule.first, rule.second);
105 const size_t units_per_k_unit{1024};
106 const std::vector<std::string> byte_units = {
" bytes",
"KB",
"MB",
"GB",
"TB",
"PB"};
107 const std::vector<size_t> bytes_per_scale_unit = {size_t(1),
114 if (bytes < units_per_k_unit) {
118 const size_t byte_scale = log(bytes) / log(units_per_k_unit);
121 const size_t scaled_bytes_left_of_decimal = bytes / bytes_per_scale_unit[byte_scale];
122 const size_t scaled_bytes_right_of_decimal = bytes % bytes_per_scale_unit[byte_scale];
123 const size_t fractional_digits =
static_cast<double>(scaled_bytes_right_of_decimal) /
124 bytes_per_scale_unit[byte_scale] * 100.;
131 return std::string(v);
139 std::pair<std::string_view, const char*>
substring(
const std::string& str,
140 size_t substr_length) {
144 const auto str_size = str.size();
145 if (substr_length >= str_size) {
148 std::string_view substr(str.c_str(), substr_length);
149 return {substr,
"..."};
153 static char charset[] =
155 "abcdefghijklmnopqrstuvwxyz"
156 "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
158 static std::mt19937 prng{std::random_device{}()};
159 static std::uniform_int_distribution<size_t> dist(0, strlen(charset) - 1);
163 for (
size_t i = 0; i < len; i++) {
164 str += charset[dist(prng)];
173 std::vector<std::string>
split(std::string_view str,
174 std::string_view delim,
175 std::optional<size_t> maxsplit) {
176 std::vector<std::string>
result;
179 if (!delim.empty()) {
180 std::string::size_type i = 0, j = 0;
181 while ((i = str.find(delim, i)) != std::string::npos &&
182 (!maxsplit || result.size() < maxsplit.value())) {
183 result.emplace_back(str, j, i - j);
187 result.emplace_back(str, j, std::string::npos);
193 std::string::size_type i = 0, j = 0;
194 for (; i < str.size(); ++i) {
196 if (!isspace(str[i])) {
202 if (isspace(str[i])) {
204 result.emplace_back(str, j, i - j);
207 if ((maxsplit && result.size() == maxsplit.value())) {
209 result.emplace_back(str, j, std::string::npos);
216 result.emplace_back(str, j, std::string::npos);
223 std::string::size_type i, j;
224 for (i = 0; i < str.size() && std::isspace(str[i]); ++i) {
226 for (j = str.size(); j > i && std::isspace(str[j - 1]); --j) {
228 return str.substr(i, j - i);
231 std::string
strip(std::string_view str) {
238 const std::vector<std::pair<size_t, size_t>>& literal_positions) {
239 const auto end = start + length;
240 for (
const auto& literal_position : literal_positions) {
241 if (literal_position.first <= start && end <= literal_position.second) {
242 return literal_position.second;
251 std::string& str) noexcept {
252 char inside_quote = 0;
253 bool previous_c_was_backslash =
false;
254 for (
auto& c : str) {
256 if (c ==
'\'' || c ==
'\"') {
258 if (!previous_c_was_backslash) {
260 if (inside_quote == c) {
263 }
else if (inside_quote == 0) {
268 }
else if (inside_quote == 0) {
270 if (c ==
'\n' || c ==
'\t' || c ==
'\r') {
278 previous_c_was_backslash = !previous_c_was_backslash;
280 previous_c_was_backslash =
false;
286 return (inside_quote == 0);
291 std::stringstream ss;
292 ss << std::quoted(filename, quote, escape);
299 auto sanitized_str{str};
300 for (
auto& c : sanitized_str) {
301 c = (c < 32) ?
' ' : c;
303 return sanitized_str;
DEVICE auto accumulate(ARGS &&...args)
std::string filename(char const *path)