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
|
#pragma once
#include <array>
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
static constexpr std::array<char, 16> digitsArray = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
inline std::string intToHexString(uint64_t value, size_t digits)
{
std::string rc(digits, '0');
size_t bitIndex = (digits - 1) * 4;
for (size_t digitIndex = 0; digitIndex < digits; digitIndex++)
{
rc[digitIndex] = digitsArray[(value >> bitIndex) & 0x0f];
bitIndex -= 4;
}
return rc;
}
inline std::string bytesToHexString(const std::vector<uint8_t>& bytes)
{
std::string rc(bytes.size() * 2, '0');
for (size_t i = 0; i < bytes.size(); ++i)
{
rc[i * 2] = digitsArray[(bytes[i] & 0xf0) >> 4];
rc[i * 2 + 1] = digitsArray[bytes[i] & 0x0f];
}
return rc;
}
// Returns nibble.
inline uint8_t hexCharToNibble(char ch)
{
uint8_t rc = 16;
if (ch >= '0' && ch <= '9')
{
rc = static_cast<uint8_t>(ch) - '0';
}
else if (ch >= 'A' && ch <= 'F')
{
rc = static_cast<uint8_t>(ch) - 'A' + 10;
}
else if (ch >= 'a' && ch <= 'f')
{
rc = static_cast<uint8_t>(ch) - 'a' + 10;
}
return rc;
}
// Returns empty vector in case of malformed hex-string.
inline std::vector<uint8_t> hexStringToBytes(const std::string& str)
{
std::vector<uint8_t> rc(str.size() / 2, 0);
for (size_t i = 0; i < str.length(); i += 2)
{
uint8_t hi = hexCharToNibble(str[i]);
if (i == str.length() - 1)
{
return {};
}
uint8_t lo = hexCharToNibble(str[i + 1]);
if (lo == 16 || hi == 16)
{
return {};
}
rc[i / 2] = static_cast<uint8_t>(hi << 4) | lo;
}
return rc;
}
|
