SLIPParser.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/STL/cstddef> // std::nullptr, size_t
#include <AH/STL/utility> // std::forward
#include <stddef.h>       // size_t
 
#include <SLIPStream/SLIP.hpp>
 
#include <boost/integer.hpp>
 
 
class SLIPParser {
  public:
    template <size_t N>
    SLIPParser(uint8_t (&buffer)[N]) : SLIPParser(buffer, N) {}
 
    SLIPParser() : SLIPParser(nullptr) {}
 
    SLIPParser(std::nullptr_t) : SLIPParser(nullptr, 0) {}
 
    SLIPParser(uint8_t *buffer, size_t bufferSize)
        : buffer(buffer), bufferSize(bufferSize) {
        reset();
    }
 
    template <class Callback>
    size_t parse(uint8_t c, Callback callback);
 
    size_t parse(uint8_t c) {
        auto cb = [](uint8_t, size_t) {};
        return parse(c, cb);
    }
 
    bool wasTruncated() const { return truncated > 0; }
 
    size_t numTruncated() const { return truncated; }
 
  private:
    void reset() { write = buffer; }
 
  private:
    uint8_t *buffer   = nullptr;
    uint8_t *write    = nullptr;
    size_t bufferSize = 0;
    size_t truncated  = 0;
    bool escape       = false;
};
 
 
 
template <class CRC>
class SLIPParserCRC {
  public:
    SLIPParserCRC(const SLIPParser &parser) : parser(parser) {}
    SLIPParserCRC(const SLIPParser &parser, CRC &&crc)
        : parser(parser), crc(std::forward<CRC>(crc)) {}
 
    using checksum_t = typename boost::uint_t<CRC::bit_count>::least;
 
    size_t parse(uint8_t c) {
        // callback that resets the CRC when necessary, and that feeds the 
        // parsed byte to the CRC
        auto cb = [this](uint8_t c, size_t index) {
            if (index == 0)
                crc.reset();
            crc(c);
        };
        // use the standard SLIPParser
        size_t size = parser.parse(c, cb);
 
        // Correct the size of the packet for the size of the checksum
        if (size <= sizeof(checksum_t))
            return 0;
        if (parser.numTruncated() < sizeof(checksum_t))
            return size + parser.numTruncated() - sizeof(checksum_t);
        return size;
    }
 
    bool wasTruncated() const { return numTruncated() > 0; }
 
    size_t numTruncated() const {
        return parser.numTruncated() < sizeof(checksum_t)
                   ? 0
                   : parser.numTruncated() - sizeof(checksum_t);
    }
    checksum_t checksum() const { return crc.checksum(); }
 
  private:
    SLIPParser parser;
    CRC crc;
};
 
 
#include "SLIPParser.ipp"