mip_packet.hpp

Go to the documentation of this file.

#pragma once
 
#include "mip_field.hpp"
 
#include <mip/mip_packet.h>
#include <mip/mip_offsets.h>
 
#include <microstrain/common/serialization.hpp>
 
#include <assert.h>
#include <cstring>
 
 
namespace mip
{
 
 
class PacketView : public C::mip_packet_view
{
public:
    static constexpr size_t PAYLOAD_LENGTH_MAX = C::MIP_PACKET_PAYLOAD_LENGTH_MAX;
    static constexpr size_t PACKET_SIZE_MIN    = C::MIP_PACKET_LENGTH_MIN;
    static constexpr size_t PACKET_SIZE_MAX    = C::MIP_PACKET_LENGTH_MAX;
 
    class FieldIterator;
 
public:
    PacketView(uint8_t* buffer, size_t bufferSize, uint8_t descriptorSet) { C::mip_packet_create(this, buffer, bufferSize, descriptorSet); }
    PacketView(const uint8_t* buffer, size_t length) { C::mip_packet_from_buffer(this, const_cast<uint8_t*>(buffer), length); }
    PacketView(const C::mip_packet_view* other) { std::memcpy(static_cast<C::mip_packet_view*>(this), other, sizeof(*this)); }
    PacketView(const C::mip_packet_view& other) { std::memcpy(static_cast<C::mip_packet_view*>(this), &other, sizeof(*this)); }
 
    PacketView(microstrain::Span<uint8_t> buffer, uint8_t descriptorSet) { C::mip_packet_create(this, buffer.data(), buffer.size(), descriptorSet); }
 
    PacketView(microstrain::Span<const uint8_t> buffer) { C::mip_packet_from_buffer(this, const_cast<uint8_t*>(buffer.data()), buffer.size()); }
 
    //
    // C function wrappers
    //
 
    uint8_t        descriptorSet() const { return C::mip_packet_descriptor_set(this); }  
    uint_least16_t totalLength()   const { return C::mip_packet_total_length(this);   }  
    uint8_t        payloadLength() const { return C::mip_packet_payload_length(this); }  
 
    bool isData() const { return C::mip_packet_is_data(this); }
 
    const uint8_t* pointer() const { return C::mip_packet_pointer(this); }  
    const uint8_t* payload() const { return C::mip_packet_payload(this); }  
 
    uint16_t checksumValue() const { return C::mip_packet_checksum_value(this); }     
    uint16_t computeChecksum() const { return C::mip_packet_compute_checksum(this); } 
 
    bool isSane() const { return C::mip_packet_is_sane(this); }    
    bool isValid() const { return C::mip_packet_is_valid(this); }  
    bool isEmpty() const { return C::mip_packet_is_empty(this); }  
 
    uint_least16_t bufferSize() const { return C::mip_packet_buffer_size(this); }  
    int remainingSpace() const { return C::mip_packet_remaining_space(this); }  
 
    bool addField(uint8_t fieldDescriptor, const uint8_t* payload, uint8_t payloadLength) { return C::mip_packet_add_field(this, fieldDescriptor, payload, payloadLength); }  
    Serializer createField(uint8_t fieldDescriptor, uint8_t length) { uint8_t * ptr; if(C::mip_packet_create_field(this, fieldDescriptor, length, &ptr) < 0) length =0; return Serializer{ptr, length}; }
    //std::tuple<uint8_t*, size_t> createField(uint8_t fieldDescriptor) { uint8_t* ptr; int max_size = C::mip_packet_alloc_field(this, fieldDescriptor, 0, &ptr); return max_size >= 0 ? std::make_tuple(ptr, max_size) : std::make_tuple(nullptr, 0); }  ///<@copydoc mip::C::mip_packet_alloc_field
    //int finishLastField(uint8_t* payloadPtr, uint8_t newPayloadLength) { return C::mip_packet_realloc_last_field(this, payloadPtr, newPayloadLength); }  ///<@copydoc mip::C::mip_packet_realloc_last_field
    //int cancelLastField(uint8_t* payloadPtr) { return C::mip_packet_cancel_last_field(this, payloadPtr); }  ///<@copydoc mip::C::mip_packet_cancel_last_field
 
    void finalize() { C::mip_packet_finalize(this); }  
 
    void reset(uint8_t descSet) { C::mip_packet_reset(this, descSet); }  
    void reset() { reset(descriptorSet()); }  
 
    //
    // C++ additions
    //
 
    microstrain::Span<const uint8_t> totalSpan() const { return {pointer(), totalLength()}; }
 
    microstrain::Span<const uint8_t> payloadSpan() const { return {payload(), payloadLength()}; }
 
 
    class AllocatedField : public Serializer
    {
    public:
        AllocatedField(mip::PacketView& packet, uint8_t* buffer, size_t space) : Serializer(buffer, space), m_packet(packet) {}
        //AllocatedField(const AllocatedField&) = delete;
        AllocatedField& operator=(const AllocatedField&) = delete;
 
        bool commit()
        {
            assert(capacity() <= FIELD_PAYLOAD_LENGTH_MAX);
 
            bool ok = isOk();
 
            if(ok)
                ok &= C::mip_packet_update_last_field_length(&m_packet, basePointer(), (uint8_t) usedLength()) >= 0;
 
            if(!ok)
                C::mip_packet_cancel_last_field(&m_packet, basePointer());
 
            return ok;
        }
 
        void cancel() { if(basePointer()) C::mip_packet_cancel_last_field(&m_packet, basePointer()); }
 
    private:
        PacketView& m_packet;
    };
 
    AllocatedField createField(uint8_t fieldDescriptor) { uint8_t* ptr; size_t max_size = std::max<int>(0, C::mip_packet_create_field(this, fieldDescriptor, 0, &ptr)); return {*this, ptr, max_size}; }
 
    uint8_t operator[](unsigned int index) const { return pointer()[index]; }
 
    //
    // Additional functions which have no C equivalent
    //
 
    FieldIterator begin() const { return firstField(); }
 
#if __cpp_range_based_for >= 201603
    // After 201603, for loops allow different clases for begin and end.
    // Using nullptr is simpler and more efficient than creating an end iterator.
    std::nullptr_t end() const { return nullptr; }
#else
    FieldIterator end() const { return FieldView(); }
#endif
 
    FieldView firstField() const { return FieldView(C::mip_field_first_from_packet(this)); }
 
    template<class FieldType>
    bool addField(const FieldType& field, uint8_t fieldDescriptor=INVALID_FIELD_DESCRIPTOR)
    {
        if( fieldDescriptor == INVALID_FIELD_DESCRIPTOR )
            fieldDescriptor = FieldType::FIELD_DESCRIPTOR;
 
        AllocatedField buffer = createField(fieldDescriptor);
        buffer.insert(field);
        return buffer.commit();
    }
 
    template<class FieldType>
    static PacketView createFromField(uint8_t* buffer, size_t bufferSize, const FieldType& field, uint8_t fieldDescriptor=INVALID_FIELD_DESCRIPTOR)
    {
        if( fieldDescriptor == INVALID_FIELD_DESCRIPTOR )
            fieldDescriptor = FieldType::FIELD_DESCRIPTOR;
        PacketView packet(buffer, bufferSize, FieldType::DESCRIPTOR_SET);
        packet.addField<FieldType>(field, fieldDescriptor);
        packet.finalize();
        return packet;
    }
 
 
    class FieldIterator
    {
    public:
        FieldIterator() {}
 
        FieldIterator(const FieldView& first) : mField(first) {}
 
        bool operator==(const FieldIterator& other) const {
            // Required to make invalid fields equivalent for range-based for loop
            if( !mField.isValid() && !other.mField.isValid() )
                return true;
            return mField.descriptorSet() == other.mField.descriptorSet() && mField.fieldDescriptor() == other.mField.fieldDescriptor() && mField.payload() == other.mField.payload();
        }
        bool operator!=(const FieldIterator& other) const { return !(*this == other); }
 
        bool operator==(std::nullptr_t) const { return !mField.isValid(); }
        bool operator!=(std::nullptr_t) const { return mField.isValid(); }
 
        const FieldView& operator*() const { return mField; }
 
        FieldIterator& operator++() { mField.next(); return *this; }
 
    private:
        FieldView mField;
    };
 
    bool copyPacketTo(uint8_t* buffer, size_t maxLength) { assert(isSane()); size_t copyLength = this->totalLength(); if(copyLength > maxLength) return false; std::memcpy(buffer, pointer(), copyLength); return true; }
 
    bool copyPacketTo(microstrain::Span<uint8_t> buffer) { return copyPacketTo(buffer.data(), buffer.size()); }
};
 
 
template<size_t BufferSize>
class SizedPacketBuf : public PacketView
{
    static_assert(BufferSize >= PACKET_LENGTH_MIN, "BufferSize must be at least PACKET_LENGTH_MIN bytes");
 
public:
    SizedPacketBuf(uint8_t descriptorSet=INVALID_DESCRIPTOR_SET) : PacketView(mData, sizeof(mData), descriptorSet) {}
 
    explicit SizedPacketBuf(const uint8_t* data, size_t length) : PacketView(mData, sizeof(mData)) { copyFrom(data, length); }
    explicit SizedPacketBuf(const PacketView& packet) : PacketView(mData, sizeof(mData)) { copyFrom(packet); }
 
    explicit SizedPacketBuf(microstrain::Span<const uint8_t> data) : SizedPacketBuf(data.data(), data.size()) {}
 
    SizedPacketBuf(const SizedPacketBuf& other) : PacketView(mData, sizeof(mData)) { copyFrom(other); }
 
 
    template<size_t OtherSize>
    explicit SizedPacketBuf(const SizedPacketBuf<OtherSize>& other) : PacketView(mData, sizeof(mData)) { copyFrom(other); };
 
    SizedPacketBuf& operator=(const SizedPacketBuf& other) { copyFrom(other); return *this; }
 
    template<size_t OtherSize>
    SizedPacketBuf& operator=(const SizedPacketBuf<OtherSize>& other) { copyFrom(other); return *this; }
 
    template<class FieldType>
    SizedPacketBuf(
        const FieldType& field,
        uint8_t fieldDescriptor=INVALID_FIELD_DESCRIPTOR,
        typename std::enable_if<std::is_class<FieldType>::value, void>::type* = nullptr
    ) : PacketView(mData, sizeof(mData))
    {
        createFromField<FieldType>(mData, sizeof(mData), field, fieldDescriptor);
    }
 
 
    PacketView ref() { return *this; }
 
    const PacketView& ref() const { return *this; }
 
    uint8_t* buffer() { return mData; }
 
    microstrain::Span<uint8_t, BufferSize> bufferSpan() { return microstrain::Span<uint8_t, BufferSize>{buffer(), BufferSize}; }
 
    void copyFrom(const uint8_t* data, size_t length) { assert(length <= sizeof(mData)); std::memcpy(mData, data, length); }
 
    void copyFrom(const PacketView& packet) { assert(packet.isSane()); copyFrom(packet.pointer(), packet.totalLength()); }
 
private:
    uint8_t mData[BufferSize];
};
 
typedef SizedPacketBuf<mip::PACKET_LENGTH_MAX> PacketBuf;
 
 
 
} // namespace mip