data_shared.hpp

Go to the documentation of this file.

#pragma once
 
#include "descriptors.h"
#include "../mip_result.h"
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
namespace mip {
class Serializer;
 
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 const uint8_t MIP_DATA_DESC_SHARED_START = 0xD0;
 
// Mip Fields
 
 
struct EventSource
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_EVENT_SOURCE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint8_t trigger_id = 0; 
    
};
void insert(Serializer& serializer, const EventSource& self);
void extract(Serializer& serializer, EventSource& self);
 
 
struct Ticks
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_TICKS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint32_t ticks = 0; 
    
};
void insert(Serializer& serializer, const Ticks& self);
void extract(Serializer& serializer, Ticks& self);
 
 
struct DeltaTicks
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_DELTA_TICKS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint32_t ticks = 0; 
    
};
void insert(Serializer& serializer, const DeltaTicks& self);
void extract(Serializer& serializer, DeltaTicks& self);
 
 
struct GpsTimestamp
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_GPS_TIME;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    struct ValidFlags : Bitfield<ValidFlags>
    {
        enum _enumType : uint16_t
        {
            NONE        = 0x0000,
            TOW         = 0x0001,  
            WEEK_NUMBER = 0x0002,  
            TIME_VALID  = 0x0003,  
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = val; return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
    };
    
    double tow = 0; 
    uint16_t week_number = 0; 
    ValidFlags valid_flags;
    
};
void insert(Serializer& serializer, const GpsTimestamp& self);
void extract(Serializer& serializer, GpsTimestamp& self);
 
 
struct DeltaTime
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_DELTA_TIME;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    double seconds = 0; 
    
};
void insert(Serializer& serializer, const DeltaTime& self);
void extract(Serializer& serializer, DeltaTime& self);
 
 
struct ReferenceTimestamp
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_REFERENCE_TIME;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint64_t nanoseconds = 0; 
    
};
void insert(Serializer& serializer, const ReferenceTimestamp& self);
void extract(Serializer& serializer, ReferenceTimestamp& self);
 
 
struct ReferenceTimeDelta
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_REF_TIME_DELTA;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    uint64_t dt_nanos = 0; 
    
};
void insert(Serializer& serializer, const ReferenceTimeDelta& self);
void extract(Serializer& serializer, ReferenceTimeDelta& self);
 
 
struct ExternalTimestamp
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_EXTERNAL_TIME;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    struct ValidFlags : Bitfield<ValidFlags>
    {
        enum _enumType : uint16_t
        {
            NONE        = 0x0000,
            NANOSECONDS = 0x0001,  
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = val; return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
    };
    
    uint64_t nanoseconds = 0;
    ValidFlags valid_flags;
    
};
void insert(Serializer& serializer, const ExternalTimestamp& self);
void extract(Serializer& serializer, ExternalTimestamp& self);
 
 
struct ExternalTimeDelta
{
    static const uint8_t DESCRIPTOR_SET = ::mip::data_shared::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::data_shared::DATA_SYS_TIME_DELTA;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    struct ValidFlags : Bitfield<ValidFlags>
    {
        enum _enumType : uint16_t
        {
            NONE     = 0x0000,
            DT_NANOS = 0x0001,  
        };
        uint16_t value = NONE;
        
        ValidFlags() : value(NONE) {}
        ValidFlags(int val) : value((uint16_t)val) {}
        operator uint16_t() const { return value; }
        ValidFlags& operator=(uint16_t val) { value = val; return *this; }
        ValidFlags& operator=(int val) { value = val; return *this; }
        ValidFlags& operator|=(uint16_t val) { return *this = value | val; }
        ValidFlags& operator&=(uint16_t val) { return *this = value & val; }
    };
    
    uint64_t dt_nanos = 0; 
    ValidFlags valid_flags;
    
};
void insert(Serializer& serializer, const ExternalTimeDelta& self);
void extract(Serializer& serializer, ExternalTimeDelta& self);
 
 
} // namespace data_shared
} // namespace mip