 |
Bitcoin Core
22.99.0
P2P Digital Currency
|
Go to the documentation of this file.
9 #ifndef BITCOIN_UTIL_STRENCODINGS_H
10 #define BITCOIN_UTIL_STRENCODINGS_H
46 t = 1'000
'000'000
'000ULL,
57 std::string SanitizeString(const std::string& str, int rule = SAFE_CHARS_DEFAULT);
58 std::vector<unsigned char> ParseHex(const char* psz);
59 std::vector<unsigned char> ParseHex(const std::string& str);
60 signed char HexDigit(char c);
61 /* Returns true if each character in str is a hex character, and has an even
62 * number of hex digits.*/
63 bool IsHex(const std::string& str);
67 bool IsHexNumber(const std::string& str);
68 std::vector<unsigned char> DecodeBase64(const char* p, bool* pf_invalid = nullptr);
69 std::string DecodeBase64(const std::string& str, bool* pf_invalid = nullptr);
70 std::string EncodeBase64(Span<const unsigned char> input);
71 inline std::string EncodeBase64(Span<const std::byte> input) { return EncodeBase64(MakeUCharSpan(input)); }
72 inline std::string EncodeBase64(const std::string& str) { return EncodeBase64(MakeUCharSpan(str)); }
73 std::vector<unsigned char> DecodeBase32(const char* p, bool* pf_invalid = nullptr);
74 std::string DecodeBase32(const std::string& str, bool* pf_invalid = nullptr);
81 std::string EncodeBase32(Span<const unsigned char> input, bool pad = true);
88 std::string EncodeBase32(const std::string& str, bool pad = true);
90 void SplitHostPort(std::string in, uint16_t& portOut, std::string& hostOut);
92 // LocaleIndependentAtoi is provided for backwards compatibility reasons.
94 // New code should use ToIntegral or the ParseInt* functions
95 // which provide parse error feedback.
97 // The goal of LocaleIndependentAtoi is to replicate the defined behaviour of
98 // std::atoi as it behaves under the "C" locale, and remove some undefined
99 // behavior. If the parsed value is bigger than the integer type's maximum
103 template <
typename T>
106 static_assert(std::is_integral<T>::value);
110 if (!s.empty() && s[0] ==
'+') {
111 if (s.length() >= 2 && s[1] ==
'-') {
116 auto [
_, error_condition] = std::from_chars(s.data(), s.data() + s.size(), result);
117 if (error_condition == std::errc::result_out_of_range) {
118 if (s.length() >= 1 && s[0] ==
'-') {
120 return std::numeric_limits<T>::min();
123 return std::numeric_limits<T>::max();
125 }
else if (error_condition != std::errc{}) {
138 return c >=
'0' && c <=
'9';
152 constexpr
inline bool IsSpace(
char c) noexcept {
153 return c ==
' ' || c ==
'\f' || c ==
'\n' || c ==
'\r' || c ==
'\t' || c ==
'\v';
164 template <
typename T>
167 static_assert(std::is_integral<T>::value);
169 const auto [first_nonmatching, error_condition] = std::from_chars(str.data(), str.data() + str.size(), result);
170 if (first_nonmatching != str.data() + str.size() || error_condition != std::errc{}) {
181 [[nodiscard]]
bool ParseInt32(
const std::string& str, int32_t *out);
188 [[nodiscard]]
bool ParseInt64(
const std::string& str, int64_t *out);
195 [[nodiscard]]
bool ParseUInt8(
const std::string& str, uint8_t *out);
202 [[nodiscard]]
bool ParseUInt16(
const std::string& str, uint16_t* out);
209 [[nodiscard]]
bool ParseUInt32(
const std::string& str, uint32_t *out);
216 [[nodiscard]]
bool ParseUInt64(
const std::string& str, uint64_t *out);
229 std::string
FormatParagraph(
const std::string& in,
size_t width = 79,
size_t indent = 0);
236 template <
typename T>
239 if (b.size() == 0)
return a.size() == 0;
240 size_t accumulator = a.size() ^ b.size();
241 for (
size_t i = 0; i < a.size(); i++)
242 accumulator |=
size_t(a[i] ^ b[i%b.size()]);
243 return accumulator == 0;
251 [[nodiscard]]
bool ParseFixedPoint(
const std::string &val,
int decimals, int64_t *amount_out);
254 template<
int frombits,
int tobits,
bool pad,
typename O,
typename I>
258 constexpr
size_t maxv = (1 << tobits) - 1;
259 constexpr
size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
261 acc = ((acc << frombits) | *it) & max_acc;
263 while (bits >= tobits) {
265 outfn((acc >> bits) & maxv);
270 if (bits) outfn((acc << (tobits - bits)) & maxv);
271 }
else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
289 return (c >=
'A' && c <=
'Z' ? (c -
'A') +
'a' : c);
301 std::string
ToLower(
const std::string& str);
315 return (c >=
'a' && c <=
'z' ? (c -
'a') +
'A' : c);
327 std::string
ToUpper(
const std::string& str);
353 #endif // BITCOIN_UTIL_STRENCODINGS_H
std::optional< uint64_t > ParseByteUnits(const std::string &str, ByteUnit default_multiplier)
Parse a string with suffix unit [k|K|m|M|g|G|t|T].
bilingual_str _(const char *psz)
Translation function.
constexpr auto MakeUCharSpan(V &&v) -> decltype(UCharSpanCast(Span
Like the Span constructor, but for (const) unsigned char member types only.
bool ConvertBits(const O &outfn, I it, I end)
Convert from one power-of-2 number base to another.
std::string Capitalize(std::string str)
Capitalizes the first character of the given string.
ByteUnit
Used by ParseByteUnits() Lowercase base 1000 Uppercase base 1024.
@ SAFE_CHARS_UA_COMMENT
BIP-0014 subset.
bool ParseFixedPoint(const std::string &val, int decimals, int64_t *amount_out)
Parse number as fixed point according to JSON number syntax.
std::string TrimString(const std::string &str, const std::string &pattern=" \f\n\r\t\v")
bool ParseUInt16(const std::string &str, uint16_t *out)
Convert decimal string to unsigned 16-bit integer with strict parse error feedback.
constexpr char ToLower(char c)
Converts the given character to its lowercase equivalent.
constexpr bool IsSpace(char c) noexcept
Tests if the given character is a whitespace character.
@ SAFE_CHARS_FILENAME
Chars allowed in filenames.
@ SAFE_CHARS_DEFAULT
The full set of allowed chars.
A Span is an object that can refer to a contiguous sequence of objects.
std::string FormatParagraph(const std::string &in, size_t width=79, size_t indent=0)
Format a paragraph of text to a fixed width, adding spaces for indentation to any added line.
std::optional< T > ToIntegral(const std::string &str)
Convert string to integral type T.
bool ParseUInt8(const std::string &str, uint8_t *out)
Convert decimal string to unsigned 8-bit integer with strict parse error feedback.
bool ParseUInt64(const std::string &str, uint64_t *out)
Convert decimal string to unsigned 64-bit integer with strict parse error feedback.
constexpr char ToUpper(char c)
Converts the given character to its uppercase equivalent.
bool ParseUInt32(const std::string &str, uint32_t *out)
Convert decimal string to unsigned 32-bit integer with strict parse error feedback.
@ SAFE_CHARS_URI
Chars allowed in URIs (RFC 3986)
bool TimingResistantEqual(const T &a, const T &b)
Timing-attack-resistant comparison.
constexpr bool IsDigit(char c)
Tests if the given character is a decimal digit.
bool ParseInt64(const std::string &str, int64_t *out)
Convert string to signed 64-bit integer with strict parse error feedback.
bool ParseInt32(const std::string &str, int32_t *out)
Convert string to signed 32-bit integer with strict parse error feedback.
T LocaleIndependentAtoi(const std::string &str)
SafeChars
Utilities for converting data from/to strings.
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.