data_shared.hpp

Go to the documentation of this file.

#pragma once
 
#include <mip/definitions/common.hpp>
#include <mip/mip_descriptors.hpp>
#include <mip/mip_result.hpp>
#include <mip/mip_interface.hpp>
 
#include <stdint.h>
#include <stddef.h>
 
namespace mip {
namespace C {
struct mip_interface;
} // namespace C
 
namespace data_shared {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET      = 0xFF,
    
    
    DATA_EVENT_SOURCE   = 0xD0,
    DATA_TICKS          = 0xD1,
    DATA_DELTA_TICKS    = 0xD2,
    DATA_GPS_TIME       = 0xD3,
    DATA_DELTA_TIME     = 0xD4,
    DATA_REFERENCE_TIME = 0xD5,
    DATA_REF_TIME_DELTA = 0xD6,
    DATA_EXTERNAL_TIME  = 0xD7,
    DATA_SYS_TIME_DELTA = 0xD8,
    DATA_DEBUG_TICKS    = 0xFF,
};
 
// Shared Type Definitions
 
static constexpr const uint8_t MIP_DATA_DESC_SHARED_START = 0xD0;
 
// Mip Fields
 
 
struct EventSource
{
    uint8_t trigger_id = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_EVENT_SOURCE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "EventSource";
    static constexpr const char* DOC_NAME = "EventSource";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(trigger_id);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(trigger_id));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct Ticks
{
    uint32_t ticks = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_TICKS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "Ticks";
    static constexpr const char* DOC_NAME = "Ticks";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(ticks);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(ticks));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct DeltaTicks
{
    uint32_t ticks = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_DELTA_TICKS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "DeltaTicks";
    static constexpr const char* DOC_NAME = "DeltaTicks";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(ticks);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(ticks));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct GpsTimestamp
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE        = 0x0000,
            TOW         = 0x0001,  
            WEEK_NUMBER = 0x0002,  
            TIME_VALID  = 0x0003,  
            ALL         = 0x0003,
        };
        uint16_t value = NONE;
        
        constexpr ValidFlags() : value(NONE) {}
        constexpr ValidFlags(int val) : value((uint16_t)val) {}
        constexpr operator uint16_t() const { return value; }
        constexpr ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        constexpr ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        constexpr ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        constexpr ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        constexpr bool tow() const { return (value & TOW) > 0; }
        constexpr void tow(bool val) { value &= ~TOW; if(val) value |= TOW; }
        constexpr bool weekNumber() const { return (value & WEEK_NUMBER) > 0; }
        constexpr void weekNumber(bool val) { value &= ~WEEK_NUMBER; if(val) value |= WEEK_NUMBER; }
        constexpr uint16_t timeValid() const { return (value & TIME_VALID) >> 0; }
        constexpr void timeValid(uint16_t val) { value = (value & ~TIME_VALID) | (val << 0); }
        constexpr bool allSet() const { return value == ALL; }
        constexpr void setAll() { value |= ALL; }
    };
    double tow = 0; 
    uint16_t week_number = 0; 
    ValidFlags valid_flags;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_GPS_TIME;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GpsTimestamp";
    static constexpr const char* DOC_NAME = "GpsTimestamp";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(tow,week_number,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(tow),std::ref(week_number),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct DeltaTime
{
    double seconds = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_DELTA_TIME;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "DeltaTime";
    static constexpr const char* DOC_NAME = "DeltaTime";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(seconds);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(seconds));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct ReferenceTimestamp
{
    uint64_t nanoseconds = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_REFERENCE_TIME;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ReferenceTimestamp";
    static constexpr const char* DOC_NAME = "ReferenceTimestamp";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(nanoseconds);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(nanoseconds));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct ReferenceTimeDelta
{
    uint64_t dt_nanos = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_REF_TIME_DELTA;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ReferenceTimeDelta";
    static constexpr const char* DOC_NAME = "ReferenceTimeDelta";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(dt_nanos);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(dt_nanos));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct ExternalTimestamp
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE        = 0x0000,
            NANOSECONDS = 0x0001,  
            ALL         = 0x0001,
        };
        uint16_t value = NONE;
        
        constexpr ValidFlags() : value(NONE) {}
        constexpr ValidFlags(int val) : value((uint16_t)val) {}
        constexpr operator uint16_t() const { return value; }
        constexpr ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        constexpr ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        constexpr ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        constexpr ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        constexpr bool nanoseconds() const { return (value & NANOSECONDS) > 0; }
        constexpr void nanoseconds(bool val) { value &= ~NANOSECONDS; if(val) value |= NANOSECONDS; }
        constexpr bool allSet() const { return value == ALL; }
        constexpr void setAll() { value |= ALL; }
    };
    uint64_t nanoseconds = 0;
    ValidFlags valid_flags;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_EXTERNAL_TIME;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ExternalTimestamp";
    static constexpr const char* DOC_NAME = "ExternalTimestamp";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(nanoseconds,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(nanoseconds),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
struct ExternalTimeDelta
{
    struct ValidFlags : Bitfield<ValidFlags>
    {
        typedef uint16_t Type;
        enum _enumType : uint16_t
        {
            NONE     = 0x0000,
            DT_NANOS = 0x0001,  
            ALL      = 0x0001,
        };
        uint16_t value = NONE;
        
        constexpr ValidFlags() : value(NONE) {}
        constexpr ValidFlags(int val) : value((uint16_t)val) {}
        constexpr operator uint16_t() const { return value; }
        constexpr ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        constexpr ValidFlags& operator=(int val) { value = uint16_t(val); return *this; }
        constexpr ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        constexpr ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
        
        constexpr bool dtNanos() const { return (value & DT_NANOS) > 0; }
        constexpr void dtNanos(bool val) { value &= ~DT_NANOS; if(val) value |= DT_NANOS; }
        constexpr bool allSet() const { return value == ALL; }
        constexpr void setAll() { value |= ALL; }
    };
    uint64_t dt_nanos = 0; 
    ValidFlags valid_flags;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_SYS_TIME_DELTA;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ExternalTimeDelta";
    static constexpr const char* DOC_NAME = "ExternalTimeDelta";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(dt_nanos,valid_flags);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(dt_nanos),std::ref(valid_flags));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
 
 
} // namespace data_shared
} // namespace mip