cobs.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include <span>
#include <iterator>
 
namespace Cobs
{
    constexpr uint8_t maxRunLength = 254;

    constexpr size_t maxEncodedSize(size_t dataSize)
    {
        size_t overhead = (dataSize + maxRunLength)/maxRunLength;
        return dataSize + overhead;
    }

    class Encoder
    {
    public:
        template<size_t Extent>
        Encoder(std::span<const uint8_t, Extent> _data)
        : data(_data), runLength(findRunLength()) { }
 
        template<size_t Extent>
        Encoder(std::span<uint8_t, Extent> span)
            : Encoder(std::span{
                reinterpret_cast<const uint8_t *>(span.data()),
                span.size()})
        {
        }
 
        Encoder begin()  const { return *this; }
        std::nullptr_t end() const { return {}; }
 
        // Iterator functionality
        using difference_type = ptrdiff_t;
        using value_type = uint8_t;
 
        value_type operator*() const;
        Encoder & operator++();
        Encoder operator++(int) { return ++*this; }
        bool operator!=(std::nullptr_t) const;
 
    private:
        uint8_t findRunLength();
 
        std::span<const uint8_t> data;
        uint8_t runLength;
        uint8_t runIndex = 0;
        bool runHeaderOutput = false;
    };
    static_assert(std::input_iterator<Encoder>);

    class Decoder
    {
    public:
        bool feed(uint8_t byte);

        uint8_t get(uint8_t byte) const;
 
    private:
        uint8_t runLength = 0;
        bool runLengthWasMax = true;
    };
};