7#include "../container/container.hpp"
8#include "../utility/utility.hpp"
9#include "../macros.hpp"
19hi_export_module(hikogui.codec.base_n);
21hi_export
namespace hi::inline
v1 {
26 bool case_insensitive;
36 template<std::
size_t StringLength>
38 char const (&str)[StringLength],
39 bool case_insensitive = StringLength <= 33,
40 char padding_char =
'\0') noexcept :
41 radix(narrow_cast<
long long>(StringLength - 1)), case_insensitive(case_insensitive), padding_char(padding_char)
43 static_assert(StringLength < 128);
46 for (
long long i = 0; i != 256; ++i) {
47 int_from_char_table[i] = -2;
51 int_from_char_table[std::bit_cast<uint8_t>(
' ')] = -1;
52 int_from_char_table[std::bit_cast<uint8_t>(
'\t')] = -1;
53 int_from_char_table[std::bit_cast<uint8_t>(
'\r')] = -1;
54 int_from_char_table[std::bit_cast<uint8_t>(
'\n')] = -1;
55 int_from_char_table[std::bit_cast<uint8_t>(
'\f')] = -1;
57 if (padding_char != 0) {
58 int_from_char_table[std::bit_cast<uint8_t>(padding_char)] = -1;
61 for (
long long i = 0; i != radix; ++i) {
63 char_from_int_table[i] = c;
65 int_from_char_table[std::bit_cast<uint8_t>(c)] = narrow_cast<int8_t>(i);
66 if constexpr (StringLength <= 33) {
68 if (c >=
'a' && c <=
'z') {
69 int_from_char_table[narrow_cast<uint8_t>((c -
'a') +
'A')] = narrow_cast<int8_t>(i);
70 }
else if (c >=
'A' && c <=
'Z') {
71 int_from_char_table[narrow_cast<uint8_t>((c -
'A') +
'a')] = narrow_cast<int8_t>(i);
83 return char_from_int_table[x];
86 constexpr int8_t int_from_char(
char c)
const noexcept
88 return int_from_char_table[std::bit_cast<uint8_t>(c)];
92constexpr auto base2_alphabet = base_n_alphabet{
"01"};
94constexpr auto base8_alphabet = base_n_alphabet{
"01234567"};
96constexpr auto base10_alphabet = base_n_alphabet{
"0123456789"};
98constexpr auto base16_alphabet = base_n_alphabet{
"0123456789ABCDEF"};
100constexpr auto base32_rfc4648_alphabet = base_n_alphabet{
"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"};
102constexpr auto base32hex_rfc4648_alphabet = base_n_alphabet{
"0123456789ABCDEFGHIJKLMNOPQRSTUV"};
104constexpr auto base64_rfc4648_alphabet =
105 base_n_alphabet{
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
false,
'='};
107constexpr auto base64url_rfc4648_alphabet =
108 base_n_alphabet{
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
false,
'='};
110constexpr auto base85_rfc1924_alphabet =
111 base_n_alphabet{
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"};
113constexpr auto base85_btoa_alphabet =
114 base_n_alphabet{
"!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu"};
118template<detail::base_n_alphabet Alphabet,
int CharsPerBlock,
int BytesPerBlock>
122 constexpr static char padding_char = alphabet.padding_char;
123 constexpr static long long radix = alphabet.radix;
124 constexpr static long long bytes_per_block = BytesPerBlock;
125 constexpr static long long chars_per_block = CharsPerBlock;
126 static_assert(bytes_per_block != 0,
"radix must be 16, 32, 64 or 85");
127 static_assert(chars_per_block != 0,
"radix must be 16, 32, 64 or 85");
130 constexpr static T int_from_char(
char c)
noexcept
132 return narrow_cast<T>(alphabet.int_from_char(c));
136 constexpr static char char_from_int(T x)
noexcept
147 template<
typename ItIn,
typename ItOut>
148 constexpr static void encode(ItIn ptr, ItIn last, ItOut output)
150 long long byte_index_in_block = 0;
153 while (ptr != last) {
155 auto const shift = 8 * ((bytes_per_block - 1) - byte_index_in_block);
156 block |=
static_cast<long long>(*(ptr++)) <<
shift;
158 if (++byte_index_in_block == bytes_per_block) {
159 encode_block(block, bytes_per_block, output);
161 byte_index_in_block = 0;
165 if (byte_index_in_block != 0) {
166 encode_block(block, byte_index_in_block, output);
176 template<
typename ItIn>
191 return encode(begin(bytes), end(bytes));
201 template<
typename ItIn,
typename ItOut>
202 constexpr static ItIn
decode(ItIn ptr, ItIn last, ItOut output)
204 int char_index_in_block = 0;
207 for (; ptr != last; ++ptr) {
208 auto const digit = int_from_char<long long>(*ptr);
213 }
else if (digit == -2) {
221 if (++char_index_in_block == chars_per_block) {
222 decode_block(block, chars_per_block, output);
224 char_index_in_block = 0;
229 if (char_index_in_block != 0) {
231 for (
auto i = char_index_in_block; i != chars_per_block; ++i) {
234 decode_block(block, char_index_in_block, output);
239 static bstring decode(std::string_view str)
243 hi_check(i == end(str),
"base-n encoded string not completely decoded");
248 template<
typename ItOut>
249 static void encode_block(
long long block,
long long nr_bytes, ItOut output)
noexcept
251 auto const padding = bytes_per_block - nr_bytes;
255 for (
long long i = 0; i != chars_per_block; ++i) {
256 auto const v = block % radix;
261 if (padding_char != 0) {
262 char_block += padding_char;
265 char_block += char_from_int(v);
270 std::copy(rbegin(char_block), rend(char_block), output);
273 template<
typename ItOut>
274 constexpr static void decode_block(
long long block,
long long nr_chars, ItOut output)
276 auto const padding = chars_per_block - nr_chars;
278 if (block and bytes_per_block == padding) {
279 throw parse_error(
"Invalid number of character to decode.");
283 for (
long long i = 0; i != (bytes_per_block - padding); ++i) {
284 auto const shift = 8 * ((bytes_per_block - 1) - i);
285 auto const byte =
static_cast<std::byte
>((block >>
shift) & 0xff);
295hi_export
using base2 = base_n<detail::base2_alphabet, 8, 1>;
296hi_export
using base8 = base_n<detail::base8_alphabet, 8, 3>;
297hi_export
using base16 = base_n<detail::base16_alphabet, 2, 1>;
298hi_export
using base32 = base_n<detail::base32_rfc4648_alphabet, 8, 5>;
299hi_export
using base32hex = base_n<detail::base32hex_rfc4648_alphabet, 8, 5>;
300hi_export
using base64 = base_n<detail::base64_rfc4648_alphabet, 4, 3>;
301hi_export
using base64url = base_n<detail::base64url_rfc4648_alphabet, 4, 3>;
302hi_export
using base85 = base_n<detail::base85_rfc1924_alphabet, 5, 4>;
303hi_export
using ascii85 = base_n<detail::base85_btoa_alphabet, 5, 4>;
DOXYGEN BUG.
Definition algorithm_misc.hpp:20
@ shift
The shift key is being held.
constexpr base_n_alphabet(char const (&str)[StringLength], bool case_insensitive=StringLength<=33, char padding_char='\0') noexcept
Construct an alphabet.
Definition base_n.hpp:37
constexpr char char_from_int(int8_t x) const noexcept
Get a character from an integer.
Definition base_n.hpp:80
Definition base_n.hpp:119
static constexpr void encode(ItIn ptr, ItIn last, ItOut output)
Encode bytes into a string.
Definition base_n.hpp:148
static std::string encode(ItIn first, ItIn last) noexcept
Encode bytes into a string.
Definition base_n.hpp:177
static constexpr std::string encode(std::span< std::byte const > bytes) noexcept
Encode bytes into a string.
Definition base_n.hpp:189
static constexpr ItIn decode(ItIn ptr, ItIn last, ItOut output)
Decodes a UTF-8 string into bytes.
Definition base_n.hpp:202
T back_inserter(T... args)