mip.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstring>
 
#include <stdint.h>
#include <stddef.h>
 
#include "mip_packet.h"
#include "mip_field.h"
#include "mip_parser.h"
#include "mip_offsets.h"
#include "definitions/descriptors.h"
#include "mip_types.h"
 
#include <assert.h>
 
 
namespace mip
{
 
using PacketLength = C::packet_length;
 
template<class Field> struct MipFieldInfo;
 
 
class Field : public C::mip_field
{
public:
    Field() { C::mip_field::_payload=nullptr; C::mip_field::_payload_length=0; C::mip_field::_field_descriptor=0x00; C::mip_field::_descriptor_set=0x00; C::mip_field::_remaining_length=0; }
    Field(uint8_t descriptor_set, uint8_t field_descriptor, const uint8_t* payload, uint8_t payload_length) { C::mip_field_init(this, descriptor_set, field_descriptor, payload, payload_length); }
    Field(const uint8_t* header, uint8_t total_length, uint8_t descriptor_set) { *this = C::mip_field_from_header_ptr(header, total_length, descriptor_set); }
    Field(const C::mip_field& other) { std::memcpy(static_cast<C::mip_field*>(this), &other, sizeof(C::mip_field)); }
 
    uint8_t descriptorSet() const { return C::mip_field_descriptor_set(this); }
    uint8_t fieldDescriptor() const { return C::mip_field_field_descriptor(this); }
    uint8_t payloadLength() const { return C::mip_field_payload_length(this); }
    const uint8_t* payload() const { return C::mip_field_payload(this); }
 
    template<class Field>
    bool extract(Field& field) const { return mip::extract(field, payload(), payloadLength(), 0, true); }
 
    uint8_t payload(unsigned int index) const { return payload()[index]; }
 
    bool isValid() const { return C::mip_field_is_valid(this); }
 
    Field nextAfter() const { return C::mip_field_next_after(this); }
    bool next() { return C::mip_field_next(this); }
 
 
    bool isCommandSet() const { return isCommandDescriptorSet(descriptorSet()); }
 
    bool isData() const { return isDataDescriptorSet(descriptorSet()); }
 
    bool isCommand() const { return isCommandSet() && isCommandFieldDescriptor(fieldDescriptor()); }
 
    bool isResponse() const { return isCommandSet() && isResponseFieldDescriptor(fieldDescriptor()); }
 
    bool isReply() const { return isCommandSet() && isReplyFieldDescriptor(fieldDescriptor()) && payloadLength()==2; }
};
 
 
class Packet : public C::mip_packet
{
    class FieldIterator;
 
public:
    Packet(uint8_t* buffer, size_t bufferSize, uint8_t descriptorSet) { C::mip_packet_create(this, buffer, bufferSize, descriptorSet); }
    Packet(uint8_t* buffer, size_t length) { C::mip_packet_from_buffer(this, buffer, length); }
    Packet(const C::mip_packet* other) { std::memcpy(static_cast<C::mip_packet*>(this), other, sizeof(*this)); }
    Packet(const C::mip_packet& other) { std::memcpy(static_cast<C::mip_packet*>(this), &other, sizeof(*this)); }
 
    uint8_t      descriptorSet() const { return C::mip_packet_descriptor_set(this); }  
    PacketLength 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); }
    bool isCommand() 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); }  
 
    PacketLength bufferSize() const { return C::mip_packet_buffer_size(this); }            
    RemainingCount remainingSpace() const { return C::mip_packet_remaining_space(this); }  
 
    bool addField(uint8_t fieldDescriptor, const uint8_t* payload, size_t payloadLength) { return C::mip_packet_add_field(this, fieldDescriptor, payload, payloadLength); }  
    RemainingCount allocField(uint8_t fieldDescriptor, uint8_t payloadLength, uint8_t** payloadPtr_out) { return C::mip_packet_alloc_field(this, fieldDescriptor, payloadLength, payloadPtr_out); }  
    RemainingCount reallocLastField(uint8_t* payloadPtr, uint8_t newPayloadLength) { return C::mip_packet_realloc_last_field(this, payloadPtr, newPayloadLength); }  
    RemainingCount cancelLastField(uint8_t* payloadPtr) { return C::mip_packet_cancel_last_field(this, payloadPtr); }  
 
    void finalize() { C::mip_packet_finalize(this); }  
 
    void reset(uint8_t descSet) { C::mip_packet_reset(this, descSet); }  
    void reset() { reset(descriptorSet()); }  
 
    Field firstField() const { return Field(C::mip_field_first_from_packet(this)); }
 
    FieldIterator begin() const { return firstField(); }
 
#if __cpp_range_based_for >= 201603
    std::nullptr_t     end() const { return nullptr; }
#else
    FieldIterator end() const { return Field(); }
#endif
 
    template<class Field>
    bool addField(const Field& field, uint8_t fieldDescriptor = Field::FIELD_DESCRIPTOR)
    {
        uint8_t* payload;
        size_t available = allocField(fieldDescriptor, 0, &payload);
        Serializer serializer(payload, available);
        insert(serializer, field);
        return reallocLastField(payload, serializer.length()) >= 0;
    }
 
    template<class Field>
    static Packet createFromField(uint8_t* buffer, size_t bufferSize, const Field& field, uint8_t fieldDescriptor=Field::FIELD_DESCRIPTOR)
    {
        Packet packet(buffer, bufferSize, Field::DESCRIPTOR_SET);
        packet.addField<Field>(field, fieldDescriptor);
        packet.finalize();
        return packet;
    }
 
private:
    class FieldIterator
    {
    public:
        FieldIterator(const Field& first) : mField(first) {}
        FieldIterator() {}
 
        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 Field& operator*() const { return mField; }
 
        FieldIterator& operator++() { mField.next(); return *this; }
    private:
        Field mField;
    };
 
};
 
 
class Parser : public C::mip_parser
{
public:
    Parser(uint8_t* buffer, size_t bufferSize, C::mip_packet_callback callback, void* callbackObject, Timeout timeout) { C::mip_parser_init(this, buffer, bufferSize, callback, callbackObject, timeout); }
    Parser(uint8_t* buffer, size_t bufferSize, bool (*callback)(void*,const Packet*,Timestamp), void* callbackObject, Timeout timeout) { C::mip_parser_init(this, buffer, bufferSize, (C::mip_packet_callback)callback, callbackObject, timeout); }
 
    Parser(uint8_t* buffer, size_t bufferSize, Timeout timeout) { C::mip_parser_init(this, buffer, bufferSize, nullptr, nullptr, timeout); }
 
    template<class T, bool (T::*Callback)(const Packet&, Timestamp)>
    void setCallback(T& object);
 
    void reset() { C::mip_parser_reset(this); }
 
    RemainingCount parse(const uint8_t* inputBuffer, size_t inputCount, Timestamp timestamp, unsigned int maxPackets) { return C::mip_parser_parse(this, inputBuffer, inputCount, timestamp, maxPackets); }
 
    Timeout timeout() const { return C::mip_parser_timeout(this); }
    void setTimeout(Timeout timeout) { return C::mip_parser_set_timeout(this, timeout); }
};
 
 
template<class T, bool (T::*Callback)(const Packet&, Timestamp)>
void Parser::setCallback(T& object)
{
    C::mip_packet_callback callback = [](void* obj, const C::mip_packet* pkt, Timestamp timestamp)->bool
    {
        return (static_cast<T*>(obj)->*Callback)(Packet(pkt), timestamp);
    };
 
    C::mip_parser_set_callback(this, callback, &object);
}
 
template<class Function>
bool parseMipDataFromSource(C::mip_parser& parser, Function reader, size_t maxPackets)
{
    uint8_t* ptr;
    size_t maxCount = C::mip_parser_get_write_ptr(&parser, &ptr);
 
    size_t count;
    Timestamp timestamp;
    if( !reader(ptr, maxCount, &count, &timestamp) )
        return false;
 
    assert(count <= maxCount);
 
    C::mip_parser_process_written(&parser, count, timestamp, maxPackets);
 
    return true;
}
 
 
} // namespace mip