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
|
#pragma once
#include "base/base.hpp"
#include <cstddef>
#include <cstdint>
#include <string>
#include <type_traits>
namespace impl
{
void ToHexRaw(void const * src, size_t size, void * dst);
void FromHexRaw(void const * src, size_t size, void * dst);
}
inline std::string ToHex(const void * ptr, size_t size)
{
std::string result;
if (size == 0) return result;
result.resize(size * 2);
::impl::ToHexRaw(ptr, size, &result[0]);
return result;
}
template <typename ContainerT>
inline std::string ToHex(ContainerT const & container)
{
static_assert(sizeof(*container.begin()) == 1, "");
if (container.empty())
return {};
return ToHex(&*container.begin(), container.end() - container.begin());
}
/// Conversion with specializations to avoid warnings
/// @{
template <typename IntT>
inline std::string NumToHex(IntT n)
{
static_assert(std::is_integral<IntT>::value, "");
uint8_t buf[sizeof(n)];
for (size_t i = 0; i < sizeof(n); ++i)
{
buf[i] = (n >> ((sizeof(n) - 1) * 8));
n <<= 8;
}
return ToHex(buf, sizeof(buf));
}
template <>
inline std::string NumToHex<int8_t>(int8_t c)
{
return ToHex(&c, sizeof(c));
}
template <>
inline std::string NumToHex<uint8_t>(uint8_t c)
{
return ToHex(&c, sizeof(c));
}
template <>
inline std::string NumToHex<char>(char c)
{
return ToHex(&c, sizeof(c));
}
/// @}
inline std::string FromHex(void const * ptr, size_t size)
{
std::string result;
result.resize(size / 2);
::impl::FromHexRaw(ptr, size, &result[0]);
return result;
}
inline std::string FromHex(std::string const & src) { return FromHex(src.c_str(), src.size()); }
inline std::string ByteToQuat(uint8_t n)
{
std::string result;
for (size_t i = 0; i < 4; ++i)
{
result += char(((n & 0xC0) >> 6) + '0');
n <<= 2;
}
return result;
}
template <typename IntT>
inline std::string NumToQuat(IntT n)
{
std::string result;
for (size_t i = 0; i < sizeof(n); ++i)
{
uint8_t ub = n >> (sizeof(n) * 8 - 8);
result += ByteToQuat(ub);
n <<= 8;
}
return result;
}
|
