1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#include <cstdint>
#include <limits>
#include <string_view>
namespace OpenVic::StringUtils {
/* The constexpr function 'string_to_uint64' will convert a string into a uint64_t integer value.
* The function takes four parameters: the input string (as a pair of pointers marking the start and
* end of the string), a bool pointer for reporting success, and the base for numerical conversion.
* The base parameter defaults to 10 (decimal), but it can be any value between 2 and 36. If the base
* given is 0, it will be set to 16 if the string starts with "0x" or "0X", otherwise 8 if the string
* still starts with "0", otherwise 10. The success bool pointer parameter is used to report whether
* or not conversion was successful. It can be nullptr if this information is not needed.
*/
constexpr uint64_t string_to_uint64(char const* str, const char* const end, bool* successful = nullptr, int base = 10) {
if (successful != nullptr) {
*successful = false;
}
// Base value should be between 2 and 36. If it's not, return 0 as an invalid case.
if (str == nullptr || end <= str || base < 0 || base == 1 || base > 36) {
return 0;
}
// The result of the conversion will be stored in this variable.
uint64_t result = 0;
// If base is zero, base is determined by the string prefix.
if (base == 0) {
if (*str == '0') {
if (str + 1 != end && (str[1] == 'x' || str[1] == 'X')) {
base = 16; // Hexadecimal.
str += 2; // Skip '0x' or '0X'
if (str == end) {
return 0;
}
} else {
base = 8; // Octal.
}
} else {
base = 10; // Decimal.
}
} else if (base == 16) {
// If base is 16 and string starts with '0x' or '0X', skip these characters.
if (*str == '0' && str + 1 != end && (str[1] == 'x' || str[1] == 'X')) {
str += 2;
if (str == end) {
return 0;
}
}
}
// Convert the number in the string.
for (; str != end; ++str) {
int digit;
if (*str >= '0' && *str <= '9') {
digit = *str - '0'; // Calculate digit value for '0'-'9'.
} else if (*str >= 'a' && *str <= 'z') {
digit = *str - 'a' + 10; // Calculate digit value for 'a'-'z'.
} else if (*str >= 'A' && *str <= 'Z') {
digit = *str - 'A' + 10; // Calculate digit value for 'A'-'Z'.
} else {
break; // Stop conversion if current character is not a digit.
}
if (digit >= base) {
break; // Stop conversion if current digit is greater than or equal to the base.
}
// Check for overflow on multiplication
if (result > std::numeric_limits<uint64_t>::max() / base) {
return std::numeric_limits<uint64_t>::max();
}
result *= base;
// Check for overflow on addition
if (result > std::numeric_limits<uint64_t>::max() - digit) {
return std::numeric_limits<uint64_t>::max();
}
result += digit;
}
// If successful is not null and the entire string was parsed,
// set *successful to true (if not it is already false).
if (successful != nullptr && str == end) {
*successful = true;
}
return result;
}
constexpr uint64_t string_to_uint64(char const* str, size_t length, bool* successful = nullptr, int base = 10) {
return string_to_uint64(str, str + length, successful, base);
}
inline uint64_t string_to_uint64(std::string_view str, bool* successful = nullptr, int base = 10) {
return string_to_uint64(str.data(), str.length(), successful, base);
}
constexpr int64_t string_to_int64(char const* str, const char* const end, bool* successful = nullptr, int base = 10) {
if (successful != nullptr) {
*successful = false;
}
if (str == nullptr || end <= str) {
return 0;
}
// This flag will be set if the number is negative.
bool is_negative = false;
// Check if there is a sign character.
if (*str == '+' || *str == '-') {
if (*str == '-') {
is_negative = true;
}
++str;
if (str == end) {
return 0;
}
}
const uint64_t result = string_to_uint64(str, end, successful, base);
if (!is_negative) {
if (result >= std::numeric_limits<int64_t>::max()) {
return std::numeric_limits<int64_t>::max();
}
return result;
} else {
if (result > std::numeric_limits<int64_t>::max()) {
return std::numeric_limits<int64_t>::min();
}
return -result;
}
}
constexpr int64_t string_to_int64(char const* str, size_t length, bool* successful = nullptr, int base = 10) {
return string_to_int64(str, str + length, successful, base);
}
inline int64_t string_to_int64(std::string_view str, bool* successful = nullptr, int base = 10) {
return string_to_int64(str.data(), str.length(), successful, base);
}
}
|
zaaarf