Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file StringUtils.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Laura Bieker
17 : /// @author Michael Behrisch
18 : /// @author Robert Hilbrich
19 : /// @date unknown
20 : ///
21 : // Some static methods for string processing
22 : /****************************************************************************/
23 : #include <config.h>
24 :
25 : #include <string>
26 : #include <iostream>
27 : #include <cstdio>
28 : #include <cstring>
29 : #include <regex>
30 : #ifdef WIN32
31 : #define NOMINMAX
32 : #include <windows.h>
33 : #undef NOMINMAX
34 : #else
35 : #include <unistd.h>
36 : #endif
37 : #include <xercesc/util/TransService.hpp>
38 : #include <xercesc/util/TranscodingException.hpp>
39 : #include <utils/common/UtilExceptions.h>
40 : #include <utils/common/ToString.h>
41 : #include <utils/common/StringTokenizer.h>
42 : #include "StringUtils.h"
43 :
44 : #define KM_PER_MILE 1.609344
45 :
46 :
47 : // ===========================================================================
48 : // static member definitions
49 : // ===========================================================================
50 : std::string StringUtils::emptyString;
51 : XERCES_CPP_NAMESPACE::XMLLCPTranscoder* StringUtils::myLCPTranscoder = nullptr;
52 :
53 :
54 : // ===========================================================================
55 : // method definitions
56 : // ===========================================================================
57 : std::string
58 1590375 : StringUtils::prune(const std::string& str) {
59 : const std::string::size_type endpos = str.find_last_not_of(" \t\n\r");
60 1590375 : if (std::string::npos != endpos) {
61 1587238 : const int startpos = (int)str.find_first_not_of(" \t\n\r");
62 1587238 : return str.substr(startpos, endpos - startpos + 1);
63 : }
64 3137 : return "";
65 : }
66 :
67 :
68 : std::string
69 56767 : StringUtils::pruneZeros(const std::string& str, int max) {
70 : const std::string::size_type endpos = str.find_last_not_of("0");
71 56767 : if (endpos != std::string::npos && str.back() == '0') {
72 37862 : std::string res = str.substr(0, MAX2((int)str.size() - max, (int)endpos + 1));
73 37862 : return res;
74 : }
75 : return str;
76 : }
77 :
78 : std::string
79 7721623 : StringUtils::to_lower_case(const std::string& str) {
80 : std::string s = str;
81 : std::transform(s.begin(), s.end(), s.begin(), [](char c) {
82 50455133 : return (char)::tolower(c);
83 : });
84 7721623 : return s;
85 : }
86 :
87 :
88 : std::string
89 1707 : StringUtils::latin1_to_utf8(std::string str) {
90 : // inspired by http://stackoverflow.com/questions/4059775/convert-iso-8859-1-strings-to-utf-8-in-c-c
91 : std::string result;
92 7124 : for (const auto& c : str) {
93 5417 : const unsigned char uc = (unsigned char)c;
94 5417 : if (uc < 128) {
95 : result += uc;
96 : } else {
97 71 : result += (char)(0xc2 + (uc > 0xbf));
98 71 : result += (char)((uc & 0x3f) + 0x80);
99 : }
100 : }
101 1707 : return result;
102 : }
103 :
104 :
105 : std::string
106 818015 : StringUtils::convertUmlaute(std::string str) {
107 2454045 : str = replace(str, "\xE4", "ae");
108 2454045 : str = replace(str, "\xC4", "Ae");
109 2454045 : str = replace(str, "\xF6", "oe");
110 2454045 : str = replace(str, "\xD6", "Oe");
111 2454045 : str = replace(str, "\xFC", "ue");
112 2454045 : str = replace(str, "\xDC", "Ue");
113 2454045 : str = replace(str, "\xDF", "ss");
114 2454045 : str = replace(str, "\xC9", "E");
115 2454045 : str = replace(str, "\xE9", "e");
116 2454045 : str = replace(str, "\xC8", "E");
117 2454045 : str = replace(str, "\xE8", "e");
118 818015 : return str;
119 : }
120 :
121 :
122 : std::string
123 57203486 : StringUtils::replace(std::string str, const std::string& what, const std::string& by) {
124 : std::string::size_type idx = str.find(what);
125 57203486 : const int what_len = (int)what.length();
126 57203486 : if (what_len > 0) {
127 57203485 : const int by_len = (int)by.length();
128 57206628 : while (idx != std::string::npos) {
129 3143 : str = str.replace(idx, what_len, by);
130 3143 : idx = str.find(what, idx + by_len);
131 : }
132 : }
133 57203486 : return str;
134 : }
135 :
136 :
137 : std::string
138 1187422 : StringUtils::substituteEnvironment(const std::string& str, const std::chrono::time_point<std::chrono::system_clock>* const timeRef) {
139 : std::string s = str;
140 1187422 : if (timeRef != nullptr) {
141 : const std::string::size_type localTimeIndex = str.find("${LOCALTIME}");
142 : const std::string::size_type utcIndex = str.find("${UTC}");
143 : const bool isUTC = utcIndex != std::string::npos;
144 1187416 : if (localTimeIndex != std::string::npos || isUTC) {
145 6 : const time_t rawtime = std::chrono::system_clock::to_time_t(*timeRef);
146 : char buffer [80];
147 6 : struct tm* timeinfo = isUTC ? gmtime(&rawtime) : localtime(&rawtime);
148 6 : strftime(buffer, 80, "%Y-%m-%d-%H-%M-%S.", timeinfo);
149 : auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(*timeRef);
150 : auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(*timeRef - seconds);
151 6 : const std::string micro = buffer + toString(microseconds.count());
152 6 : if (isUTC) {
153 : s.replace(utcIndex, 6, micro);
154 : } else {
155 : s.replace(localTimeIndex, 12, micro);
156 : }
157 : }
158 : }
159 : const std::string::size_type pidIndex = str.find("${PID}");
160 1187422 : if (pidIndex != std::string::npos) {
161 : #ifdef WIN32
162 : s.replace(pidIndex, 6, toString(::GetCurrentProcessId()));
163 : #else
164 6 : s.replace(pidIndex, 6, toString(::getpid()));
165 : #endif
166 : }
167 1187422 : if (std::getenv("SUMO_LOGO") == nullptr) {
168 3562266 : s = replace(s, "${SUMO_LOGO}", "${SUMO_HOME}/data/logo/sumo-128x138.png");
169 : }
170 : const std::string::size_type tildeIndex = str.find("~");
171 1187422 : if (tildeIndex == 0) {
172 3 : s.replace(0, 1, "${HOME}");
173 : }
174 3562266 : s = replace(s, ",~", ",${HOME}");
175 : #ifdef WIN32
176 : if (std::getenv("HOME") == nullptr) {
177 : s = replace(s, "${HOME}", "${USERPROFILE}");
178 : }
179 : #endif
180 :
181 : // Expression for an environment variables, e.g. ${NAME}
182 : // Note: - R"(...)" is a raw string literal syntax to simplify a regex declaration
183 : // - .+? looks for the shortest match (non-greedy)
184 : // - (.+?) defines a "subgroup" which is already stripped of the $ and {, }
185 1187422 : std::regex envVarExpr(R"(\$\{(.+?)\})");
186 :
187 : // Are there any variables in this string?
188 : std::smatch match;
189 : std::string strIter = s;
190 :
191 : // Loop over the entire value string and look for variable names
192 1187482 : while (std::regex_search(strIter, match, envVarExpr)) {
193 : std::string varName = match[1];
194 :
195 : // Find the variable in the environment and its value
196 : std::string varValue;
197 60 : if (std::getenv(varName.c_str()) != nullptr) {
198 59 : varValue = std::getenv(varName.c_str());
199 : }
200 :
201 : // Replace the variable placeholder with its value in the original string
202 240 : s = std::regex_replace(s, std::regex("\\$\\{" + varName + "\\}"), varValue);
203 :
204 : // Continue the loop with the remainder of the string
205 120 : strIter = match.suffix();
206 : }
207 1187422 : return s;
208 1187422 : }
209 :
210 :
211 : bool
212 4278236 : StringUtils::startsWith(const std::string& str, const std::string prefix) {
213 4278236 : return str.compare(0, prefix.length(), prefix) == 0;
214 : }
215 :
216 :
217 : bool
218 216338 : StringUtils::endsWith(const std::string& str, const std::string suffix) {
219 216338 : if (str.length() >= suffix.length()) {
220 216316 : return str.compare(str.length() - suffix.length(), suffix.length(), suffix) == 0;
221 : } else {
222 : return false;
223 : }
224 : }
225 :
226 :
227 : std::string
228 0 : StringUtils::padFront(const std::string& str, int length, char padding) {
229 0 : return std::string(MAX2(0, length - (int)str.size()), padding) + str;
230 : }
231 :
232 :
233 : std::string
234 1255434 : StringUtils::escapeXML(const std::string& orig, const bool maskDoubleHyphen) {
235 3766302 : std::string result = replace(orig, "&", "&");
236 3766302 : result = replace(result, ">", ">");
237 3766302 : result = replace(result, "<", "<");
238 3766302 : result = replace(result, "\"", """);
239 1255434 : if (maskDoubleHyphen) {
240 1900275 : result = replace(result, "--", "--");
241 : }
242 40173888 : for (char invalid = '\1'; invalid < ' '; invalid++) {
243 194592270 : result = replace(result, std::string(1, invalid).c_str(), "");
244 : }
245 3766302 : return replace(result, "'", "'");
246 : }
247 :
248 :
249 : std::string
250 3441 : StringUtils::urlEncode(const std::string& toEncode, const std::string encodeWhich) {
251 3441 : std::ostringstream out;
252 :
253 90979 : for (int i = 0; i < (int)toEncode.length(); ++i) {
254 87538 : const char t = toEncode.at(i);
255 :
256 87538 : if ((encodeWhich != "" && encodeWhich.find(t) == std::string::npos) ||
257 1 : (encodeWhich == "" &&
258 0 : ((t >= 45 && t <= 57) || // hyphen, period, slash, 0-9
259 0 : (t >= 65 && t <= 90) || // A-Z
260 : t == 95 || // underscore
261 : (t >= 97 && t <= 122) || // a-z
262 : t == 126)) // tilde
263 : ) {
264 87537 : out << toEncode.at(i);
265 : } else {
266 2 : out << charToHex(toEncode.at(i));
267 : }
268 : }
269 :
270 3441 : return out.str();
271 3441 : }
272 :
273 :
274 : std::string
275 67334 : StringUtils::urlDecode(const std::string& toDecode) {
276 67334 : std::ostringstream out;
277 :
278 977859 : for (int i = 0; i < (int)toDecode.length(); ++i) {
279 910527 : if (toDecode.at(i) == '%') {
280 2 : std::string str(toDecode.substr(i + 1, 2));
281 2 : out << hexToChar(str);
282 0 : i += 2;
283 : } else {
284 910525 : out << toDecode.at(i);
285 : }
286 : }
287 :
288 67332 : return out.str();
289 67334 : }
290 :
291 : std::string
292 1 : StringUtils::charToHex(unsigned char c) {
293 : short i = c;
294 :
295 1 : std::stringstream s;
296 :
297 1 : s << "%" << std::setw(2) << std::setfill('0') << std::hex << i;
298 :
299 1 : return s.str();
300 1 : }
301 :
302 :
303 : unsigned char
304 2 : StringUtils::hexToChar(const std::string& str) {
305 2 : short c = 0;
306 2 : if (!str.empty()) {
307 2 : std::istringstream in(str);
308 2 : in >> std::hex >> c;
309 2 : if (in.fail()) {
310 4 : throw NumberFormatException(str + " could not be interpreted as hex");
311 : }
312 2 : }
313 0 : return static_cast<unsigned char>(c);
314 : }
315 :
316 :
317 : int
318 18527533 : StringUtils::toInt(const std::string& sData) {
319 18527533 : long long int result = toLong(sData);
320 18501499 : if (result > std::numeric_limits<int>::max() || result < std::numeric_limits<int>::min()) {
321 3 : throw NumberFormatException(toString(result) + " int overflow");
322 : }
323 18501498 : return (int)result;
324 : }
325 :
326 :
327 : int
328 0 : StringUtils::toIntSecure(const std::string& sData, int def) {
329 0 : if (sData.length() == 0) {
330 : return def;
331 : }
332 0 : return toInt(sData);
333 : }
334 :
335 :
336 : long long int
337 19918396 : StringUtils::toLong(const std::string& sData) {
338 : const char* const data = sData.c_str();
339 19918396 : if (data == 0 || data[0] == 0) {
340 64 : throw EmptyData();
341 : }
342 : char* end;
343 19918332 : errno = 0;
344 : #ifdef WIN32
345 : long long int ret = _strtoi64(data, &end, 10);
346 : #else
347 19918332 : long long int ret = strtoll(data, &end, 10);
348 : #endif
349 19918332 : if (errno == ERANGE) {
350 0 : errno = 0;
351 0 : throw NumberFormatException("(long long integer range) " + sData);
352 : }
353 19918332 : if ((int)(end - data) != (int)strlen(data)) {
354 64252 : throw NumberFormatException("(long long integer format) " + sData);
355 : }
356 19886206 : return ret;
357 : }
358 :
359 :
360 : int
361 933 : StringUtils::hexToInt(const std::string& sData) {
362 933 : if (sData.length() == 0) {
363 0 : throw EmptyData();
364 : }
365 933 : size_t idx = 0;
366 : int result;
367 : try {
368 933 : if (sData[0] == '#') { // for html color codes
369 849 : result = std::stoi(sData.substr(1), &idx, 16);
370 849 : idx++;
371 : } else {
372 : result = std::stoi(sData, &idx, 16);
373 : }
374 0 : } catch (...) {
375 0 : throw NumberFormatException("(hex integer format) " + sData);
376 0 : }
377 933 : if (idx != sData.length()) {
378 0 : throw NumberFormatException("(hex integer format) " + sData);
379 : }
380 933 : return result;
381 : }
382 :
383 :
384 : double
385 118440498 : StringUtils::toDouble(const std::string& sData) {
386 118440498 : if (sData.size() == 0) {
387 191 : throw EmptyData();
388 : }
389 : try {
390 118440307 : size_t idx = 0;
391 : const double result = std::stod(sData, &idx);
392 118438734 : if (idx != sData.size()) {
393 30 : throw NumberFormatException("(double format) " + sData);
394 : } else {
395 118438719 : return result;
396 : }
397 1588 : } catch (...) {
398 : // invalid_argument or out_of_range
399 3176 : throw NumberFormatException("(double) " + sData);
400 1588 : }
401 : }
402 :
403 :
404 : double
405 336 : StringUtils::toDoubleSecure(const std::string& sData, const double def) {
406 336 : if (sData.length() == 0) {
407 : return def;
408 : }
409 336 : return toDouble(sData);
410 : }
411 :
412 :
413 : bool
414 3355735 : StringUtils::toBool(const std::string& sData) {
415 3355735 : if (sData.length() == 0) {
416 1 : throw EmptyData();
417 : }
418 3355734 : const std::string s = to_lower_case(sData);
419 3355734 : if (s == "1" || s == "yes" || s == "true" || s == "on" || s == "x" || s == "t") {
420 : return true;
421 : }
422 2775654 : if (s == "0" || s == "no" || s == "false" || s == "off" || s == "-" || s == "f") {
423 : return false;
424 : }
425 63 : throw BoolFormatException(s);
426 : }
427 :
428 : MMVersion
429 53498 : StringUtils::toVersion(const std::string& sData) {
430 160494 : std::vector<std::string> parts = StringTokenizer(sData, ".").getVector();
431 106996 : return MMVersion(toInt(parts.front()), toDouble(parts.back()));
432 53498 : }
433 :
434 :
435 : double
436 2175 : StringUtils::parseDist(const std::string& sData) {
437 2175 : if (sData.size() == 0) {
438 1 : throw EmptyData();
439 : }
440 : try {
441 2174 : size_t idx = 0;
442 : const double result = std::stod(sData, &idx);
443 2173 : if (idx != sData.size()) {
444 4 : const std::string unit = prune(sData.substr(idx));
445 4 : if (unit == "m" || unit == "metre" || unit == "meter" || unit == "metres" || unit == "meters") {
446 : return result;
447 : }
448 2 : if (unit == "km" || unit == "kilometre" || unit == "kilometer" || unit == "kilometres" || unit == "kilometers") {
449 1 : return result * 1000.;
450 : }
451 1 : if (unit == "mi" || unit == "mile" || unit == "miles") {
452 0 : return result * 1000. * KM_PER_MILE;
453 : }
454 1 : if (unit == "nmi") {
455 0 : return result * 1852.;
456 : }
457 1 : if (unit == "ft" || unit == "foot" || unit == "feet") {
458 0 : return result * 12. * 0.0254;
459 : }
460 1 : if (unit == "\"" || unit == "in" || unit == "inch" || unit == "inches") {
461 0 : return result * 0.0254;
462 : }
463 1 : if (unit[0] == '\'') {
464 0 : double inches = 12 * result;
465 0 : if (unit.length() > 1) {
466 0 : inches += std::stod(unit.substr(1), &idx);
467 1 : if (unit.substr(idx) == "\"") {
468 0 : return inches * 0.0254;
469 : }
470 : }
471 : }
472 2 : throw NumberFormatException("(distance format) " + sData);
473 : } else {
474 : return result;
475 : }
476 2 : } catch (...) {
477 : // invalid_argument or out_of_range
478 4 : throw NumberFormatException("(double) " + sData);
479 2 : }
480 : }
481 :
482 :
483 : double
484 6994 : StringUtils::parseSpeed(const std::string& sData, const bool defaultKmph) {
485 6994 : if (sData.size() == 0) {
486 1 : throw EmptyData();
487 : }
488 : try {
489 6993 : size_t idx = 0;
490 : const double result = std::stod(sData, &idx);
491 6989 : if (idx != sData.size()) {
492 553 : const std::string unit = prune(sData.substr(idx));
493 553 : if (unit == "km/h" || unit == "kph" || unit == "kmh" || unit == "kmph") {
494 3 : return result / 3.6;
495 : }
496 550 : if (unit == "m/s") {
497 : return result;
498 : }
499 548 : if (unit == "mph") {
500 547 : return result * KM_PER_MILE / 3.6;
501 : }
502 1 : if (unit == "knots") {
503 0 : return result * 1.852 / 3.6;
504 : }
505 2 : throw NumberFormatException("(speed format) " + sData);
506 : } else {
507 6436 : return defaultKmph ? result / 3.6 : result;
508 : }
509 5 : } catch (...) {
510 : // invalid_argument or out_of_range
511 10 : throw NumberFormatException("(double) " + sData);
512 5 : }
513 : }
514 :
515 :
516 : std::string
517 101176457 : StringUtils::transcode(const XMLCh* const data, int length) {
518 101176457 : if (data == 0) {
519 0 : throw EmptyData();
520 : }
521 101176457 : if (length == 0) {
522 350035 : return "";
523 : }
524 : #if _XERCES_VERSION < 30100
525 : char* t = XERCES_CPP_NAMESPACE::XMLString::transcode(data);
526 : std::string result(t);
527 : XERCES_CPP_NAMESPACE::XMLString::release(&t);
528 : return result;
529 : #else
530 : try {
531 100826422 : XERCES_CPP_NAMESPACE::TranscodeToStr utf8(data, "UTF-8");
532 100826422 : return reinterpret_cast<const char*>(utf8.str());
533 100826422 : } catch (XERCES_CPP_NAMESPACE::TranscodingException&) {
534 0 : return "?";
535 0 : }
536 : #endif
537 : }
538 :
539 :
540 : std::string
541 737353 : StringUtils::transcodeFromLocal(const std::string& localString) {
542 : #if _XERCES_VERSION > 30100
543 : try {
544 737353 : if (myLCPTranscoder == nullptr) {
545 57068 : myLCPTranscoder = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgTransService->makeNewLCPTranscoder(XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager);
546 : }
547 737353 : if (myLCPTranscoder != nullptr) {
548 737353 : return transcode(myLCPTranscoder->transcode(localString.c_str()));
549 : }
550 0 : } catch (XERCES_CPP_NAMESPACE::TranscodingException&) {}
551 : #endif
552 : return localString;
553 : }
554 :
555 :
556 : std::string
557 900446 : StringUtils::transcodeToLocal(const std::string& utf8String) {
558 : #if _XERCES_VERSION > 30100
559 : try {
560 900446 : if (myLCPTranscoder == nullptr) {
561 1056 : myLCPTranscoder = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgTransService->makeNewLCPTranscoder(XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager);
562 : }
563 900446 : if (myLCPTranscoder != nullptr) {
564 900446 : XERCES_CPP_NAMESPACE::TranscodeFromStr utf8(reinterpret_cast<const XMLByte*>(utf8String.c_str()), utf8String.size(), "UTF-8");
565 900446 : return myLCPTranscoder->transcode(utf8.str());
566 900446 : }
567 0 : } catch (XERCES_CPP_NAMESPACE::TranscodingException&) {}
568 : #endif
569 : return utf8String;
570 : }
571 :
572 :
573 : std::string
574 0 : StringUtils::trim_left(const std::string s, const std::string& t) {
575 : std::string result = s;
576 0 : result.erase(0, s.find_first_not_of(t));
577 0 : return result;
578 : }
579 :
580 : std::string
581 0 : StringUtils::trim_right(const std::string s, const std::string& t) {
582 : std::string result = s;
583 0 : result.erase(s.find_last_not_of(t) + 1);
584 0 : return result;
585 : }
586 :
587 : std::string
588 0 : StringUtils::trim(const std::string s, const std::string& t) {
589 0 : return trim_right(trim_left(s, t), t);
590 : }
591 :
592 :
593 : std::string
594 0 : StringUtils::wrapText(const std::string s, int width) {
595 0 : std::vector<std::string> parts = StringTokenizer(s).getVector();
596 : std::string result;
597 : std::string line;
598 : bool firstLine = true;
599 : bool firstWord = true;
600 0 : for (std::string p : parts) {
601 0 : if ((int)(line.size() + p.size()) < width || firstWord) {
602 0 : if (firstWord) {
603 : firstWord = false;
604 : } else {
605 : line += " ";
606 : }
607 0 : line = line + p;
608 : } else {
609 0 : if (firstLine) {
610 : firstLine = false;
611 : } else {
612 : result += "\n";
613 : }
614 0 : result = result + line;
615 : line.clear();
616 : firstWord = true;
617 : }
618 : }
619 0 : if (line.size() > 0) {
620 0 : if (firstLine) {
621 : firstLine = false;
622 : } else {
623 : result += "\n";
624 : }
625 0 : result = result + line;
626 : }
627 0 : return result;
628 0 : }
629 :
630 :
631 : void
632 58362 : StringUtils::resetTranscoder() {
633 58362 : myLCPTranscoder = nullptr;
634 58362 : }
635 :
636 : /****************************************************************************/
|
