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 <limits>
#include <span>
#include <stdexcept>
namespace CBOR
@ -148,6 +149,9 @@ namespace CBOR
public:
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

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

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

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

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

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

@ -1,15 +1,15 @@
#ifndef LIBCBOR_PRINTER_HPP
#define LIBCBOR_PRINTER_HPP
#include "Core.hpp"
#include "Decoder.hpp"
#include <ostream>
#include <span>
namespace CBOR
{
void Print(std::ostream &out, std::span<const std::uint8_t> buffer);
void Print(std::ostream &out, CBOR::Item item);
void Print(std::ostream &out, ConstBuffer buffer);
void Print(std::ostream &out, Item item);
}
#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();
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()) {
return 0;
@ -65,8 +65,7 @@ namespace CBOR
return buffer.size() - offset;
}
void EnsureEnoughSpace(std::span<const std::uint8_t> buffer, std::size_t offset,
std::size_t spaceRequired)
void EnsureEnoughSpace(ConstBuffer buffer, std::size_t offset, std::size_t spaceRequired)
{
if (SpaceLeft(buffer, offset) < spaceRequired) {
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);
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);
std::uint16_t result = 0;
@ -90,7 +89,7 @@ namespace CBOR
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);
std::uint32_t result = 0;
@ -101,7 +100,7 @@ namespace CBOR
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);
std::uint64_t result = 0;
@ -116,13 +115,13 @@ namespace CBOR
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);
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);
std::uint16_t result = 0;
@ -131,7 +130,7 @@ namespace CBOR
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);
std::uint32_t result = 0;
@ -142,7 +141,7 @@ namespace CBOR
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);
std::uint64_t result = 0;
@ -172,8 +171,7 @@ namespace CBOR
return ArgumentPosition(header & std::to_underlying(ArgumentPosition::PositionMask));
}
std::uint64_t ArgumentValue(std::uint8_t header, std::span<const std::uint8_t> buffer,
std::size_t &current)
std::uint64_t ArgumentValue(std::uint8_t header, ConstBuffer buffer, std::size_t &current)
{
ArgumentPosition position = GetArgumentPosition(header);
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::size_t current)
std::uint64_t ReadArgumentValue(std::uint8_t header, ConstBuffer buffer, std::size_t current)
{
ArgumentPosition position = GetArgumentPosition(header);
if (std::to_underlying(position) <= 23) {
@ -217,7 +214,7 @@ namespace CBOR
}
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();
@ -272,8 +269,7 @@ namespace CBOR
// Note(3011): In this case it includes zero, even though zero is not technically positive.
template <std::signed_integral T>
T SignedPositive(std::uint8_t header, std::span<const std::uint8_t> buffer,
std::size_t &current)
T SignedPositive(std::uint8_t header, ConstBuffer buffer, std::size_t &current)
{
static constexpr std::uint64_t maxValue = std::numeric_limits<T>::max();
@ -325,8 +321,7 @@ namespace CBOR
}
template <std::signed_integral T>
T SignedNegative(std::uint8_t header, std::span<const std::uint8_t> buffer,
std::size_t &current)
T SignedNegative(std::uint8_t header, ConstBuffer buffer, std::size_t &current)
{
static constexpr auto actualMin = std::numeric_limits<T>::min();
static constexpr std::uint64_t minValue = -std::int64_t(actualMin + 1);
@ -379,7 +374,7 @@ namespace CBOR
}
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);
MajorType major = GetMajorType(header);
@ -395,17 +390,15 @@ namespace CBOR
}
}
std::span<const std::uint8_t>
ExtractBinary(std::size_t size, std::span<const std::uint8_t> buffer, std::size_t &current)
ConstBuffer ExtractBinary(std::size_t size, ConstBuffer buffer, std::size_t &current)
{
EnsureEnoughSpace(buffer, current, size);
std::span<const std::uint8_t> result(buffer.data() + current, size);
ConstBuffer result(buffer.data() + current, size);
current += size;
return result;
}
std::string_view ExtractString(std::size_t size, std::span<const std::uint8_t> buffer,
std::size_t &current)
std::string_view ExtractString(std::size_t size, ConstBuffer buffer, std::size_t &current)
{
EnsureEnoughSpace(buffer, current, size);
std::string_view result(reinterpret_cast<const char *>(buffer.data() + current), size);
@ -493,7 +486,7 @@ namespace CBOR
return mDecoder->Double();
}
std::span<const std::uint8_t> Item::Binary()
ConstBuffer Item::Binary()
{
return mDecoder->Binary();
}
@ -608,7 +601,7 @@ namespace CBOR
return mDone;
}
std::span<const std::uint8_t> Binary::Next()
ConstBuffer Binary::Next()
{
if (!mHeaderParsed) {
std::uint8_t header = Consume1B(mDecoder->mBuffer, mDecoder->mCurrent);
@ -844,7 +837,7 @@ namespace CBOR
return KeyValue(*mDecoder);
}
Decoder::Decoder(std::span<const std::uint8_t> buffer)
Decoder::Decoder(ConstBuffer buffer)
: mCurrent(0), mBuffer(buffer)
{}
@ -985,7 +978,7 @@ namespace CBOR
throw TypeMismatchError("double", ToString(major));
}
std::span<const std::uint8_t> Decoder::Binary()
ConstBuffer Decoder::Binary()
{
std::uint8_t header = Consume1B(mBuffer, mCurrent);
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)
: mBuffer(FixedBuffer { .Current = 0, .Buffer = buffer, })
EncoderBuffer::EncoderBuffer(Buffer buffer)
: mBuffer(FixedBuffer { .mCurrent = 0, .mBuffer = buffer, })
{}
EncoderBuffer::EncoderBuffer(std::vector<std::uint8_t> &buffer)
: mBuffer(DynamicBuffer { .Buffer = &buffer })
: mBuffer(DynamicBuffer { .mBuffer = &buffer })
{}
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)
@ -120,7 +120,7 @@ namespace CBOR
}, mBuffer);
}
void EncoderBuffer::Write(std::span<std::uint8_t> value)
void EncoderBuffer::Write(Buffer value)
{
std::visit(Overload {
[value] (FixedBuffer &buffer) { buffer.Write(value); },
@ -147,7 +147,7 @@ namespace CBOR
void EncoderBuffer::FixedBuffer::Write(std::uint8_t value)
{
EnsureSpace(1);
Buffer[Current++] = value;
mBuffer[mCurrent++] = value;
}
void EncoderBuffer::FixedBuffer::Write(std::uint16_t value)
@ -155,8 +155,8 @@ namespace CBOR
EnsureSpace(2);
static constexpr std::uint16_t mask = 0x00'FF;
std::uint16_t network = HostToNetwork(value);
Buffer[Current++] = 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 ) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 8) & mask);
}
void EncoderBuffer::FixedBuffer::Write(std::uint32_t value)
@ -164,10 +164,10 @@ namespace CBOR
EnsureSpace(4);
static constexpr std::uint32_t mask = 0x00'00'00'FF;
std::uint32_t network = HostToNetwork(value);
Buffer[Current++] = static_cast<std::uint8_t>((network ) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 8) & mask);
Buffer[Current++] = 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 ) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 8) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 16) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 24) & mask);
}
void EncoderBuffer::FixedBuffer::Write(std::uint64_t value)
@ -175,33 +175,33 @@ namespace CBOR
EnsureSpace(8);
static constexpr std::uint64_t mask = 0x00'00'00'00'00'00'00'FF;
std::uint64_t network = HostToNetwork(value);
Buffer[Current++] = static_cast<std::uint8_t>((network ) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 8) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 16) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 24) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 32) & mask);
Buffer[Current++] = static_cast<std::uint8_t>((network >> 40) & mask);
Buffer[Current++] = 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 ) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 8) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 16) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 24) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 32) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 40) & mask);
mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 48) & 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());
std::memcpy(Buffer.data() + Current, value.data(), value.size());
Current += value.size();
std::memcpy(mBuffer.data() + mCurrent, value.data(), value.size());
mCurrent += value.size();
}
void EncoderBuffer::FixedBuffer::Write(std::string_view value)
{
EnsureSpace(value.size());
std::memcpy(Buffer.data() + Current, value.data(), value.size());
Current += value.size();
std::memcpy(mBuffer.data() + mCurrent, value.data(), value.size());
mCurrent += value.size();
}
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) {
throw NotEnoughSpace(spaceLeft, size);
@ -210,59 +210,59 @@ namespace CBOR
std::size_t EncoderBuffer::FixedBuffer::Size() const
{
return Current;
return mCurrent;
}
void EncoderBuffer::DynamicBuffer::Write(std::uint8_t value)
{
Buffer->push_back(value);
mBuffer->push_back(value);
}
void EncoderBuffer::DynamicBuffer::Write(std::uint16_t value)
{
static constexpr std::uint16_t mask = 0x00'FF;
std::uint16_t network = HostToNetwork(value);
Buffer->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 ) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
}
void EncoderBuffer::DynamicBuffer::Write(std::uint32_t value)
{
static constexpr std::uint32_t mask = 0x00'00'00'FF;
std::uint32_t network = HostToNetwork(value);
Buffer->push_back(static_cast<std::uint8_t>((network ) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
Buffer->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 ) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask));
}
void EncoderBuffer::DynamicBuffer::Write(std::uint64_t value)
{
static constexpr std::uint64_t mask = 0x00'00'00'00'00'00'00'FF;
std::uint64_t network = HostToNetwork(value);
Buffer->push_back(static_cast<std::uint8_t>((network ) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 32) & mask));
Buffer->push_back(static_cast<std::uint8_t>((network >> 40) & mask));
Buffer->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 ) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 32) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 40) & mask));
mBuffer->push_back(static_cast<std::uint8_t>((network >> 48) & 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)
{
Buffer->append_range(value);
mBuffer->append_range(value);
}
std::size_t EncoderBuffer::DynamicBuffer::Size() const
{
return Buffer->size();
return mBuffer->size();
}
BasicEncoder::BasicEncoder(EncoderBuffer buffer)
@ -447,7 +447,7 @@ namespace CBOR
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());
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);
Print(out, 0, dec.AsItem());