mip_parser.hpp

Go to the documentation of this file.

#pragma once
 
#include "mip_packet.hpp"
 
#include <mip/mip_parser.h>
 
 
namespace mip
{
 
class Parser : public C::mip_parser
{
public:
    Parser(C::mip_packet_callback callback, void* callbackObject, Timeout timeout) { C::mip_parser_init(this, callback, callbackObject, timeout); }
    Parser(bool (*callback)(void*,const PacketView*,Timestamp), void* callbackObject, Timeout timeout) { C::mip_parser_init(this, (C::mip_packet_callback)callback, callbackObject, timeout); }
    explicit Parser(Timeout timeout) { C::mip_parser_init(this, nullptr, nullptr, timeout); }
 
    void setCallback(C::mip_packet_callback callback, void* callbackObject) { C::mip_parser_set_callback(this, callback, callbackObject); }
 
    template<class Lambda>
    void setCallback(Lambda lambda);
 
    template<class T, bool (T::*Callback)(const PacketView&, Timestamp)>
    void setCallback(T& object);
 
    template<class T, bool (*Callback)(T&, const PacketView&, Timestamp)>
    void setCallback(T& object);
 
    void reset() { C::mip_parser_reset(this); }
 
    size_t parse(const uint8_t* inputBuffer, size_t inputCount, Timestamp timestamp) { return C::mip_parser_parse(this, inputBuffer, inputCount, timestamp); }
 
    size_t parse(microstrain::Span<const uint8_t> data, Timestamp timestamp) { return parse(data.data(), data.size(), timestamp); }
 
    void flush() { C::mip_parser_flush(this); }
 
    microstrain::Span<uint8_t> getWritePtr() { uint8_t* ptr; size_t length = C::mip_parser_get_write_ptr(this, &ptr); return {ptr, length}; }
 
    Timeout timeout() const { return C::mip_parser_timeout(this); }
    void setTimeout(Timeout timeout) { return C::mip_parser_set_timeout(this, timeout); }
};
 
 
template<class FunctionOrLambda>
void Parser::setCallback(FunctionOrLambda function)
{
    C::mip_packet_callback callback = [](void* obj, const C::mip_packet_view* packet, Timestamp timestamp)->bool
    {
        return *(static_cast<FunctionOrLambda*>(obj))( mip::PacketView(*packet), timestamp );
    };
 
    C::mip_parser_set_callback(this, callback, &function);
}
 
template<class T, bool (T::*Callback)(const PacketView&, Timestamp)>
void Parser::setCallback(T& object)
{
    C::mip_packet_callback callback = +[](void* obj, const C::mip_packet_view* pkt, Timestamp timestamp)->bool
    {
        return (static_cast<T*>(obj)->*Callback)(PacketView(pkt), timestamp);
    };
 
    C::mip_parser_set_callback(this, callback, &object);
}
 
template<class T, bool (*Callback)(T&, const PacketView&, Timestamp)>
void Parser::setCallback(T& object)
{
    C::mip_packet_callback callback = +[](void* obj, const C::mip_packet_view* pkt, Timestamp timestamp)->bool
    {
        return (*Callback)(*static_cast<T*>(obj), PacketView(pkt), timestamp);
    };
 
    C::mip_parser_set_callback(this, callback, &object);
}
 
} // namespace mip