TennesseeTrash/LibCBOR
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactors

Browse source 
- Refer to std::span<std::uint8_t> as Buffer
- Refer to std::span<const std::uint8_t> as ConstBuffer
- Use more consistent naming for members

These were mostly added so the function prototypes look a bit better.
This commit is contained in:
TennesseeTrash 2025-09-26 02:16:52 +02:00
parent d5680eaccb
commit ca8750aab2
7 changed files with 106 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

4
LibCBOR/Include/CBOR/Core.hpp
View file

@ -3,6 +3,7 @@
#include <cstdint> #include <cstdint>
#include <limits> #include <limits>
#include <span>
#include <stdexcept> #include <stdexcept>
namespace CBOR namespace CBOR
@ -148,6 +149,9 @@ namespace CBOR
public: public:
using std::runtime_error::runtime_error; using std::runtime_error::runtime_error;
}; };
using Buffer = std::span<std::uint8_t>;
using ConstBuffer = std::span<const std::uint8_t>;
} }
#endif // LIBCBOR_CORE_HPP #endif // LIBCBOR_CORE_HPP

11
LibCBOR/Include/CBOR/Decoder.hpp
View file

@ -4,7 +4,6 @@
#include "Core.hpp" #include "Core.hpp"
#include <limits> #include <limits>
#include <span>
#include <string_view> #include <string_view>
namespace CBOR namespace CBOR
@ -45,7 +44,7 @@ namespace CBOR
float Float(); float Float();
double Double(); double Double();
std::span<const std::uint8_t> Binary(); ConstBuffer Binary();
std::string_view String(); std::string_view String();
class Binary IndefiniteBinary(); class Binary IndefiniteBinary();
class String IndefiniteString(); class String IndefiniteString();
@ -111,7 +110,7 @@ namespace CBOR
public: public:
bool Done(); bool Done();
std::span<const std::uint8_t> Next(); ConstBuffer Next();
private: private:
friend class Decoder; friend class Decoder;
@ -183,7 +182,7 @@ namespace CBOR
class Decoder class Decoder
{ {
public: public:
Decoder(std::span<const std::uint8_t> buffer); Decoder(ConstBuffer buffer);
static constexpr static constexpr
std::uint64_t ArgumentIndefinite = std::numeric_limits<std::uint64_t>::max(); std::uint64_t ArgumentIndefinite = std::numeric_limits<std::uint64_t>::max();
@ -209,7 +208,7 @@ namespace CBOR
float Float(); float Float();
double Double(); double Double();
std::span<const std::uint8_t> Binary(); ConstBuffer Binary();
std::string_view String(); std::string_view String();
class Binary IndefiniteBinary(); class Binary IndefiniteBinary();
class String IndefiniteString(); class String IndefiniteString();
@ -226,7 +225,7 @@ namespace CBOR
friend class TaggedItem; friend class TaggedItem;
std::size_t mCurrent; std::size_t mCurrent;
std::span<const std::uint8_t> mBuffer; ConstBuffer mBuffer;
}; };
} }

16
LibCBOR/Include/CBOR/Encoder.hpp
View file

@ -21,7 +21,7 @@ namespace CBOR
class EncoderBuffer class EncoderBuffer
{ {
public: public:
EncoderBuffer(std::span<std::uint8_t> buffer); EncoderBuffer(Buffer buffer);
EncoderBuffer(std::vector<std::uint8_t> &buffer); EncoderBuffer(std::vector<std::uint8_t> &buffer);
template <std::size_t N> template <std::size_t N>
@ -39,7 +39,7 @@ namespace CBOR
void Write(std::uint16_t value); void Write(std::uint16_t value);
void Write(std::uint32_t value); void Write(std::uint32_t value);
void Write(std::uint64_t value); void Write(std::uint64_t value);
void Write(std::span<std::uint8_t> value); void Write(Buffer value);
void Write(std::string_view value); void Write(std::string_view value);
std::size_t Size() const; std::size_t Size() const;
@ -51,14 +51,14 @@ namespace CBOR
void Write(std::uint16_t value); void Write(std::uint16_t value);
void Write(std::uint32_t value); void Write(std::uint32_t value);
void Write(std::uint64_t value); void Write(std::uint64_t value);
void Write(std::span<std::uint8_t> value); void Write(Buffer value);
void Write(std::string_view value); void Write(std::string_view value);
std::size_t Size() const; std::size_t Size() const;
void EnsureSpace(std::size_t size) const; void EnsureSpace(std::size_t size) const;
std::size_t Current; std::size_t mCurrent;
std::span<std::uint8_t> Buffer; Buffer mBuffer;
}; };
struct DynamicBuffer struct DynamicBuffer
@ -67,12 +67,12 @@ namespace CBOR
void Write(std::uint16_t value); void Write(std::uint16_t value);
void Write(std::uint32_t value); void Write(std::uint32_t value);
void Write(std::uint64_t value); void Write(std::uint64_t value);
void Write(std::span<std::uint8_t> value); void Write(Buffer value);
void Write(std::string_view value); void Write(std::string_view value);
std::size_t Size() const; std::size_t Size() const;
std::vector<std::uint8_t> *Buffer; std::vector<std::uint8_t> *mBuffer;
}; };
using BufferType = std::variant<FixedBuffer, DynamicBuffer>; using BufferType = std::variant<FixedBuffer, DynamicBuffer>;
@ -108,7 +108,7 @@ namespace CBOR
void Encode(float value); void Encode(float value);
void Encode(double value); void Encode(double value);
void Encode(std::span<std::uint8_t> value); void Encode(Buffer value);
void Encode(const char *value); void Encode(const char *value);
void Encode(std::string_view value); void Encode(std::string_view value);

6
LibCBOR/Include/CBOR/Printer.hpp
View file

@ -1,15 +1,15 @@
#ifndef LIBCBOR_PRINTER_HPP #ifndef LIBCBOR_PRINTER_HPP
#define LIBCBOR_PRINTER_HPP #define LIBCBOR_PRINTER_HPP
#include "Core.hpp"
#include "Decoder.hpp" #include "Decoder.hpp"
#include <ostream> #include <ostream>
#include <span>
namespace CBOR namespace CBOR
{ {
void Print(std::ostream &out, std::span<const std::uint8_t> buffer); void Print(std::ostream &out, ConstBuffer buffer);
void Print(std::ostream &out, CBOR::Item item); void Print(std::ostream &out, Item item);
} }
#endif // LIBCBOR_PRINTER_HPP #endif // LIBCBOR_PRINTER_HPP

53
LibCBOR/Source/Decoder.cpp
View file

@ -57,7 +57,7 @@ namespace CBOR
{ {
static constexpr std::size_t Indefinite = std::numeric_limits<std::size_t>::max(); static constexpr std::size_t Indefinite = std::numeric_limits<std::size_t>::max();
std::size_t SpaceLeft(std::span<const std::uint8_t> buffer, std::size_t offset) std::size_t SpaceLeft(ConstBuffer buffer, std::size_t offset)
{ {
if (offset >= buffer.size()) { if (offset >= buffer.size()) {
return 0; return 0;
@ -65,8 +65,7 @@ namespace CBOR
return buffer.size() - offset; return buffer.size() - offset;
} }
void EnsureEnoughSpace(std::span<const std::uint8_t> buffer, std::size_t offset, void EnsureEnoughSpace(ConstBuffer buffer, std::size_t offset, std::size_t spaceRequired)
std::size_t spaceRequired)
{ {
if (SpaceLeft(buffer, offset) < spaceRequired) { if (SpaceLeft(buffer, offset) < spaceRequired) {
using namespace std::string_view_literals; using namespace std::string_view_literals;
@ -75,13 +74,13 @@ namespace CBOR
} }
} }
std::uint8_t Read1B(std::span<const std::uint8_t> buffer, std::size_t current) std::uint8_t Read1B(ConstBuffer buffer, std::size_t current)
{ {
EnsureEnoughSpace(buffer, current, 1); EnsureEnoughSpace(buffer, current, 1);
return buffer[current]; return buffer[current];
} }
std::uint16_t Read2B(std::span<const std::uint8_t> buffer, std::size_t current) std::uint16_t Read2B(ConstBuffer buffer, std::size_t current)
{ {
EnsureEnoughSpace(buffer, current, 2); EnsureEnoughSpace(buffer, current, 2);
std::uint16_t result = 0; std::uint16_t result = 0;
@ -90,7 +89,7 @@ namespace CBOR
return NetworkToHost(result); return NetworkToHost(result);
} }
std::uint32_t Read4B(std::span<const std::uint8_t> buffer, std::size_t current) std::uint32_t Read4B(ConstBuffer buffer, std::size_t current)
{ {
EnsureEnoughSpace(buffer, current, 4); EnsureEnoughSpace(buffer, current, 4);
std::uint32_t result = 0; std::uint32_t result = 0;
@ -101,7 +100,7 @@ namespace CBOR
return NetworkToHost(result); return NetworkToHost(result);
} }
std::uint64_t Read8B(std::span<const std::uint8_t> buffer, std::size_t current) std::uint64_t Read8B(ConstBuffer buffer, std::size_t current)
{ {
EnsureEnoughSpace(buffer, current, 8); EnsureEnoughSpace(buffer, current, 8);
std::uint64_t result = 0; std::uint64_t result = 0;
@ -116,13 +115,13 @@ namespace CBOR
return NetworkToHost(result); return NetworkToHost(result);
} }
std::uint8_t Consume1B(std::span<const std::uint8_t> buffer, std::size_t &current) std::uint8_t Consume1B(ConstBuffer buffer, std::size_t &current)
{ {
EnsureEnoughSpace(buffer, current, 1); EnsureEnoughSpace(buffer, current, 1);
return buffer[current++]; return buffer[current++];
} }
std::uint16_t Consume2B(std::span<const std::uint8_t> buffer, std::size_t &current) std::uint16_t Consume2B(ConstBuffer buffer, std::size_t &current)
{ {
EnsureEnoughSpace(buffer, current, 2); EnsureEnoughSpace(buffer, current, 2);
std::uint16_t result = 0; std::uint16_t result = 0;
@ -131,7 +130,7 @@ namespace CBOR
return NetworkToHost(result); return NetworkToHost(result);
} }
std::uint32_t Consume4B(std::span<const std::uint8_t> buffer, std::size_t &current) std::uint32_t Consume4B(ConstBuffer buffer, std::size_t &current)
{ {
EnsureEnoughSpace(buffer, current, 4); EnsureEnoughSpace(buffer, current, 4);
std::uint32_t result = 0; std::uint32_t result = 0;
@ -142,7 +141,7 @@ namespace CBOR
return NetworkToHost(result); return NetworkToHost(result);
} }
std::uint64_t Consume8B(std::span<const std::uint8_t> buffer, std::size_t &current) std::uint64_t Consume8B(ConstBuffer buffer, std::size_t &current)
{ {
EnsureEnoughSpace(buffer, current, 8); EnsureEnoughSpace(buffer, current, 8);
std::uint64_t result = 0; std::uint64_t result = 0;
@ -172,8 +171,7 @@ namespace CBOR
return ArgumentPosition(header & std::to_underlying(ArgumentPosition::PositionMask)); return ArgumentPosition(header & std::to_underlying(ArgumentPosition::PositionMask));
} }
std::uint64_t ArgumentValue(std::uint8_t header, std::span<const std::uint8_t> buffer, std::uint64_t ArgumentValue(std::uint8_t header, ConstBuffer buffer, std::size_t &current)
std::size_t &current)
{ {
ArgumentPosition position = GetArgumentPosition(header); ArgumentPosition position = GetArgumentPosition(header);
if (std::to_underlying(position) <= 23) { if (std::to_underlying(position) <= 23) {
@ -194,8 +192,7 @@ namespace CBOR
} }
} }
std::uint64_t ReadArgumentValue(std::uint8_t header, std::span<const std::uint8_t> buffer, std::uint64_t ReadArgumentValue(std::uint8_t header, ConstBuffer buffer, std::size_t current)
std::size_t current)
{ {
ArgumentPosition position = GetArgumentPosition(header); ArgumentPosition position = GetArgumentPosition(header);
if (std::to_underlying(position) <= 23) { if (std::to_underlying(position) <= 23) {
@ -217,7 +214,7 @@ namespace CBOR
} }
template <std::unsigned_integral T> template <std::unsigned_integral T>
T ExtractUnsigned(std::span<const std::uint8_t> buffer, std::size_t &current) T ExtractUnsigned(ConstBuffer buffer, std::size_t &current)
{ {
static constexpr std::uint64_t maxValue = std::numeric_limits<T>::max(); static constexpr std::uint64_t maxValue = std::numeric_limits<T>::max();
@ -272,8 +269,7 @@ namespace CBOR
// Note(3011): In this case it includes zero, even though zero is not technically positive. // Note(3011): In this case it includes zero, even though zero is not technically positive.
template <std::signed_integral T> template <std::signed_integral T>
T SignedPositive(std::uint8_t header, std::span<const std::uint8_t> buffer, T SignedPositive(std::uint8_t header, ConstBuffer buffer, std::size_t &current)
std::size_t &current)
{ {
static constexpr std::uint64_t maxValue = std::numeric_limits<T>::max(); static constexpr std::uint64_t maxValue = std::numeric_limits<T>::max();
@ -325,8 +321,7 @@ namespace CBOR
} }
template <std::signed_integral T> template <std::signed_integral T>
T SignedNegative(std::uint8_t header, std::span<const std::uint8_t> buffer, T SignedNegative(std::uint8_t header, ConstBuffer buffer, std::size_t &current)
std::size_t &current)
{ {
static constexpr auto actualMin = std::numeric_limits<T>::min(); static constexpr auto actualMin = std::numeric_limits<T>::min();
static constexpr std::uint64_t minValue = -std::int64_t(actualMin + 1); static constexpr std::uint64_t minValue = -std::int64_t(actualMin + 1);
@ -379,7 +374,7 @@ namespace CBOR
} }
template <std::signed_integral T> template <std::signed_integral T>
T ExtractSigned(std::span<const std::uint8_t> buffer, std::size_t &current) T ExtractSigned(ConstBuffer buffer, std::size_t &current)
{ {
std::uint8_t header = Consume1B(buffer, current); std::uint8_t header = Consume1B(buffer, current);
MajorType major = GetMajorType(header); MajorType major = GetMajorType(header);
@ -395,17 +390,15 @@ namespace CBOR
} }
} }
std::span<const std::uint8_t> ConstBuffer ExtractBinary(std::size_t size, ConstBuffer buffer, std::size_t &current)
ExtractBinary(std::size_t size, std::span<const std::uint8_t> buffer, std::size_t &current)
{ {
EnsureEnoughSpace(buffer, current, size); EnsureEnoughSpace(buffer, current, size);
std::span<const std::uint8_t> result(buffer.data() + current, size); ConstBuffer result(buffer.data() + current, size);
current += size; current += size;
return result; return result;
} }
std::string_view ExtractString(std::size_t size, std::span<const std::uint8_t> buffer, std::string_view ExtractString(std::size_t size, ConstBuffer buffer, std::size_t &current)
std::size_t &current)
{ {
EnsureEnoughSpace(buffer, current, size); EnsureEnoughSpace(buffer, current, size);
std::string_view result(reinterpret_cast<const char *>(buffer.data() + current), size); std::string_view result(reinterpret_cast<const char *>(buffer.data() + current), size);
@ -493,7 +486,7 @@ namespace CBOR
return mDecoder->Double(); return mDecoder->Double();
} }
std::span<const std::uint8_t> Item::Binary() ConstBuffer Item::Binary()
{ {
return mDecoder->Binary(); return mDecoder->Binary();
} }
@ -608,7 +601,7 @@ namespace CBOR
return mDone; return mDone;
} }
std::span<const std::uint8_t> Binary::Next() ConstBuffer Binary::Next()
{ {
if (!mHeaderParsed) { if (!mHeaderParsed) {
std::uint8_t header = Consume1B(mDecoder->mBuffer, mDecoder->mCurrent); std::uint8_t header = Consume1B(mDecoder->mBuffer, mDecoder->mCurrent);
@ -844,7 +837,7 @@ namespace CBOR
return KeyValue(*mDecoder); return KeyValue(*mDecoder);
} }
Decoder::Decoder(std::span<const std::uint8_t> buffer) Decoder::Decoder(ConstBuffer buffer)
: mCurrent(0), mBuffer(buffer) : mCurrent(0), mBuffer(buffer)
{} {}
@ -985,7 +978,7 @@ namespace CBOR
throw TypeMismatchError("double", ToString(major)); throw TypeMismatchError("double", ToString(major));
} }
std::span<const std::uint8_t> Decoder::Binary() ConstBuffer Decoder::Binary()
{ {
std::uint8_t header = Consume1B(mBuffer, mCurrent); std::uint8_t header = Consume1B(mBuffer, mCurrent);
MajorType major = GetMajorType(header); MajorType major = GetMajorType(header);

94
LibCBOR/Source/Encoder.cpp
View file

@ -76,16 +76,16 @@ namespace CBOR
} }
} }
EncoderBuffer::EncoderBuffer(std::span<std::uint8_t> buffer) EncoderBuffer::EncoderBuffer(Buffer buffer)
: mBuffer(FixedBuffer { .Current = 0, .Buffer = buffer, }) : mBuffer(FixedBuffer { .mCurrent = 0, .mBuffer = buffer, })
{} {}
EncoderBuffer::EncoderBuffer(std::vector<std::uint8_t> &buffer) EncoderBuffer::EncoderBuffer(std::vector<std::uint8_t> &buffer)
: mBuffer(DynamicBuffer { .Buffer = &buffer }) : mBuffer(DynamicBuffer { .mBuffer = &buffer })
{} {}
EncoderBuffer::EncoderBuffer(EncoderBuffer &&other) EncoderBuffer::EncoderBuffer(EncoderBuffer &&other)
: mBuffer(std::exchange(other.mBuffer, FixedBuffer { .Current = 0, .Buffer = {}, })) : mBuffer(std::exchange(other.mBuffer, FixedBuffer { .mCurrent = 0, .mBuffer = {}, }))
{} {}
void EncoderBuffer::Write(std::uint8_t value) void EncoderBuffer::Write(std::uint8_t value)
@ -120,7 +120,7 @@ namespace CBOR
}, mBuffer); }, mBuffer);
} }
void EncoderBuffer::Write(std::span<std::uint8_t> value) void EncoderBuffer::Write(Buffer value)
{ {
std::visit(Overload { std::visit(Overload {
[value] (FixedBuffer &buffer) { buffer.Write(value); }, [value] (FixedBuffer &buffer) { buffer.Write(value); },
@ -147,7 +147,7 @@ namespace CBOR
void EncoderBuffer::FixedBuffer::Write(std::uint8_t value) void EncoderBuffer::FixedBuffer::Write(std::uint8_t value)
{ {
EnsureSpace(1); EnsureSpace(1);
Buffer[Current++] = value; mBuffer[mCurrent++] = value;
} }
void EncoderBuffer::FixedBuffer::Write(std::uint16_t value) void EncoderBuffer::FixedBuffer::Write(std::uint16_t value)
@ -155,8 +155,8 @@ namespace CBOR
EnsureSpace(2); EnsureSpace(2);
static constexpr std::uint16_t mask = 0x00'FF; static constexpr std::uint16_t mask = 0x00'FF;
std::uint16_t network = HostToNetwork(value); std::uint16_t network = HostToNetwork(value);
Buffer[Current++] = static_cast<std::uint8_t>((network ) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network ) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 8) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 8) & mask);
} }
void EncoderBuffer::FixedBuffer::Write(std::uint32_t value) void EncoderBuffer::FixedBuffer::Write(std::uint32_t value)
@ -164,10 +164,10 @@ namespace CBOR
EnsureSpace(4); EnsureSpace(4);
static constexpr std::uint32_t mask = 0x00'00'00'FF; static constexpr std::uint32_t mask = 0x00'00'00'FF;
std::uint32_t network = HostToNetwork(value); std::uint32_t network = HostToNetwork(value);
Buffer[Current++] = static_cast<std::uint8_t>((network ) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network ) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 8) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 8) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 16) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 16) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 24) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 24) & mask);
} }
void EncoderBuffer::FixedBuffer::Write(std::uint64_t value) void EncoderBuffer::FixedBuffer::Write(std::uint64_t value)
@ -175,33 +175,33 @@ namespace CBOR
EnsureSpace(8); EnsureSpace(8);
static constexpr std::uint64_t mask = 0x00'00'00'00'00'00'00'FF; static constexpr std::uint64_t mask = 0x00'00'00'00'00'00'00'FF;
std::uint64_t network = HostToNetwork(value); std::uint64_t network = HostToNetwork(value);
Buffer[Current++] = static_cast<std::uint8_t>((network ) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network ) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 8) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 8) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 16) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 16) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 24) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 24) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 32) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 32) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 40) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 40) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 48) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 48) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 56) & mask); mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 56) & mask);
} }
void EncoderBuffer::FixedBuffer::Write(std::span<std::uint8_t> value) void EncoderBuffer::FixedBuffer::Write(Buffer value)
{ {
EnsureSpace(value.size()); EnsureSpace(value.size());
std::memcpy(Buffer.data() + Current, value.data(), value.size()); std::memcpy(mBuffer.data() + mCurrent, value.data(), value.size());
Current += value.size(); mCurrent += value.size();
} }
void EncoderBuffer::FixedBuffer::Write(std::string_view value) void EncoderBuffer::FixedBuffer::Write(std::string_view value)
{ {
EnsureSpace(value.size()); EnsureSpace(value.size());
std::memcpy(Buffer.data() + Current, value.data(), value.size()); std::memcpy(mBuffer.data() + mCurrent, value.data(), value.size());
Current += value.size(); mCurrent += value.size();
} }
void EncoderBuffer::FixedBuffer::EnsureSpace(std::size_t size) const void EncoderBuffer::FixedBuffer::EnsureSpace(std::size_t size) const
{ {
std::size_t spaceLeft = Current > Buffer.size() ? 0 : Buffer.size() - Current; std::size_t spaceLeft = mCurrent > mBuffer.size() ? 0 : mBuffer.size() - mCurrent;
if (size > spaceLeft) { if (size > spaceLeft) {
throw NotEnoughSpace(spaceLeft, size); throw NotEnoughSpace(spaceLeft, size);
@ -210,59 +210,59 @@ namespace CBOR
std::size_t EncoderBuffer::FixedBuffer::Size() const std::size_t EncoderBuffer::FixedBuffer::Size() const
{ {
return Current; return mCurrent;
} }
void EncoderBuffer::DynamicBuffer::Write(std::uint8_t value) void EncoderBuffer::DynamicBuffer::Write(std::uint8_t value)
{ {
Buffer->push_back(value); mBuffer->push_back(value);
} }
void EncoderBuffer::DynamicBuffer::Write(std::uint16_t value) void EncoderBuffer::DynamicBuffer::Write(std::uint16_t value)
{ {
static constexpr std::uint16_t mask = 0x00'FF; static constexpr std::uint16_t mask = 0x00'FF;
std::uint16_t network = HostToNetwork(value); std::uint16_t network = HostToNetwork(value);
Buffer->push_back(static_cast<std::uint8_t>((network ) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network ) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
} }
void EncoderBuffer::DynamicBuffer::Write(std::uint32_t value) void EncoderBuffer::DynamicBuffer::Write(std::uint32_t value)
{ {
static constexpr std::uint32_t mask = 0x00'00'00'FF; static constexpr std::uint32_t mask = 0x00'00'00'FF;
std::uint32_t network = HostToNetwork(value); std::uint32_t network = HostToNetwork(value);
Buffer->push_back(static_cast<std::uint8_t>((network ) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network ) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask));
} }
void EncoderBuffer::DynamicBuffer::Write(std::uint64_t value) void EncoderBuffer::DynamicBuffer::Write(std::uint64_t value)
{ {
static constexpr std::uint64_t mask = 0x00'00'00'00'00'00'00'FF; static constexpr std::uint64_t mask = 0x00'00'00'00'00'00'00'FF;
std::uint64_t network = HostToNetwork(value); std::uint64_t network = HostToNetwork(value);
Buffer->push_back(static_cast<std::uint8_t>((network ) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network ) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 32) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 32) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 40) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 40) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 48) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 48) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 56) & mask)); mBuffer->push_back(static_cast<std::uint8_t>((network >> 56) & mask));
} }
void EncoderBuffer::DynamicBuffer::Write(std::span<std::uint8_t> value) void EncoderBuffer::DynamicBuffer::Write(Buffer value)
{ {
Buffer->append_range(value); mBuffer->append_range(value);
} }
void EncoderBuffer::DynamicBuffer::Write(std::string_view value) void EncoderBuffer::DynamicBuffer::Write(std::string_view value)
{ {
Buffer->append_range(value); mBuffer->append_range(value);
} }
std::size_t EncoderBuffer::DynamicBuffer::Size() const std::size_t EncoderBuffer::DynamicBuffer::Size() const
{ {
return Buffer->size(); return mBuffer->size();
} }
BasicEncoder::BasicEncoder(EncoderBuffer buffer) BasicEncoder::BasicEncoder(EncoderBuffer buffer)
@ -447,7 +447,7 @@ namespace CBOR
mBuffer.Write(std::bit_cast<std::uint64_t>(value)); mBuffer.Write(std::bit_cast<std::uint64_t>(value));
} }
void BasicEncoder::Encode(std::span<std::uint8_t> value) void BasicEncoder::Encode(Buffer value)
{ {
WriteHeader(mBuffer, MajorType::Binary, value.size()); WriteHeader(mBuffer, MajorType::Binary, value.size());
mBuffer.Write(value); mBuffer.Write(value);

2
LibCBOR/Source/Printer.cpp
View file

@ -137,7 +137,7 @@ namespace CBOR
} }
} }
void Print(std::ostream &out, std::span<const std::uint8_t> buffer) void Print(std::ostream &out, ConstBuffer buffer)
{ {
CBOR::Decoder dec(buffer); CBOR::Decoder dec(buffer);
Print(out, 0, dec.AsItem()); Print(out, 0, dec.AsItem());