rtcmem_ts_getters.h

Go to the documentation of this file.

/*
=============================================================================
MIT License
 
Copyright (c) 2023-2025 Institute for Automotive Engineering (ika), RWTH Aachen University
Copyright (c) 2026 Virtual Vehicle Research GmbH
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=============================================================================
*/


 
#pragma once
 
#include <stdexcept>
#include <vector>
 
namespace etsi_its_rtcmem_ts_msgs {
 
namespace access {
 
#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_getters.h>
#include <etsi_its_msgs_utils/impl/checks.h>


  inline uint8_t getProtocolVersion(const ItsPduHeader& header) {
    return header.protocol_version;
  }

  inline uint8_t getMessageID(const ItsPduHeader& header) {
    return header.message_id;
  }

  inline StationID getStationID(const ItsPduHeader& header) {
    return header.station_id;
  }

  inline uint32_t getStationIDValue(const ItsPduHeader& header) {
    return getStationID(header).value;
  }

  inline ItsPduHeader getHeader(const RTCMEM& rtcmem) {
    return rtcmem.header;
  }

  inline uint8_t getProtocolVersion(const RTCMEM& rtcmem) {
    return getProtocolVersion(rtcmem.header);
  }

  inline uint8_t getMessageID(const RTCMEM& rtcmem) {
    return getMessageID(rtcmem.header);
  }

  inline StationID getStationID(const RTCMEM& rtcmem) {
    return getStationID(rtcmem.header);
  }

  inline uint32_t getStationIDValue(const RTCMEM& rtcmem) {
    return getStationIDValue(rtcmem.header);
  }

  inline RTCMcorrections getRTCMcorrections(const RTCMEM& rtcmem) {
    return rtcmem.rtcmc;
  }

  inline uint8_t getMsgCount(const MsgCount& msg_cnt) {
    return msg_cnt.value;
  }

  inline uint8_t getMsgCount(const RTCMcorrections& rtcm) {
    return getMsgCount(rtcm.msg_cnt);
  }

  inline uint8_t getMsgCount(const RTCMEM& rtcmem) {
    return getMsgCount(rtcmem.rtcmc);
  }

  inline RTCMRevision getRTCMRevision(const RTCMcorrections& rtcm) {
    return rtcm.rev;
  }

  inline RTCMRevision getRTCMRevision(const RTCMEM& rtcmem) {
    return getRTCMRevision(rtcmem.rtcmc);
  }

  inline uint8_t getRTCMRevisionValue(const RTCMRevision& rev) {
    return rev.value;
  }

  inline uint8_t getRTCMRevisionValue(const RTCMcorrections& rtcm) {
    return getRTCMRevisionValue(rtcm.rev);
  }

  inline uint8_t getRTCMRevisionValue(const RTCMEM& rtcmem) {
    return getRTCMRevisionValue(rtcmem.rtcmc);
  }

  inline bool hasMinuteOfTheYear(const RTCMcorrections& rtcm) {
    return rtcm.time_stamp_is_present;
  }

  inline bool hasMinuteOfTheYear(const RTCMEM& rtcmem) {
    return hasMinuteOfTheYear(rtcmem.rtcmc);
  }

  inline MinuteOfTheYear getMinuteOfTheYear(const RTCMcorrections& rtcm) {
    throwIfNotPresent(rtcm.time_stamp_is_present, "rtcm.time_stamp");
    return rtcm.time_stamp;
  }

  inline MinuteOfTheYear getMinuteOfTheYear(const RTCMEM& rtcmem) {
    return getMinuteOfTheYear(rtcmem.rtcmc);
  }

  inline uint32_t getMinuteOfTheYearValue(const RTCMcorrections& rtcm) {
    return getMinuteOfTheYear(rtcm).value;
  }

  inline uint32_t getMinuteOfTheYearValue(const RTCMEM& rtcmem) {
    return getMinuteOfTheYearValue(rtcmem.rtcmc);
  }

  inline bool hasAnchorPoint(const RTCMcorrections& rtcm) {
    return rtcm.anchor_point_is_present;
  }

  inline bool hasAnchorPoint(const RTCMEM& rtcmem) {
    return hasAnchorPoint(rtcmem.rtcmc);
  }

  inline FullPositionVector getAnchorPoint(const RTCMcorrections& rtcm) {
    throwIfNotPresent(rtcm.anchor_point_is_present, "rtcm.anchor_point");
    return rtcm.anchor_point;
  }

  inline FullPositionVector getAnchorPoint(const RTCMEM& rtcmem) {
    return getAnchorPoint(rtcmem.rtcmc);
  }

  inline bool hasRTCMHeader(const RTCMcorrections& rtcm) {
    return rtcm.rtcm_header_is_present;
  }

  inline bool hasRTCMHeader(const RTCMEM& rtcmem) {
    return hasRTCMHeader(rtcmem.rtcmc);
  }

  inline RTCMheader getRTCMHeader(const RTCMcorrections& rtcm) {
    throwIfNotPresent(rtcm.rtcm_header_is_present, "rtcm.rtcm_header");
    return rtcm.rtcm_header;
  }

  inline RTCMheader getRTCMHeader(const RTCMEM& rtcmem) {
    return getRTCMHeader(rtcmem.rtcmc);
  }

  inline RTCMmessageList getRTCMmessageList(const RTCMcorrections& rtcm) {
    return rtcm.msgs;
  }

  inline RTCMmessageList getRTCMmessageList(const RTCMEM& rtcmem) {
    return getRTCMmessageList(rtcmem.rtcmc);
  }

  inline std::vector<RTCMmessage> getRTCMmessages(const RTCMmessageList& msgs) {
    return msgs.array;
  }

  inline std::vector<RTCMmessage> getRTCMmessages(const RTCMcorrections& rtcm) {
    return getRTCMmessages(rtcm.msgs);
  }

  inline std::vector<RTCMmessage> getRTCMmessages(const RTCMEM& rtcmem) {
    return getRTCMmessages(rtcmem.rtcmc);
  }

  inline std::size_t getRTCMmessageCount(const RTCMmessageList& msgs) {
    return msgs.array.size();
  }

  inline std::size_t getRTCMmessageCount(const RTCMcorrections& rtcm) {
    return getRTCMmessageCount(rtcm.msgs);
  }

  inline std::size_t getRTCMmessageCount(const RTCMEM& rtcmem) {
    return getRTCMmessageCount(rtcmem.rtcmc);
  }

  inline RTCMmessage getRTCMmessage(const RTCMmessageList& msgs, const std::size_t index) {
    if (index >= msgs.array.size()) {
      throw std::out_of_range("RTCMmessageList index out of range.");
    }
    return msgs.array[index];
  }

  inline RTCMmessage getRTCMmessage(const RTCMcorrections& rtcm, const std::size_t index) {
    return getRTCMmessage(rtcm.msgs, index);
  }

  inline RTCMmessage getRTCMmessage(const RTCMEM& rtcmem, const std::size_t index) {
    return getRTCMmessage(rtcmem.rtcmc, index);
  }

  inline std::vector<uint8_t> getRTCMmessageValue(const RTCMmessage& msg) {
    return msg.value;
  }

  inline std::size_t getRTCMmessageSize(const RTCMmessage& msg) {
    return msg.value.size();
  }

  inline GNSSstatus getGNSSstatus(const RTCMheader& header) {
    return header.status;
  }

  inline std::vector<bool> getGNSSstatus(const GNSSstatus& status) {
    return getBitString(status.value, status.bits_unused);
  }

  inline std::vector<bool> getGNSSstatusBits(const RTCMheader& header) {
    return getGNSSstatus(header.status);
  }

  inline AntennaOffsetSet getAntennaOffsetSet(const RTCMheader& header) {
    return header.offset_set;
  }

  inline bool getGNSSstatusBit(const GNSSstatus& status, const uint8_t bit_index) {
    throwIfOutOfRange(bit_index, static_cast<uint8_t>(0), static_cast<uint8_t>(GNSSstatus::SIZE_BITS - 1), "GNSSstatus bit index");
 
    if (status.value.empty()) {
      return false;
    }
 
    const uint8_t mask = static_cast<uint8_t>(1u << bit_index);
    return (status.value[0] & mask) != 0;
  }

  inline bool getUnavailableFlag(const GNSSstatus& status) {
    return getGNSSstatusBit(status, GNSSstatus::BIT_INDEX_UNAVAILABLE);
  }

  inline bool getIsHealthyFlag(const GNSSstatus& status) {
    return getGNSSstatusBit(status, GNSSstatus::BIT_INDEX_IS_HEALTHY);
  }

  inline bool getIsMonitoredFlag(const GNSSstatus& status) {
    return getGNSSstatusBit(status, GNSSstatus::BIT_INDEX_IS_MONITORED);
  }

  inline bool getBaseStationTypeFlag(const GNSSstatus& status) {
    return getGNSSstatusBit(status, GNSSstatus::BIT_INDEX_BASE_STATION_TYPE);
  }

  inline bool getAPDOPofUnder5Flag(const GNSSstatus& status) {
    return getGNSSstatusBit(status, GNSSstatus::BIT_INDEX_A_PDO_POF_UNDER5);
  }

  inline bool getInViewOfUnder5Flag(const GNSSstatus& status) {
    return getGNSSstatusBit(status, GNSSstatus::BIT_INDEX_IN_VIEW_OF_UNDER5);
  }

  inline bool getLocalCorrectionsPresentFlag(const GNSSstatus& status) {
    return getGNSSstatusBit(status, GNSSstatus::BIT_INDEX_LOCAL_CORRECTIONS_PRESENT);
  }

  inline bool getNetworkCorrectionsPresentFlag(const GNSSstatus& status) {
    return getGNSSstatusBit(status, GNSSstatus::BIT_INDEX_NETWORK_CORRECTIONS_PRESENT);
  }

  inline int16_t getAntennaOffsetXValue(const AntennaOffsetSet& offset) {
    return offset.ant_offset_x.value;
  }

  inline int16_t getAntennaOffsetYValue(const AntennaOffsetSet& offset) {
    return offset.ant_offset_y.value;
  }

  inline int16_t getAntennaOffsetZValue(const AntennaOffsetSet& offset) {
    return offset.ant_offset_z.value;
  }

  inline double getLongitude(const Longitude& longitude) {
    return static_cast<double>(longitude.value) * 1e-7;
  }

  inline double getLatitude(const Latitude& latitude) {
    return static_cast<double>(latitude.value) * 1e-7;
  }

  inline double getElevation(const Elevation& elevation) {
    return static_cast<double>(elevation.value) * 1e-1;
  }

  inline uint16_t getHeadingValue(const HeadingDSRC& heading) {
    return heading.value;
  }

  inline bool hasUTCTime(const FullPositionVector& pos) {
    return pos.utc_time_is_present;
  }

  inline DDateTime getUTCTime(const FullPositionVector& pos) {
    throwIfNotPresent(pos.utc_time_is_present, "pos.utc_time");
    return pos.utc_time;
  }

  inline int32_t getLongitudeValue(const FullPositionVector& pos) {
    return pos.lon.value;
  }

  inline double getLongitude(const FullPositionVector& pos) {
    return getLongitude(pos.lon);
  }

  inline int32_t getLatitudeValue(const FullPositionVector& pos) {
    return pos.lat.value;
  }

  inline double getLatitude(const FullPositionVector& pos) {
    return getLatitude(pos.lat);
  }

  inline bool hasElevation(const FullPositionVector& pos) {
    return pos.elevation_is_present;
  }

  inline Elevation getElevationObject(const FullPositionVector& pos) {
    throwIfNotPresent(pos.elevation_is_present, "pos.elevation");
    return pos.elevation;
  }

  inline double getElevation(const FullPositionVector& pos) {
    return getElevation(getElevationObject(pos));
  }

  inline bool hasHeading(const FullPositionVector& pos) {
    return pos.heading_is_present;
  }

  inline HeadingDSRC getHeading(const FullPositionVector& pos) {
    throwIfNotPresent(pos.heading_is_present, "pos.heading");
    return pos.heading;
  }

  inline bool hasSpeed(const FullPositionVector& pos) {
    return pos.speed_is_present;
  }

  inline TransmissionAndSpeed getSpeed(const FullPositionVector& pos) {
    throwIfNotPresent(pos.speed_is_present, "pos.speed");
    return pos.speed;
  }

  inline bool hasPositionalAccuracy(const FullPositionVector& pos) {
    return pos.pos_accuracy_is_present;
  }

  inline PositionalAccuracy getPositionalAccuracy(const FullPositionVector& pos) {
    throwIfNotPresent(pos.pos_accuracy_is_present, "pos.pos_accuracy");
    return pos.pos_accuracy;
  }

  inline bool hasTimeConfidence(const FullPositionVector& pos) {
    return pos.time_confidence_is_present;
  }

  inline TimeConfidence getTimeConfidence(const FullPositionVector& pos) {
    throwIfNotPresent(pos.time_confidence_is_present, "pos.time_confidence");
    return pos.time_confidence;
  }

  inline uint8_t getTimeConfidenceValue(const TimeConfidence& time_confidence) {
    return time_confidence.value;
  }

  inline bool hasPositionConfidence(const FullPositionVector& pos) {
    return pos.pos_confidence_is_present;
  }

  inline PositionConfidenceSet getPositionConfidence(const FullPositionVector& pos) {
    throwIfNotPresent(pos.pos_confidence_is_present, "pos.pos_confidence");
    return pos.pos_confidence;
  }

  inline bool hasSpeedConfidence(const FullPositionVector& pos) {
    return pos.speed_confidence_is_present;
  }

  inline SpeedandHeadingandThrottleConfidence getSpeedConfidence(const FullPositionVector& pos) {
    throwIfNotPresent(pos.speed_confidence_is_present, "pos.speed_confidence");
    return pos.speed_confidence;
  }

  inline TransmissionState getTransmissionState(const TransmissionAndSpeed& speed) {
    return speed.transmisson;
  }

  inline uint8_t getTransmissionStateValue(const TransmissionAndSpeed& speed) {
    return getTransmissionState(speed).value;
  }

  inline Velocity getVelocity(const TransmissionAndSpeed& speed) {
    return speed.speed;
  }

  inline uint16_t getVelocityValue(const TransmissionAndSpeed& speed) {
    return getVelocity(speed).value;
  }

  inline SemiMajorAxisAccuracy getSemiMajorAxisAccuracy(const PositionalAccuracy& accuracy) {
    return accuracy.semi_major;
  }

  inline uint8_t getSemiMajorAxisAccuracyValue(const PositionalAccuracy& accuracy) {
    return getSemiMajorAxisAccuracy(accuracy).value;
  }

  inline SemiMinorAxisAccuracy getSemiMinorAxisAccuracy(const PositionalAccuracy& accuracy) {
    return accuracy.semi_minor;
  }

  inline uint8_t getSemiMinorAxisAccuracyValue(const PositionalAccuracy& accuracy) {
    return getSemiMinorAxisAccuracy(accuracy).value;
  }

  inline SemiMajorAxisOrientation getSemiMajorAxisOrientation(const PositionalAccuracy& accuracy) {
    return accuracy.orientation;
  }

  inline uint16_t getSemiMajorAxisOrientationValue(const PositionalAccuracy& accuracy) {
    return getSemiMajorAxisOrientation(accuracy).value;
  }

  inline PositionConfidence getPositionConfidence(const PositionConfidenceSet& confidence) {
    return confidence.pos;
  }

  inline uint8_t getPositionConfidenceValue(const PositionConfidenceSet& confidence) {
    return getPositionConfidence(confidence).value;
  }

  inline ElevationConfidence getElevationConfidence(const PositionConfidenceSet& confidence) {
    return confidence.elevation;
  }

  inline uint8_t getElevationConfidenceValue(const PositionConfidenceSet& confidence) {
    return getElevationConfidence(confidence).value;
  }

  inline HeadingConfidenceDSRC getHeadingConfidence(const SpeedandHeadingandThrottleConfidence& confidence) {
    return confidence.heading;
  }

  inline uint8_t getHeadingConfidenceValue(const SpeedandHeadingandThrottleConfidence& confidence) {
    return getHeadingConfidence(confidence).value;
  }

  inline SpeedConfidenceDSRC getSpeedConfidenceDSRC(const SpeedandHeadingandThrottleConfidence& confidence) {
    return confidence.speed;
  }

  inline uint8_t getSpeedConfidenceValue(const SpeedandHeadingandThrottleConfidence& confidence) {
    return getSpeedConfidenceDSRC(confidence).value;
  }

  inline ThrottleConfidence getThrottleConfidence(const SpeedandHeadingandThrottleConfidence& confidence) {
    return confidence.throttle;
  }

  inline uint8_t getThrottleConfidenceValue(const SpeedandHeadingandThrottleConfidence& confidence) {
    return getThrottleConfidence(confidence).value;
  }

  inline bool hasYear(const DDateTime& date_time) {
    return date_time.year_is_present;
  }

  inline DYear getYear(const DDateTime& date_time) {
    throwIfNotPresent(date_time.year_is_present, "date_time.year");
    return date_time.year;
  }

  inline uint16_t getYearValue(const DDateTime& date_time) {
    return getYear(date_time).value;
  }

  inline bool hasMonth(const DDateTime& date_time) {
    return date_time.month_is_present;
  }

  inline DMonth getMonth(const DDateTime& date_time) {
    throwIfNotPresent(date_time.month_is_present, "date_time.month");
    return date_time.month;
  }

  inline uint8_t getMonthValue(const DDateTime& date_time) {
    return getMonth(date_time).value;
  }

  inline bool hasDay(const DDateTime& date_time) {
    return date_time.day_is_present;
  }

  inline DDay getDay(const DDateTime& date_time) {
    throwIfNotPresent(date_time.day_is_present, "date_time.day");
    return date_time.day;
  }

  inline uint8_t getDayValue(const DDateTime& date_time) {
    return getDay(date_time).value;
  }

  inline bool hasHour(const DDateTime& date_time) {
    return date_time.hour_is_present;
  }

  inline DHour getHour(const DDateTime& date_time) {
    throwIfNotPresent(date_time.hour_is_present, "date_time.hour");
    return date_time.hour;
  }

  inline uint8_t getHourValue(const DDateTime& date_time) {
    return getHour(date_time).value;
  }

  inline bool hasMinute(const DDateTime& date_time) {
    return date_time.minute_is_present;
  }

  inline DMinute getMinute(const DDateTime& date_time) {
    throwIfNotPresent(date_time.minute_is_present, "date_time.minute");
    return date_time.minute;
  }

  inline uint8_t getMinuteValue(const DDateTime& date_time) {
    return getMinute(date_time).value;
  }

  inline bool hasSecond(const DDateTime& date_time) {
    return date_time.second_is_present;
  }

  inline DSecond getSecond(const DDateTime& date_time) {
    throwIfNotPresent(date_time.second_is_present, "date_time.second");
    return date_time.second;
  }

  inline double getSecondValue(const DDateTime& date_time) {
    return static_cast<double>(getSecond(date_time).value) * 1e-3;
  }

  inline bool hasOffset(const DDateTime& date_time) {
    return date_time.offset_is_present;
  }

  inline DOffset getOffset(const DDateTime& date_time) {
    throwIfNotPresent(date_time.offset_is_present, "date_time.offset");
    return date_time.offset;
  }

  inline int16_t getOffsetValue(const DDateTime& date_time) {
    return getOffset(date_time).value;
  }
 
} // namespace access
 
} // namespace etsi_its_rtcmem_ts_msgs