LibCBOR/CMakeLists.txt

@@ -25,5 +25,4 @@ target_sources(LibCBOR
     "Source/Core.cpp"
     "Source/Decoder.cpp"
     "Source/Encoder.cpp"
-    "Source/Printer.cpp"
 )

LibCBOR/Include/CBOR/Core.hpp

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

LibCBOR/Include/CBOR/Decoder.hpp

@@ -3,7 +3,7 @@
 
 #include "Core.hpp"
 
-#include <limits>
+#include <span>
 #include <string_view>
 
 namespace CBOR
@@ -19,21 +19,7 @@ namespace CBOR
     private:
         Item(class Decoder &decoder);
 
-        Item(const Item &) = delete;
-        Item &operator=(const Item &) = delete;
-
     public:
-        Item(Item &&other);
-        Item &operator=(Item &&other);
-        ~Item() = default;
-
-        static constexpr
-        std::uint64_t ArgumentIndefinite = std::numeric_limits<std::uint64_t>::max();
-
-        MajorType GetMajor() const;
-        MinorType GetMinor() const;
-        std::uint64_t GetArgument() const;
-
         bool Bool();
         Special Special();
 
@@ -51,7 +37,7 @@ namespace CBOR
         float  Float();
         double Double();
 
-        ConstBuffer      Binary();
+        std::span<std::uint8_t> Binary();
         std::string_view        String();
         class Binary            IndefiniteBinary();
         class String            IndefiniteString();
@@ -73,14 +59,7 @@ namespace CBOR
     private:
         TaggedItem(class Decoder &decoder);
 
-        TaggedItem(const TaggedItem &) = delete;
-        TaggedItem &operator=(const TaggedItem &) = delete;
-
     public:
-        TaggedItem(TaggedItem &&other);
-        TaggedItem &operator=(TaggedItem &&other);
-        ~TaggedItem() = default;
-
         std::uint64_t Tag();
         Item          Item();
 
@@ -101,14 +80,7 @@ namespace CBOR
     private:
         KeyValue(class Decoder &decoder);
 
-        KeyValue(const KeyValue &) = delete;
-        KeyValue &operator=(const KeyValue &) = delete;
-
     public:
-        KeyValue(KeyValue &&other);
-        KeyValue &operator=(KeyValue &&other);
-        ~KeyValue() = default;
-
         Item Key();
         Item Value();
     private:
@@ -129,16 +101,9 @@ namespace CBOR
     private:
         Binary(class Decoder &decoder);
 
-        Binary(const Binary &) = delete;
-        Binary &operator=(const Binary &) = delete;
-
     public:
-        Binary(Binary &&other);
-        Binary &operator=(Binary &&other);
-        ~Binary() = default;
-
         bool                    Done();
-        ConstBuffer Next();
+        std::span<std::uint8_t> Next();
 
     private:
         friend class Decoder;
@@ -154,14 +119,7 @@ namespace CBOR
     private:
         String(class Decoder &decoder);
 
-        String(const String &) = delete;
-        String &operator=(const String &) = delete;
-
     public:
-        String(String &&other);
-        String &operator=(String &&other);
-        ~String() = default;
-
         bool             Done();
         std::string_view Next();
 
@@ -179,14 +137,7 @@ namespace CBOR
     private:
         Array(class Decoder &decoder);
 
-        Array(const Array &) = delete;
-        Array &operator=(const Array &) = delete;
-
     public:
-        Array(Array &&other);
-        Array &operator=(Array &&other);
-        ~Array() = default;
-
         bool Done();
         Item Next();
 
@@ -206,14 +157,7 @@ namespace CBOR
     private:
         Map(class Decoder &decoder);
 
-        Map(const Map &) = delete;
-        Map &operator=(const Map &) = delete;
-
     public:
-        Map(Map &&other);
-        Map &operator=(Map &&other);
-        ~Map() = default;
-
         bool     Done();
         KeyValue Next();
 
@@ -231,20 +175,7 @@ namespace CBOR
     class Decoder
     {
     public:
-        Decoder(ConstBuffer buffer);
+        Decoder(std::span<std::uint8_t> buffer);
-
-        Decoder(const Decoder &) = delete;
-        Decoder &operator=(const Decoder &) = delete;
-        Decoder(Decoder &&other);
-        Decoder &operator=(Decoder &&other);
-        ~Decoder() = default;
-
-        static constexpr
-        std::uint64_t ArgumentIndefinite = std::numeric_limits<std::uint64_t>::max();
-
-        MajorType GetMajor() const;
-        MinorType GetMinor() const;
-        std::uint64_t GetArgument() const;
 
         bool Bool();
         Special Special();
@@ -263,7 +194,7 @@ namespace CBOR
         float  Float();
         double Double();
 
-        ConstBuffer      Binary();
+        std::span<std::uint8_t> Binary();
         std::string_view        String();
         class Binary            IndefiniteBinary();
         class String            IndefiniteString();
@@ -271,7 +202,6 @@ namespace CBOR
         class Map               Map();
         class TaggedItem        TaggedItem();
 
-        class Item       AsItem();
     private:
         friend class Binary;
         friend class String;
@@ -280,7 +210,7 @@ namespace CBOR
         friend class TaggedItem;
 
         std::size_t             mCurrent;
-        ConstBuffer mBuffer;
+        std::span<std::uint8_t> mBuffer;
     };
 }
 

LibCBOR/Include/CBOR/Encoder.hpp

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

LibCBOR/Include/CBOR/Printer.hpp

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

LibCBOR/Source/Decoder.cpp

@@ -57,7 +57,7 @@ namespace CBOR
     {
         static constexpr std::size_t Indefinite = std::numeric_limits<std::size_t>::max();
 
-        std::size_t SpaceLeft(ConstBuffer buffer, std::size_t offset)
+        std::size_t SpaceLeft(std::span<std::uint8_t> buffer, std::size_t offset)
         {
             if (offset >= buffer.size()) {
                 return 0;
@@ -65,7 +65,8 @@ namespace CBOR
             return buffer.size() - offset;
         }
 
-        void EnsureEnoughSpace(ConstBuffer buffer, std::size_t offset, std::size_t spaceRequired)
+        void EnsureEnoughSpace(std::span<std::uint8_t> buffer, std::size_t offset,
+                               std::size_t spaceRequired)
         {
             if (SpaceLeft(buffer, offset) < spaceRequired) {
                 using namespace std::string_view_literals;
@@ -74,54 +75,19 @@ namespace CBOR
             }
         }
 
-        std::uint8_t  Read1B(ConstBuffer buffer, std::size_t current)
+        std::uint8_t  Read1B(std::span<std::uint8_t> buffer, std::size_t current)
         {
             EnsureEnoughSpace(buffer, current, 1);
             return buffer[current];
         }
 
-        std::uint16_t Read2B(ConstBuffer buffer, std::size_t current)
+        std::uint8_t  Consume1B(std::span<std::uint8_t> buffer, std::size_t &current)
-        {
-            EnsureEnoughSpace(buffer, current, 2);
-            std::uint16_t result = 0;
-            result |= std::uint16_t(buffer[current++])     ;
-            result |= std::uint16_t(buffer[current++]) << 8;
-            return NetworkToHost(result);
-        }
-
-        std::uint32_t Read4B(ConstBuffer buffer, std::size_t current)
-        {
-            EnsureEnoughSpace(buffer, current, 4);
-            std::uint32_t result = 0;
-            result |= std::uint32_t(buffer[current++])      ;
-            result |= std::uint32_t(buffer[current++]) <<  8;
-            result |= std::uint32_t(buffer[current++]) << 16;
-            result |= std::uint32_t(buffer[current++]) << 24;
-            return NetworkToHost(result);
-        }
-
-        std::uint64_t Read8B(ConstBuffer buffer, std::size_t current)
-        {
-            EnsureEnoughSpace(buffer, current, 8);
-            std::uint64_t result = 0;
-            result |= std::uint64_t(buffer[current++])      ;
-            result |= std::uint64_t(buffer[current++]) <<  8;
-            result |= std::uint64_t(buffer[current++]) << 16;
-            result |= std::uint64_t(buffer[current++]) << 24;
-            result |= std::uint64_t(buffer[current++]) << 32;
-            result |= std::uint64_t(buffer[current++]) << 40;
-            result |= std::uint64_t(buffer[current++]) << 48;
-            result |= std::uint64_t(buffer[current++]) << 56;
-            return NetworkToHost(result);
-        }
-
-        std::uint8_t  Consume1B(ConstBuffer buffer, std::size_t &current)
         {
             EnsureEnoughSpace(buffer, current, 1);
             return buffer[current++];
         }
 
-        std::uint16_t Consume2B(ConstBuffer buffer, std::size_t &current)
+        std::uint16_t Consume2B(std::span<std::uint8_t> buffer, std::size_t &current)
         {
             EnsureEnoughSpace(buffer, current, 2);
             std::uint16_t result = 0;
@@ -130,7 +96,7 @@ namespace CBOR
             return NetworkToHost(result);
         }
 
-        std::uint32_t Consume4B(ConstBuffer buffer, std::size_t &current)
+        std::uint32_t Consume4B(std::span<std::uint8_t> buffer, std::size_t &current)
         {
             EnsureEnoughSpace(buffer, current, 4);
             std::uint32_t result = 0;
@@ -141,7 +107,7 @@ namespace CBOR
             return NetworkToHost(result);
         }
 
-        std::uint64_t Consume8B(ConstBuffer buffer, std::size_t &current)
+        std::uint64_t Consume8B(std::span<std::uint8_t> buffer, std::size_t &current)
         {
             EnsureEnoughSpace(buffer, current, 8);
             std::uint64_t result = 0;
@@ -171,7 +137,7 @@ namespace CBOR
             return ArgumentPosition(header & std::to_underlying(ArgumentPosition::PositionMask));
         }
 
-        std::uint64_t ArgumentValue(std::uint8_t header, ConstBuffer buffer, std::size_t &current)
+        std::uint64_t ArgumentValue(std::uint8_t header, std::span<std::uint8_t> buffer, std::size_t &current)
         {
             ArgumentPosition position = GetArgumentPosition(header);
             if (std::to_underlying(position) <= 23) {
@@ -192,29 +158,8 @@ namespace CBOR
             }
         }
 
-        std::uint64_t ReadArgumentValue(std::uint8_t header, ConstBuffer buffer, std::size_t current)
-        {
-            ArgumentPosition position = GetArgumentPosition(header);
-            if (std::to_underlying(position) <= 23) {
-                return std::to_underlying(position);
-            }
-            switch (position) {
-            case ArgumentPosition::Next1B:
-                return Read1B(buffer, current);
-            case ArgumentPosition::Next2B:
-                return Read2B(buffer, current);
-            case ArgumentPosition::Next4B:
-                return Read4B(buffer, current);
-            case ArgumentPosition::Next8B:
-                return Read8B(buffer, current);
-            default:
-                throw MalformedDataError("argument position is reserved for future use, incorrect, "
-                                         "or the parser is out of date");
-            }
-        }
-
         template <std::unsigned_integral T>
-        T ExtractUnsigned(ConstBuffer buffer, std::size_t &current)
+        T ExtractUnsigned(std::span<std::uint8_t> buffer, std::size_t &current)
         {
             static constexpr std::uint64_t maxValue = std::numeric_limits<T>::max();
 
@@ -269,7 +214,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, ConstBuffer buffer, std::size_t &current)
+        T SignedPositive(std::uint8_t header, std::span<std::uint8_t> buffer, std::size_t &current)
         {
             static constexpr std::uint64_t maxValue = std::numeric_limits<T>::max();
 
@@ -321,7 +266,7 @@ namespace CBOR
         }
 
         template <std::signed_integral T>
-        T SignedNegative(std::uint8_t header, ConstBuffer buffer, std::size_t &current)
+        T SignedNegative(std::uint8_t header, std::span<std::uint8_t> 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);
@@ -374,7 +319,7 @@ namespace CBOR
         }
 
         template <std::signed_integral T>
-        T ExtractSigned(ConstBuffer buffer, std::size_t &current)
+        T ExtractSigned(std::span<std::uint8_t> buffer, std::size_t &current)
         {
             std::uint8_t header = Consume1B(buffer, current);
             MajorType major = GetMajorType(header);
@@ -390,15 +335,15 @@ namespace CBOR
             }
         }
 
-        ConstBuffer ExtractBinary(std::size_t size, ConstBuffer buffer, std::size_t &current)
+        std::span<std::uint8_t> ExtractBinary(std::size_t size, std::span<std::uint8_t> buffer, std::size_t &current)
         {
             EnsureEnoughSpace(buffer, current, size);
-            ConstBuffer result(buffer.data() + current, size);
+            std::span<std::uint8_t> result(buffer.data() + current, size);
             current += size;
             return result;
         }
 
-        std::string_view ExtractString(std::size_t size, ConstBuffer buffer, std::size_t &current)
+        std::string_view ExtractString(std::size_t size, std::span<std::uint8_t> buffer, std::size_t &current)
         {
             EnsureEnoughSpace(buffer, current, size);
             std::string_view result(reinterpret_cast<const char *>(buffer.data() + current), size);
@@ -411,31 +356,6 @@ namespace CBOR
         : mDecoder(&decoder)
     {}
 
-    Item::Item(Item &&other)
-        : mDecoder(std::exchange(other.mDecoder, nullptr))
-    {}
-
-    Item &Item::operator=(Item &&other)
-    {
-        mDecoder = std::exchange(other.mDecoder, nullptr);
-        return *this;
-    }
-
-    MajorType Item::GetMajor() const
-    {
-        return mDecoder->GetMajor();
-    }
-
-    MinorType Item::GetMinor() const
-    {
-        return mDecoder->GetMinor();
-    }
-
-    std::uint64_t Item::GetArgument() const
-    {
-        return mDecoder->GetArgument();
-    }
-
     bool Item::Bool()
     {
         return mDecoder->Bool();
@@ -496,7 +416,7 @@ namespace CBOR
         return mDecoder->Double();
     }
 
-    ConstBuffer Item::Binary()
+    std::span<std::uint8_t> Item::Binary()
     {
         return mDecoder->Binary();
     }
@@ -535,18 +455,6 @@ namespace CBOR
         : mState(State::Initial), mDecoder(&decoder)
     {}
 
-    TaggedItem::TaggedItem(TaggedItem &&other)
-        : mState(std::exchange(other.mState, State::Done))
-        , mDecoder(std::exchange(other.mDecoder, nullptr))
-    {}
-
-    TaggedItem &TaggedItem::operator=(TaggedItem &&other)
-    {
-        mState = std::exchange(other.mState, State::Done);
-        mDecoder = std::exchange(other.mDecoder, nullptr);
-        return *this;
-    }
-
     std::uint64_t TaggedItem::Tag()
     {
         if (mState != State::Initial) {
@@ -577,18 +485,6 @@ namespace CBOR
         : mState(State::Initial), mDecoder(&decoder)
     {}
 
-    KeyValue::KeyValue(KeyValue &&other)
-        : mState(std::exchange(other.mState, State::Done))
-        , mDecoder(std::exchange(other.mDecoder, nullptr))
-    {}
-
-    KeyValue &KeyValue::operator=(KeyValue &&other)
-    {
-        mState = std::exchange(other.mState, State::Done);
-        mDecoder = std::exchange(other.mDecoder, nullptr);
-        return *this;
-    }
-
     Item KeyValue::Key()
     {
         if (mState != State::Initial) {
@@ -616,22 +512,6 @@ namespace CBOR
         , mDecoder(&decoder)
     {}
 
-    Binary::Binary(Binary &&other)
-        : mHeaderParsed(std::exchange(other.mHeaderParsed, true))
-        , mDone(std::exchange(other.mDone, true))
-        , mCheckedDone(std::exchange(other.mCheckedDone, true))
-        , mDecoder(std::exchange(other.mDecoder, nullptr))
-    {}
-
-    Binary &Binary::operator=(Binary &&other)
-    {
-        mHeaderParsed = std::exchange(other.mHeaderParsed, true);
-        mDone = std::exchange(other.mDone, true);
-        mCheckedDone = std::exchange(other.mCheckedDone, true);
-        mDecoder = std::exchange(other.mDecoder, nullptr);
-        return *this;
-    }
-
     bool Binary::Done()
     {
         if (!mHeaderParsed) {
@@ -651,7 +531,7 @@ namespace CBOR
         return mDone;
     }
 
-    ConstBuffer Binary::Next()
+    std::span<std::uint8_t> Binary::Next()
     {
         if (!mHeaderParsed) {
             std::uint8_t header = Consume1B(mDecoder->mBuffer, mDecoder->mCurrent);
@@ -699,22 +579,6 @@ namespace CBOR
         , mDecoder(&decoder)
     {}
 
-    String::String(String &&other)
-        : mHeaderParsed(std::exchange(other.mHeaderParsed, true))
-        , mDone(std::exchange(other.mDone, true))
-        , mCheckedDone(std::exchange(other.mCheckedDone, true))
-        , mDecoder(std::exchange(other.mDecoder, nullptr))
-    {}
-
-    String &String::operator=(String &&other)
-    {
-        mHeaderParsed = std::exchange(other.mHeaderParsed, true);
-        mDone = std::exchange(other.mDone, true);
-        mCheckedDone = std::exchange(other.mCheckedDone, true);
-        mDecoder = std::exchange(other.mDecoder, nullptr);
-        return *this;
-    }
-
     bool String::Done()
     {
         if (!mHeaderParsed) {
@@ -784,26 +648,6 @@ namespace CBOR
         , mDecoder(&decoder)
     {}
 
-    Array::Array(Array &&other)
-        : mHeaderParsed(std::exchange(other.mHeaderParsed, true))
-        , mDone(std::exchange(other.mDone, true))
-        , mCheckedDone(std::exchange(other.mCheckedDone, true))
-        , mCurrent(std::exchange(other.mCurrent, 0))
-        , mSize(std::exchange(other.mSize, 0))
-        , mDecoder(std::exchange(other.mDecoder, nullptr))
-    {}
-
-    Array &Array::operator=(Array &&other)
-    {
-        mHeaderParsed = std::exchange(other.mHeaderParsed, true);
-        mDone = std::exchange(other.mDone, true);
-        mCheckedDone = std::exchange(other.mCheckedDone, true);
-        mCurrent = std::exchange(other.mCurrent, 0);
-        mSize = std::exchange(other.mSize, 0);
-        mDecoder = std::exchange(other.mDecoder, nullptr);
-        return *this;
-    }
-
     bool Array::Done()
     {
         if (!mHeaderParsed) {
@@ -868,26 +712,6 @@ namespace CBOR
         , mDecoder(&decoder)
     {}
 
-    Map::Map(Map &&other)
-        : mHeaderParsed(std::exchange(other.mHeaderParsed, true))
-        , mDone(std::exchange(other.mDone, true))
-        , mCheckedDone(std::exchange(other.mCheckedDone, true))
-        , mCurrent(std::exchange(other.mCurrent, 0))
-        , mSize(std::exchange(other.mSize, 0))
-        , mDecoder(std::exchange(other.mDecoder, nullptr))
-    {}
-
-    Map &Map::operator=(Map &&other)
-    {
-        mHeaderParsed = std::exchange(other.mHeaderParsed, true);
-        mDone = std::exchange(other.mDone, true);
-        mCheckedDone = std::exchange(other.mCheckedDone, true);
-        mCurrent = std::exchange(other.mCurrent, 0);
-        mSize = std::exchange(other.mSize, 0);
-        mDecoder = std::exchange(other.mDecoder, nullptr);
-        return *this;
-    }
-
     bool Map::Done()
     {
         if (!mHeaderParsed) {
@@ -943,49 +767,10 @@ namespace CBOR
         return KeyValue(*mDecoder);
     }
 
-    Decoder::Decoder(ConstBuffer buffer)
+    Decoder::Decoder(std::span<std::uint8_t> buffer)
         : mCurrent(0), mBuffer(buffer)
     {}
 
-    Decoder::Decoder(Decoder &&other)
-        : mCurrent(std::exchange(other.mCurrent, 0))
-        , mBuffer(std::exchange(other.mBuffer, {}))
-    {}
-
-    Decoder &Decoder::operator=(Decoder &&other)
-    {
-        mCurrent = std::exchange(other.mCurrent, 0);
-        mBuffer = std::exchange(other.mBuffer, {});
-        return *this;
-    }
-
-    MajorType Decoder::GetMajor() const
-    {
-        std::uint8_t header = Read1B(mBuffer, mCurrent);
-        return GetMajorType(header);
-    }
-
-    MinorType Decoder::GetMinor() const
-    {
-        std::uint8_t header = Read1B(mBuffer, mCurrent);
-        if (GetMajorType(header) != MajorType::Other) {
-            throw InvalidUsageError("use the GetArgument function instead");
-        }
-        return GetMinorType(header);
-    }
-
-    std::uint64_t Decoder::GetArgument() const
-    {
-        std::uint8_t header = Read1B(mBuffer, mCurrent);
-        if (GetMajorType(header) != MajorType::Other) {
-            throw InvalidUsageError("use the GetMinor function instead");
-        }
-        if (GetArgumentPosition(header) == ArgumentPosition::Indefinite) {
-            return Decoder::ArgumentIndefinite;
-        }
-        return ReadArgumentValue(header, mBuffer, mCurrent);
-    }
-
     bool Decoder::Bool()
     {
         std::uint8_t header = Consume1B(mBuffer, mCurrent);
@@ -1096,7 +881,7 @@ namespace CBOR
         throw TypeMismatchError("double", ToString(major));
     }
 
-    ConstBuffer Decoder::Binary()
+    std::span<std::uint8_t> Decoder::Binary()
     {
         std::uint8_t header = Consume1B(mBuffer, mCurrent);
         MajorType major = GetMajorType(header);
@@ -1152,9 +937,4 @@ namespace CBOR
     {
         return { *this };
     }
-
-    Item Decoder::AsItem()
-    {
-        return { *this };
-    }
 }

LibCBOR/Source/Encoder.cpp

@@ -76,16 +76,16 @@ namespace CBOR
         }
     }
 
-    EncoderBuffer::EncoderBuffer(Buffer buffer)
+    EncoderBuffer::EncoderBuffer(std::span<std::uint8_t> buffer)
-        : mBuffer(FixedBuffer { .mCurrent = 0, .mBuffer = buffer, })
+        : mBuffer(FixedBuffer { .Current = 0, .Buffer = buffer, })
     {}
 
     EncoderBuffer::EncoderBuffer(std::vector<std::uint8_t> &buffer)
-        : mBuffer(DynamicBuffer { .mBuffer = &buffer })
+        : mBuffer(DynamicBuffer { .Buffer = &buffer })
     {}
 
     EncoderBuffer::EncoderBuffer(EncoderBuffer &&other)
-        : mBuffer(std::exchange(other.mBuffer, FixedBuffer { .mCurrent = 0, .mBuffer = {}, }))
+        : mBuffer(std::exchange(other.mBuffer, FixedBuffer { .Current = 0, .Buffer = {}, }))
     {}
 
     void EncoderBuffer::Write(std::uint8_t value)
@@ -120,7 +120,7 @@ namespace CBOR
         }, mBuffer);
     }
 
-    void EncoderBuffer::Write(Buffer value)
+    void EncoderBuffer::Write(std::span<std::uint8_t> 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);
-        mBuffer[mCurrent++] = value;
+        Buffer[Current++] = 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);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network     ) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network     ) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 8) & mask);
+        Buffer[Current++] = 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);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network      ) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network      ) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >>  8) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >>  8) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 16) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >> 16) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 24) & mask);
+        Buffer[Current++] = 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);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network      ) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network      ) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >>  8) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >>  8) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 16) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >> 16) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 24) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >> 24) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 32) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >> 32) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 40) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >> 40) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 48) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >> 48) & mask);
-        mBuffer[mCurrent++] = static_cast<std::uint8_t>((network >> 56) & mask);
+        Buffer[Current++] = static_cast<std::uint8_t>((network >> 56) & mask);
     }
 
-    void EncoderBuffer::FixedBuffer::Write(Buffer value)
+    void EncoderBuffer::FixedBuffer::Write(std::span<std::uint8_t> value)
     {
         EnsureSpace(value.size());
-        std::memcpy(mBuffer.data() + mCurrent, value.data(), value.size());
+        std::memcpy(Buffer.data() + Current, value.data(), value.size());
-        mCurrent += value.size();
+        Current += value.size();
     }
 
     void EncoderBuffer::FixedBuffer::Write(std::string_view value)
     {
         EnsureSpace(value.size());
-        std::memcpy(mBuffer.data() + mCurrent, value.data(), value.size());
+        std::memcpy(Buffer.data() + Current, value.data(), value.size());
-        mCurrent += value.size();
+        Current += value.size();
     }
 
     void EncoderBuffer::FixedBuffer::EnsureSpace(std::size_t size) const
     {
-        std::size_t spaceLeft = mCurrent > mBuffer.size() ? 0 : mBuffer.size() - mCurrent;
+        std::size_t spaceLeft = Current > Buffer.size() ? 0 : Buffer.size() - Current;
 
         if (size > spaceLeft) {
             throw NotEnoughSpace(spaceLeft, size);
@@ -210,59 +210,59 @@ namespace CBOR
 
     std::size_t EncoderBuffer::FixedBuffer::Size() const
     {
-        return mCurrent;
+        return Current;
     }
 
     void EncoderBuffer::DynamicBuffer::Write(std::uint8_t value)
     {
-        mBuffer->push_back(value);
+        Buffer->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);
-        mBuffer->push_back(static_cast<std::uint8_t>((network     ) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network     ) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 8) & mask));
+        Buffer->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);
-        mBuffer->push_back(static_cast<std::uint8_t>((network      ) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network      ) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >>  8) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >>  8) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask));
+        Buffer->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);
-        mBuffer->push_back(static_cast<std::uint8_t>((network      ) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network      ) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >>  8) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >>  8) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >> 16) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >> 24) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 32) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >> 32) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 40) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >> 40) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 48) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >> 48) & mask));
-        mBuffer->push_back(static_cast<std::uint8_t>((network >> 56) & mask));
+        Buffer->push_back(static_cast<std::uint8_t>((network >> 56) & mask));
     }
 
-    void EncoderBuffer::DynamicBuffer::Write(Buffer value)
+    void EncoderBuffer::DynamicBuffer::Write(std::span<std::uint8_t> value)
     {
-        mBuffer->append_range(value);
+        Buffer->append_range(value);
     }
 
     void EncoderBuffer::DynamicBuffer::Write(std::string_view value)
     {
-        mBuffer->append_range(value);
+        Buffer->append_range(value);
     }
 
     std::size_t EncoderBuffer::DynamicBuffer::Size() const
     {
-        return mBuffer->size();
+        return Buffer->size();
     }
 
     BasicEncoder::BasicEncoder(EncoderBuffer buffer)
@@ -447,7 +447,7 @@ namespace CBOR
         mBuffer.Write(std::bit_cast<std::uint64_t>(value));
     }
 
-    void BasicEncoder::Encode(Buffer value)
+    void BasicEncoder::Encode(std::span<std::uint8_t> value)
     {
         WriteHeader(mBuffer, MajorType::Binary, value.size());
         mBuffer.Write(value);

LibCBOR/Source/Printer.cpp

@@ -1,152 +0,0 @@
-#include "Printer.hpp"
-
-#include "Core.hpp"
-#include "Decoder.hpp"
-
-#include <print>
-#include <string>
-
-namespace CBOR
-{
-    namespace
-    {
-        void Print(std::ostream &out, std::size_t depth, CBOR::Item item);
-
-        char AsChar(std::uint8_t nibble)
-        {
-            if (nibble < 10) {
-                return nibble + '0';
-            }
-            if (nibble < 16) {
-                return nibble + 'A';
-            }
-            return 'X';
-        }
-
-        std::string AsString(std::uint8_t byte)
-        {
-            std::string result;
-            result.push_back(AsChar((byte >> 4) & 15));
-            result.push_back(AsChar((byte     ) & 15));
-            return result;
-        }
-
-        void PrintBinary(std::ostream &out, CBOR::Binary binary)
-        {
-            out << "b\"";
-            while (!binary.Done()) {
-                std::span<const std::uint8_t> chunk = binary.Next();
-                for (std::uint8_t byte: chunk) {
-                    out << AsString(byte);
-                }
-            }
-            out << '\"';
-        }
-
-        void PrintString(std::ostream &out, CBOR::String string)
-        {
-            out << '\"';
-            while (!string.Done()) {
-                out << string.Next();
-            }
-            out << '\"';
-        }
-
-        void PrintArray(std::ostream &out, std::size_t depth, CBOR::Array array)
-        {
-            out << "[\n";
-            while (!array.Done()) {
-                out << std::string((depth + 1) * 4, ' ');
-                Print(out, depth + 1, array.Next());
-                out << ",\n";
-            }
-            out << std::string(depth * 4, ' ') << "]";
-        }
-
-        void PrintMap(std::ostream &out, std::size_t depth, CBOR::Map map)
-        {
-            out << "{\n";
-            while (!map.Done()) {
-                CBOR::KeyValue kv = map.Next();
-                out << std::string((depth + 1) * 4, ' ');
-                Print(out, depth + 1, kv.Key());
-                out << ": ";
-                Print(out, depth + 1, kv.Value());
-                out << ",\n";
-            }
-            out << std::string(depth * 4, ' ') << "}";
-        }
-
-        void PrintTagged(std::ostream &out, std::size_t depth, CBOR::TaggedItem item)
-        {
-            out << item.Tag();
-            out << '(';
-            Print(out, depth, item.Item());
-            out << ')';
-        }
-
-        void Print(std::ostream &out, std::size_t depth, CBOR::Item item)
-        {
-            switch (item.GetMajor()) {
-            case MajorType::Unsigned:
-                out << item.Uint64();
-                break;
-            case MajorType::Negative:
-                out << item.Int64();
-                break;
-            case MajorType::Binary:
-                PrintBinary(out, item.IndefiniteBinary());
-                break;
-            case MajorType::String:
-                PrintString(out, item.IndefiniteString());
-                break;
-            case MajorType::Array:
-                PrintArray(out, depth, item.Array());
-                break;
-            case MajorType::Map:
-                PrintMap(out, depth, item.Map());
-                break;
-            case MajorType::Tag:
-                PrintTagged(out, depth, item.TaggedItem());
-                break;
-            case MajorType::Other:
-                switch (item.GetMinor()) {
-                case MinorType::False:
-                    out << "false";
-                    break;
-                case MinorType::True:
-                    out << "true";
-                    break;
-                case MinorType::Null:
-                    out << "null";
-                    break;
-                case MinorType::Undefined:
-                    out << "undefined";
-                    break;
-                case MinorType::Float:
-                    std::print(out, "{:.6f}", item.Float());
-                    break;
-                case MinorType::Double:
-                    std::print(out, "{:.15f}", item.Double());
-                    break;
-                default:
-                    out << "invalid_value";
-                    break;
-                }
-            }
-        }
-    }
-
-    void Print(std::ostream &out, ConstBuffer buffer)
-    {
-        CBOR::Decoder dec(buffer);
-        Print(out, 0, dec.AsItem());
-        out << '\n';
-    }
-
-    void Print(std::ostream &out, CBOR::Item item)
-    {
-        Print(out, 0, std::move(item));
-        out << '\n';
-    }
-}

Tests/Main.cpp

@@ -1,9 +1,7 @@
 #include "CBOR/Decoder.hpp"
 #include "CBOR/Encoder.hpp"
-#include "CBOR/Printer.hpp"
 #include <array>
 #include <cstdint>
-#include <iostream>
 #include <print>
 #include <ranges>
 #include <stdexcept>
@@ -208,9 +206,6 @@ int main()
         SomeStruct result1 = Decode1(std::span<std::uint8_t>(buffer.data(), encodedSize));
         SomeStruct result2 = Decode2(std::span<std::uint8_t>(buffer.data(), encodedSize));
 
-        std::println("JSON-esque serialization:");
-        CBOR::Print(std::cout, std::span<std::uint8_t>(buffer.data(), encodedSize));
-
         Compare(expected, result1);
         Compare(expected, result2);
         std::println("The test has been completed successfully.");