You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
643 lines
18 KiB
643 lines
18 KiB
#pragma once
|
|
|
|
#include <gp/algorithms/repeat.hpp>
|
|
#include <gp/math/boolean/bitops.hpp>
|
|
#include <gp/functional/optional.hpp>
|
|
#include <gp/utils/pair.hpp>
|
|
#include <gp/functional/variant.hpp>
|
|
#include <gp/containers/vector.hpp>
|
|
|
|
|
|
namespace gp {
|
|
enum class cbor_type : uint8_t {
|
|
uint = 0,
|
|
nint = 1,
|
|
bstr = 2,
|
|
tstr = 3,
|
|
list = 4,
|
|
hmap = 5,
|
|
tags = 6,
|
|
oths = 7
|
|
};
|
|
|
|
enum class cbor_oths : uint8_t {
|
|
value_false = 20,
|
|
value_true = 21,
|
|
value_null = 22,
|
|
value_undefined = 23,
|
|
byte = 24,
|
|
word = 25,
|
|
dword = 26,
|
|
qword = 27,
|
|
terminator = 31
|
|
};
|
|
|
|
enum class cbor_tags {
|
|
datetime = 0,
|
|
unix_time = 1,
|
|
ubignum = 2,
|
|
nbignum = 3,
|
|
decimal = 4,
|
|
bigfloat = 5,
|
|
cose_encrypt0 = 16,
|
|
cose_mac0 = 17,
|
|
cose_sign1 = 18,
|
|
expected_base64url = 21,
|
|
expected_base64 = 22,
|
|
expected_base16 = 23,
|
|
encoded_cbor = 24,
|
|
url = 32,
|
|
base64url = 33,
|
|
base64 = 34,
|
|
regexp = 35,
|
|
mime = 36,
|
|
cose_encrypt = 96,
|
|
cose_mac = 97,
|
|
cose_sign = 98,
|
|
signature = 55799
|
|
};
|
|
|
|
struct cbor_number final {
|
|
bool sign;
|
|
uint64_t value;
|
|
|
|
bool is_negative() {
|
|
return sign;
|
|
}
|
|
|
|
cbor_number(int64_t v)
|
|
: sign{v < 0}
|
|
, value{uint64_t((sign ? -1 : 1) * v)}
|
|
{}
|
|
|
|
cbor_number(bool s, uint64_t v)
|
|
: sign{s}
|
|
, value{v}
|
|
{}
|
|
};
|
|
|
|
struct ieee754_hf final {
|
|
uint16_t sign : 1;
|
|
uint16_t exponent : 5;
|
|
uint16_t mantissa : 10;
|
|
|
|
// TODO: support for denormalized values and NaNs
|
|
operator float() {
|
|
auto a = (uint32_t)((sign<<16) | ((exponent+0x1C000)<<13) | (mantissa<<13));
|
|
return *(float*)&a;
|
|
}
|
|
|
|
operator double() {
|
|
return (float)*this;
|
|
}
|
|
};
|
|
|
|
struct cbor_floating_point final {
|
|
using backing = gp::fixed_variant<
|
|
ieee754_hf,
|
|
float,
|
|
double
|
|
>;
|
|
backing contents;
|
|
|
|
cbor_floating_point(backing& p)
|
|
: contents{p}{}
|
|
|
|
cbor_floating_point(ieee754_hf p)
|
|
: contents{p}{}
|
|
|
|
cbor_floating_point(float p)
|
|
: contents{p}{}
|
|
|
|
cbor_floating_point(double p)
|
|
: contents{p}{}
|
|
|
|
operator ieee754_hf() {
|
|
return contents.value<ieee754_hf>();
|
|
}
|
|
|
|
operator float() {
|
|
switch(contents.type()) {
|
|
case backing::alt<ieee754_hf>():
|
|
return contents.value<ieee754_hf>();
|
|
case backing::alt<float>():
|
|
return contents.value<float>();
|
|
default:
|
|
gp_config::assertion(false,"this code should never be reached");
|
|
return std::numeric_limits<float>::quiet_NaN();
|
|
}
|
|
}
|
|
|
|
operator double() {
|
|
switch(contents.type()) {
|
|
case backing::alt<ieee754_hf>():
|
|
return contents.value<ieee754_hf>();
|
|
case backing::alt<float>():
|
|
return contents.value<float>();
|
|
case backing::alt<double>():
|
|
return contents.value<double>();
|
|
default:
|
|
gp_config::assertion(false,"this code should never be reached");
|
|
return std::numeric_limits<double>::quiet_NaN();
|
|
}
|
|
}
|
|
};
|
|
|
|
struct undefined_t final {};
|
|
|
|
template<typename T>
|
|
using cbor_composite = gp::fixed_variant<
|
|
gp::undefined_t,
|
|
cbor_number,
|
|
gp::vector<std::byte>,
|
|
bool,
|
|
gp::vector<T>,
|
|
gp::vector<gp::pair<T, T>>,
|
|
gp::nullopt_t,
|
|
cbor_floating_point
|
|
>;
|
|
|
|
class cbor_value {
|
|
|
|
cbor_composite<cbor_value> contents;
|
|
gp::reference_wrapper<allocator> alloc;
|
|
public:
|
|
|
|
cbor_value(allocator& alloc_v)
|
|
: contents()
|
|
, alloc(alloc_v)
|
|
{}
|
|
|
|
cbor_value(cbor_number number, allocator& alloc_v)
|
|
: contents(number)
|
|
, alloc(alloc_v)
|
|
{}
|
|
|
|
cbor_value(cbor_composite<cbor_value> val, allocator& alloc_v)
|
|
: contents(val)
|
|
, alloc(alloc_v)
|
|
{}
|
|
|
|
cbor_value(const cbor_value& oth)
|
|
: contents(oth.contents)
|
|
, alloc(oth.alloc)
|
|
{}
|
|
|
|
cbor_value(cbor_value&& oth)
|
|
: contents(gp::move(oth.contents))
|
|
, alloc(gp::move(oth.alloc))
|
|
{}
|
|
|
|
cbor_value& operator=(cbor_value& value) {
|
|
contents = value.contents;
|
|
alloc = value.alloc;
|
|
return *this;
|
|
}
|
|
|
|
cbor_value& operator=(cbor_value&& value) {
|
|
gp::swap(contents, value.contents);
|
|
gp::swap(alloc, value.alloc);
|
|
return *this;
|
|
}
|
|
|
|
cbor_value& operator=(cbor_composite<cbor_value>& value) {
|
|
contents = value;
|
|
return *this;
|
|
}
|
|
|
|
template<typename T>
|
|
cbor_value& operator=(T& value) {
|
|
contents = value;
|
|
return *this;
|
|
}
|
|
|
|
template<typename T>
|
|
cbor_value& operator=(T&& value) {
|
|
contents = gp::move(value);
|
|
return *this;
|
|
}
|
|
|
|
auto new_array() {
|
|
return gp::vector<cbor_value>{alloc};
|
|
}
|
|
|
|
auto new_object() {
|
|
return gp::vector<gp::pair<cbor_value, cbor_value>>{alloc};
|
|
}
|
|
|
|
static gp::pair<uint64_t, gp::buffer<std::byte>::associated_iterator> decode_integer(gp::buffer<std::byte> src) {
|
|
#define ERROR return {0, src.begin()}
|
|
auto local = (uint8_t)0b00011111 & (uint8_t)src[0];
|
|
if(local <= 23) {
|
|
return {local, src.begin()+1};
|
|
} else {
|
|
switch((cbor_oths)local) {
|
|
case cbor_oths::byte: {
|
|
if(src.size()<2) ERROR;
|
|
return {
|
|
(uint8_t)*(src.begin()+1),
|
|
src.begin()+2
|
|
};
|
|
}
|
|
case cbor_oths::word: {
|
|
if(src.size()<3) ERROR;
|
|
return {
|
|
uint16_t(*(src.slice_start(3).slice_end(2).cast<gp::endian_wrapper<uint16_t, endian::big>>().begin().data)),
|
|
src.begin()+3
|
|
};
|
|
}
|
|
case cbor_oths::dword: {
|
|
if(src.size()<5) ERROR;
|
|
return {
|
|
uint32_t(*(src.slice_start(5).slice_end(4).cast<gp::endian_wrapper<uint32_t, endian::big>>().begin().data)),
|
|
src.begin()+5
|
|
};
|
|
}
|
|
case cbor_oths::qword: {
|
|
if(src.size()<9) ERROR;
|
|
return {
|
|
uint64_t(*(src.slice_start(9).slice_end(8).cast<gp::endian_wrapper<uint64_t, endian::big>>().begin().data)),
|
|
src.begin()+9
|
|
};
|
|
}
|
|
default: {
|
|
ERROR;
|
|
}
|
|
}
|
|
}
|
|
#undef ERROR
|
|
}
|
|
|
|
template<typename U>
|
|
bool is_a() {
|
|
if constexpr (
|
|
std::is_same_v<U, uint8_t>
|
|
|| std::is_same_v<U, uint16_t>
|
|
|| std::is_same_v<U, uint32_t>
|
|
|| std::is_same_v<U, uint64_t>
|
|
|| std::is_same_v<U, int8_t>
|
|
|| std::is_same_v<U, int16_t>
|
|
|| std::is_same_v<U, int32_t>
|
|
|| std::is_same_v<U, int64_t>
|
|
) {
|
|
if(contents.is_a<cbor_number>())
|
|
{
|
|
auto& v = contents.value<cbor_number>();
|
|
if(!std::is_signed_v<U> && v.is_negative()) return false;
|
|
if(
|
|
std::numeric_limits<int64_t>::max()<v.value
|
|
&& (
|
|
!std::is_same_v<U, uint64_t>
|
|
|| v.is_negative()
|
|
)
|
|
) return false;
|
|
int64_t signed_v = (v.is_negative() ? -1 : 1 ) * v.value;
|
|
if(
|
|
std::numeric_limits<U>::min() <= signed_v
|
|
&& std::numeric_limits<U>::max() >= signed_v
|
|
) return true;
|
|
return false;
|
|
} else return false;
|
|
} else if constexpr (
|
|
std::is_same_v<U, ieee754_hf>
|
|
|| std::is_same_v<U, float>
|
|
|| std::is_same_v<U, double>
|
|
) {
|
|
auto& v = contents.value<cbor_floating_point>();
|
|
switch(v.contents.type()) {
|
|
case cbor_floating_point::backing::alt<ieee754_hf>():
|
|
return std::is_same_v<U, ieee754_hf>;
|
|
case cbor_floating_point::backing::alt<float>():
|
|
return std::is_same_v<U, float> || std::is_same_v<U, ieee754_hf>;
|
|
case cbor_floating_point::backing::alt<double>():
|
|
return std::is_same_v<U, double> || std::is_same_v<U, float> || std::is_same_v<U, ieee754_hf>;
|
|
default:
|
|
return false;
|
|
}
|
|
} else {
|
|
return contents.is_a<U>();
|
|
}
|
|
}
|
|
|
|
template<typename U>
|
|
U get_value() {
|
|
gp_config::assertion(is_a<U>(), "can't convert value legally");
|
|
if constexpr (
|
|
std::is_same_v<U, uint8_t>
|
|
|| std::is_same_v<U, uint16_t>
|
|
|| std::is_same_v<U, uint32_t>
|
|
|| std::is_same_v<U, uint64_t>
|
|
|| std::is_same_v<U, int8_t>
|
|
|| std::is_same_v<U, int16_t>
|
|
|| std::is_same_v<U, int32_t>
|
|
|| std::is_same_v<U, int64_t>
|
|
) {
|
|
auto& v = contents.value<cbor_number>();
|
|
return (v.is_negative() ? -1 : 1 ) * v.value;
|
|
} else if constexpr (
|
|
std::is_same_v<U, ieee754_hf>
|
|
|| std::is_same_v<U, float>
|
|
|| std::is_same_v<U, double>
|
|
) {
|
|
auto& v = contents.value<cbor_floating_point>();
|
|
return v;
|
|
} else {
|
|
return contents.value<U>();
|
|
}
|
|
}
|
|
|
|
static gp::pair<cbor_value, gp::buffer<std::byte>::associated_iterator> decode(allocator& alloc, gp::buffer<std::byte> src) {
|
|
#define ERROR return {cbor_value{alloc}, src.begin()}
|
|
if(src.size()==0) ERROR;
|
|
auto discriminant = (cbor_type)(((uint8_t)*src.begin()) >> 5);
|
|
auto local = uint8_t(((uint8_t)*src.begin()) & 0b00011111);
|
|
switch(discriminant) {
|
|
case cbor_type::uint:
|
|
case cbor_type::nint: {
|
|
auto nb = decode_integer(src);
|
|
return {cbor_value{cbor_number{(bool)discriminant, nb.first}, alloc}, nb.second};
|
|
}
|
|
case cbor_type::bstr: {
|
|
gp::vector<std::byte> str{alloc};
|
|
if(local == 31) {
|
|
auto sub = src.slice_end(src.size() - 1);
|
|
if(!sub.size()) ERROR;
|
|
while((uint8_t)sub[0] && 0b00011111 != 31) {
|
|
auto len = decode_integer(sub);
|
|
if(len.second == sub.begin()) ERROR;
|
|
str.reserve(str.size() + len.first);
|
|
auto end = (len.second + len.first);
|
|
if(len.first + (len.second - src.begin()) > src.size()) ERROR;
|
|
for(auto it = len.second; it != end; it++) {
|
|
str.push_back(*it);
|
|
}
|
|
sub = sub.slice_end(sub.size() - (len.first + (len.second - sub.begin())));
|
|
}
|
|
return {cbor_value{str, alloc}, sub.begin()+1};
|
|
} else if(auto len = decode_integer(src); len.second != src.begin()) {
|
|
str.reserve(len.first);
|
|
auto end = (len.second + len.first);
|
|
if(len.first + (len.second - src.begin()) > src.size()) ERROR;
|
|
for(auto it = len.second; it != end; it++) {
|
|
str.push_back(*it);
|
|
}
|
|
return {cbor_value{str, alloc}, end};
|
|
}
|
|
ERROR;
|
|
}
|
|
case cbor_type::tstr: {
|
|
ERROR;
|
|
}
|
|
case cbor_type::list: {
|
|
gp::vector<cbor_value> list{alloc};
|
|
if(local == 31) {
|
|
// TODO: Add the indefinite length version
|
|
} else if(auto len = decode_integer(src); len.second != src.begin()) {
|
|
auto sub = src.slice_end(src.size()-(len.second - src.begin()));
|
|
while(len.first--) {
|
|
auto tmp = decode(alloc, sub);
|
|
if(tmp.second == sub.begin()) ERROR;
|
|
list.push_back(tmp.first);
|
|
sub = sub.slice_end(sub.size() - (tmp.second - sub.begin()));
|
|
}
|
|
return {cbor_value{list, alloc}, sub.begin()};
|
|
}
|
|
ERROR;
|
|
}
|
|
case cbor_type::hmap: {
|
|
gp::vector<gp::pair<cbor_value, cbor_value>> list{alloc};
|
|
if(local == 31) {
|
|
// TODO: Add the indefinite length version
|
|
} else if(auto len = decode_integer(src); len.second != src.begin()) {
|
|
auto sub = src.slice_end(src.size()-(len.second - src.begin()));
|
|
while(len.first--) {
|
|
auto tmpl = decode(alloc, sub);
|
|
if(tmpl.second == sub.begin()) ERROR;
|
|
sub = sub.slice_end(sub.size() - (tmpl.second - sub.begin()));
|
|
auto tmpr = decode(alloc, sub);
|
|
if(tmpr.second == sub.begin()) ERROR;
|
|
list.push_back(gp::make_pair(
|
|
tmpl.first,
|
|
tmpr.first
|
|
));
|
|
sub = sub.slice_end(sub.size() - (tmpr.second - sub.begin()));
|
|
}
|
|
return {cbor_value{list, alloc}, sub.begin()};
|
|
}
|
|
ERROR;
|
|
}
|
|
case cbor_type::tags: {
|
|
// TODO: add tag decoding methods
|
|
}
|
|
case cbor_type::oths: {
|
|
switch((cbor_oths)local) {
|
|
case cbor_oths::value_false: {
|
|
return {
|
|
cbor_value{
|
|
cbor_composite<cbor_value>(false),
|
|
alloc
|
|
},
|
|
src.begin()+1
|
|
};
|
|
}
|
|
case cbor_oths::value_true: {
|
|
return {
|
|
cbor_value{
|
|
cbor_composite<cbor_value>(true),
|
|
alloc
|
|
},
|
|
src.begin()+1
|
|
};
|
|
}
|
|
case cbor_oths::value_null: {
|
|
return {
|
|
cbor_value{
|
|
cbor_composite<cbor_value>(nullopt),
|
|
alloc
|
|
},
|
|
src.begin()+1
|
|
};
|
|
}
|
|
case cbor_oths::value_undefined: {
|
|
return {
|
|
cbor_value{
|
|
cbor_composite<cbor_value>(undefined_t{}),
|
|
alloc
|
|
},
|
|
src.begin()+1
|
|
};
|
|
}
|
|
case cbor_oths::word: {
|
|
if(src.size()<3) ERROR;
|
|
return {
|
|
cbor_value{
|
|
cbor_floating_point{ieee754_hf(*(src.slice_start(3).slice_end(2).cast<gp::endian_wrapper<ieee754_hf, endian::big>>().begin().data))},
|
|
alloc
|
|
},
|
|
src.begin()+3
|
|
};
|
|
}
|
|
case cbor_oths::dword: {
|
|
if(src.size()<5) ERROR;
|
|
return {
|
|
cbor_value{
|
|
cbor_floating_point{float(*(src.slice_start(5).slice_end(4).cast<gp::endian_wrapper<float, endian::big>>().begin().data))},
|
|
alloc
|
|
},
|
|
src.begin()+5
|
|
};
|
|
}
|
|
case cbor_oths::qword: {
|
|
if(src.size()<9) ERROR;
|
|
return {
|
|
cbor_value{
|
|
cbor_floating_point{double(*(src.slice_start(9).slice_end(8).cast<gp::endian_wrapper<double, endian::big>>().begin().data))},
|
|
alloc
|
|
},
|
|
src.begin()+9
|
|
};
|
|
}
|
|
default: {
|
|
ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ERROR;
|
|
#undef ERROR
|
|
}
|
|
|
|
static auto encode_float(buffer<std::byte> dest, cbor_floating_point& value) {
|
|
switch(value.contents.type()) {
|
|
case cbor_floating_point::backing::alt<ieee754_hf>():{
|
|
if(dest.size() < 3) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)cbor_type::oths << 5u) + (uint8_t)cbor_oths::word);
|
|
(dest.slice_start(3).slice_end(2).cast<gp::endian_wrapper<ieee754_hf, gp::endian::big>>())[0] = value.contents.value<ieee754_hf>();
|
|
return dest.begin()+3;
|
|
}
|
|
case cbor_floating_point::backing::alt<float>():{
|
|
if(dest.size() < 5) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)cbor_type::oths << 5u) + (uint8_t)cbor_oths::dword);
|
|
(dest.slice_start(5).slice_end(4).cast<gp::endian_wrapper<float, gp::endian::big>>())[0] = value.contents.value<float>();
|
|
return dest.begin()+5;
|
|
}
|
|
case cbor_floating_point::backing::alt<double>():{
|
|
if(dest.size() < 9) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)cbor_type::oths << 5u) + (uint8_t)cbor_oths::qword);
|
|
(dest.slice_start(9).slice_end(8).cast<gp::endian_wrapper<double, gp::endian::big>>())[0] = value.contents.value<double>();
|
|
return dest.begin()+9;
|
|
}
|
|
default: return dest.begin();
|
|
}
|
|
}
|
|
|
|
static auto encode_length(buffer<std::byte> dest, cbor_type major, uint64_t value) {
|
|
auto num = value;
|
|
if(value <= 23) {
|
|
if(dest.size() < 1) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)major << 5u) + value);
|
|
return dest.begin()+1;
|
|
} else if(value <= 255) {
|
|
if(dest.size() < 2) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)major << 5u) + (uint8_t)cbor_oths::byte);
|
|
dest[1] = std::byte(value);
|
|
return dest.begin() + 2;
|
|
} else if(value <= 65535) {
|
|
if(dest.size() < 3) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)major << 5u) + (uint8_t)cbor_oths::word);
|
|
(dest.slice_start(3).slice_end(2).cast<gp::endian_wrapper<uint16_t, gp::endian::big>>())[0] = num;
|
|
return dest.begin()+3;
|
|
} else if(value <= 4294967295) {
|
|
if(dest.size() < 5) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)major << 5u) + (uint8_t)cbor_oths::dword);
|
|
(dest.slice_start(5).slice_end(4).cast<gp::endian_wrapper<uint32_t, gp::endian::big>>())[0] = num;
|
|
return dest.begin()+5;
|
|
} else {
|
|
if(dest.size() < 9) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)major << 5u) + (uint8_t)cbor_oths::qword);
|
|
(dest.slice_start(9).slice_end(8).cast<gp::endian_wrapper<uint64_t, gp::endian::big>>())[0] = num;
|
|
return dest.begin()+9;
|
|
}
|
|
}
|
|
|
|
auto encode(buffer<std::byte> dest) {
|
|
switch(contents.type()) {
|
|
case cbor_composite<cbor_value>::alt<undefined_t>(): {
|
|
if(dest.size() < 1) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)cbor_type::oths << 5u) + (uint8_t)cbor_oths::value_undefined);
|
|
return dest.begin()+1;
|
|
}
|
|
case cbor_composite<cbor_value>::alt<cbor_number>(): {
|
|
auto& ref = contents.value<cbor_number>();
|
|
return encode_length(
|
|
dest,
|
|
ref.is_negative() ? cbor_type::nint : cbor_type::uint,
|
|
ref.value
|
|
);
|
|
}
|
|
case cbor_composite<cbor_value>::alt<gp::vector<std::byte>>(): {
|
|
auto& ref = contents.value<gp::vector<std::byte>>();
|
|
auto it = encode_length(
|
|
dest,
|
|
cbor_type::bstr,
|
|
ref.size()
|
|
);
|
|
if(it == dest.begin()) return it;
|
|
|
|
for(auto a : ref) {
|
|
*(it++) = a;
|
|
}
|
|
return it;
|
|
}
|
|
case cbor_composite<cbor_value>::alt<bool>(): {
|
|
if(dest.size() < 1) return dest.begin();
|
|
if(contents.value<bool>())
|
|
dest[0] = std::byte(((uint8_t)cbor_type::oths << 5u) + (uint8_t)cbor_oths::value_true);
|
|
else
|
|
dest[0] = std::byte(((uint8_t)cbor_type::oths << 5u) + (uint8_t)cbor_oths::value_false);
|
|
return dest.begin()+1;
|
|
}
|
|
case cbor_composite<cbor_value>::alt<gp::vector<cbor_value>>(): {
|
|
auto& ary = contents.value<gp::vector<cbor_value>>();
|
|
auto it_begin = encode_length(dest, cbor_type::list, ary.size());
|
|
if(it_begin == dest.begin()) return dest.begin();
|
|
for(auto& elem : ary) {
|
|
auto slice = dest.slice_end(dest.size() - (it_begin - dest.begin()));
|
|
auto it = elem.encode(slice);
|
|
if(it == it_begin)
|
|
return dest.begin();
|
|
it_begin = it;
|
|
}
|
|
return it_begin;
|
|
}
|
|
case cbor_composite<cbor_value>::alt<gp::vector<gp::pair<cbor_value, cbor_value>>>(): {
|
|
auto& ary = contents.value<gp::vector<gp::pair<cbor_value,cbor_value>>>();
|
|
auto it_begin = encode_length(dest, cbor_type::hmap, ary.size());
|
|
if(it_begin == dest.begin()) return dest.begin();
|
|
|
|
for(auto& elem : ary) {
|
|
auto slice = dest.slice_end(dest.size() - (it_begin - dest.begin()));
|
|
auto it = elem.first.encode(slice);
|
|
if(it == it_begin) return dest.begin();
|
|
it_begin = it;
|
|
|
|
slice = dest.slice_end(dest.size() - (it_begin - dest.begin()));
|
|
it = elem.second.encode(slice);
|
|
if(it == it_begin) return dest.begin();
|
|
it_begin = it;
|
|
}
|
|
return it_begin;
|
|
}
|
|
case cbor_composite<cbor_value>::alt<gp::nullopt_t>(): {
|
|
if(dest.size() < 1) return dest.begin();
|
|
dest[0] = std::byte(((uint8_t)cbor_type::oths << 5u) + (uint8_t)cbor_oths::value_null);
|
|
return dest.begin()+1;
|
|
}
|
|
case cbor_composite<cbor_value>::alt<cbor_floating_point>(): {
|
|
return encode_float(dest, contents.value<cbor_floating_point>());
|
|
}
|
|
default: return dest.begin();
|
|
}
|
|
}
|
|
};
|
|
}
|