rtcmem_ts_setters.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 <cmath>
#include <vector>
 
namespace etsi_its_rtcmem_ts_msgs {
 
namespace access {
 
#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
#include <etsi_its_msgs_utils/impl/checks.h>


  inline void setProtocolVersion(ItsPduHeader& header, const uint8_t value) {
    throwIfOutOfRange(value, ItsPduHeader::PROTOCOL_VERSION_MIN, ItsPduHeader::PROTOCOL_VERSION_MAX,
                      "ItsPduHeader.protocol_version");
    header.protocol_version = value;
  }

  inline void setMessageID(ItsPduHeader& header, const uint8_t value) {
    throwIfOutOfRange(value, ItsPduHeader::MESSAGE_ID_MIN, ItsPduHeader::MESSAGE_ID_MAX,
                      "ItsPduHeader.message_id");
    header.message_id = value;
  }

  inline void setMessageIDToRTCMEM(ItsPduHeader& header) {
    header.message_id = ItsPduHeader::MESSAGE_ID_RTCMEM;
  }

  inline void setStationID(StationID& station_id, const uint32_t value) {
    throwIfOutOfRange(value, StationID::MIN, StationID::MAX, "StationID");
    station_id.value = value;
  }

  inline void setStationID(ItsPduHeader& header, const uint32_t value) {
    setStationID(header.station_id, value);
  }

  inline void setHeader(RTCMEM& rtcmem, const ItsPduHeader& header) {
    rtcmem.header = header;
  }

  inline void setProtocolVersion(RTCMEM& rtcmem, const uint8_t value) {
    setProtocolVersion(rtcmem.header, value);
  }

  inline void setMessageID(RTCMEM& rtcmem, const uint8_t value) {
    setMessageID(rtcmem.header, value);
  }

  inline void setMessageIDToRTCMEM(RTCMEM& rtcmem) {
    setMessageIDToRTCMEM(rtcmem.header);
  }

  inline void setStationID(RTCMEM& rtcmem, const uint32_t value) {
    setStationID(rtcmem.header, value);
  }

  inline void setRTCMcorrections(RTCMEM& rtcmem, const RTCMcorrections& rtcm) {
    rtcmem.rtcmc = rtcm;
  }

  inline void setMsgCount(MsgCount& msg_cnt, const uint8_t value) {
    throwIfOutOfRange(value, MsgCount::MIN, MsgCount::MAX, "MsgCount");
    msg_cnt.value = value;
  }

  inline void setMsgCount(RTCMcorrections& rtcm, const uint8_t value) {
    setMsgCount(rtcm.msg_cnt, value);
  }

  inline void setMsgCount(RTCMEM& rtcmem, const uint8_t value) {
    setMsgCount(rtcmem.rtcmc, value);
  }

  inline void setRTCMRevision(RTCMRevision& rev, const uint8_t value) {
    throwIfOutOfRange(value, RTCMRevision::UNKNOWN, RTCMRevision::RESERVED, "RTCMRevision");
    rev.value = value;
  }

  inline void setRTCMRevision(RTCMcorrections& rtcm, const uint8_t value) {
    setRTCMRevision(rtcm.rev, value);
  }

  inline void setRTCMRevision(RTCMEM& rtcmem, const uint8_t value) {
    setRTCMRevision(rtcmem.rtcmc, value);
  }

  inline void setMinuteOfTheYear(MinuteOfTheYear& moy, const uint32_t value) {
    throwIfOutOfRange(value, MinuteOfTheYear::MIN, MinuteOfTheYear::MAX, "MinuteOfTheYear");
    moy.value = value;
  }

  inline void setMinuteOfTheYear(RTCMcorrections& rtcm, const uint32_t value) {
    setMinuteOfTheYear(rtcm.time_stamp, value);
    rtcm.time_stamp_is_present = true;
  }

  inline void setMinuteOfTheYear(RTCMEM& rtcmem, const uint32_t value) {
    setMinuteOfTheYear(rtcmem.rtcmc, value);
  }

  inline void clearMinuteOfTheYear(RTCMcorrections& rtcm) {
    rtcm.time_stamp_is_present = false;
  }

  inline void clearMinuteOfTheYear(RTCMEM& rtcmem) {
    clearMinuteOfTheYear(rtcmem.rtcmc);
  }

  inline void setAnchorPoint(RTCMcorrections& rtcm, const FullPositionVector& anchor) {
    rtcm.anchor_point = anchor;
    rtcm.anchor_point_is_present = true;
  }

  inline void setAnchorPoint(RTCMEM& rtcmem, const FullPositionVector& anchor) {
    setAnchorPoint(rtcmem.rtcmc, anchor);
  }

  inline void clearAnchorPoint(RTCMcorrections& rtcm) {
    rtcm.anchor_point_is_present = false;
  }

  inline void clearAnchorPoint(RTCMEM& rtcmem) {
    clearAnchorPoint(rtcmem.rtcmc);
  }

  inline void setRTCMHeader(RTCMcorrections& rtcm, const RTCMheader& header) {
    rtcm.rtcm_header = header;
    rtcm.rtcm_header_is_present = true;
  }

  inline void setRTCMHeader(RTCMEM& rtcmem, const RTCMheader& header) {
    setRTCMHeader(rtcmem.rtcmc, header);
  }

  inline void clearRTCMHeader(RTCMcorrections& rtcm) {
    rtcm.rtcm_header_is_present = false;
  }

  inline void clearRTCMHeader(RTCMEM& rtcmem) {
    clearRTCMHeader(rtcmem.rtcmc);
  }

  inline void setRTCMmessageValue(RTCMmessage& msg, const std::vector<uint8_t>& data) {
    throwIfOutOfRange(data.size(),
                      static_cast<std::size_t>(RTCMmessage::MIN_SIZE),
                      static_cast<std::size_t>(RTCMmessage::MAX_SIZE),
                      "RTCMmessage length");
    msg.value = data;
  }

  inline void setRTCMmessageData(RTCMmessage& msg, const std::vector<uint8_t>& data) {
    setRTCMmessageValue(msg, data);
  }

  inline void setRTCMmessageList(RTCMmessageList& msgs, const std::vector<RTCMmessage>& values) {
    throwIfOutOfRange(values.size(),
                      static_cast<std::size_t>(RTCMmessageList::MIN_SIZE),
                      static_cast<std::size_t>(RTCMmessageList::MAX_SIZE),
                      "RTCMmessageList size");
    msgs.array = values;
  }

  inline void setRTCMmessageList(RTCMcorrections& rtcm, const std::vector<RTCMmessage>& values) {
    setRTCMmessageList(rtcm.msgs, values);
  }

  inline void setRTCMmessageList(RTCMEM& rtcmem, const std::vector<RTCMmessage>& values) {
    setRTCMmessageList(rtcmem.rtcmc, values);
  }

  inline RTCMmessage& addRTCMmessage(RTCMmessageList& msgs) {
    throwIfOutOfRange(msgs.array.size() + 1,
                      static_cast<std::size_t>(RTCMmessageList::MIN_SIZE),
                      static_cast<std::size_t>(RTCMmessageList::MAX_SIZE),
                      "RTCMmessageList size");
    msgs.array.emplace_back();
    return msgs.array.back();
  }

  inline RTCMmessage& addRTCMmessage(RTCMcorrections& rtcm) {
    return addRTCMmessage(rtcm.msgs);
  }

  inline RTCMmessage& addRTCMmessage(RTCMEM& rtcmem) {
    return addRTCMmessage(rtcmem.rtcmc);
  }

  inline RTCMmessage& addRTCMmessage(RTCMmessageList& msgs, const std::vector<uint8_t>& data) {
    RTCMmessage& msg = addRTCMmessage(msgs);
    setRTCMmessageValue(msg, data);
    return msg;
  }

  inline RTCMmessage& addRTCMmessage(RTCMcorrections& rtcm, const std::vector<uint8_t>& data) {
    return addRTCMmessage(rtcm.msgs, data);
  }

  inline RTCMmessage& addRTCMmessage(RTCMEM& rtcmem, const std::vector<uint8_t>& data) {
    return addRTCMmessage(rtcmem.rtcmc, data);
  }

  inline void clearRTCMmessages(RTCMmessageList& msgs) {
    msgs.array.clear();
  }

  inline void clearRTCMmessages(RTCMcorrections& rtcm) {
    clearRTCMmessages(rtcm.msgs);
  }

  inline void clearRTCMmessages(RTCMEM& rtcmem) {
    clearRTCMmessages(rtcmem.rtcmc);
  }

  inline void setGNSSstatus(RTCMheader& header, const GNSSstatus& status) {
    header.status = status;
  }

  inline void setGNSSstatus(RTCMheader& header, const std::vector<bool>& status_bits) {
    setBitString(header.status, status_bits);
  }

  inline void setAntennaOffsetSet(RTCMheader& header, const AntennaOffsetSet& offset_set) {
    header.offset_set = offset_set;
  }

  inline void ensureGNSSstatusStorage(GNSSstatus& status) {
    if (status.value.size() < 1) {
      status.value.resize(1, 0u);
      status.bits_unused = 0;
    }
  }

  inline void setGNSSstatusBit(GNSSstatus& status, const uint8_t bit_index, const bool value) {
    throwIfOutOfRange(bit_index, static_cast<uint8_t>(0), static_cast<uint8_t>(GNSSstatus::SIZE_BITS - 1), "GNSSstatus bit index");
 
    ensureGNSSstatusStorage(status);
    const uint8_t mask = static_cast<uint8_t>(1u << bit_index);
 
    if (value) {
      status.value[0] = static_cast<uint8_t>(status.value[0] | mask);
    } else {
      status.value[0] = static_cast<uint8_t>(status.value[0] & ~mask);
    }
  }

  inline void setUnavailableFlag(GNSSstatus& status, const bool value) {
    setGNSSstatusBit(status, GNSSstatus::BIT_INDEX_UNAVAILABLE, value);
  }

  inline void setIsHealthyFlag(GNSSstatus& status, const bool value) {
    setGNSSstatusBit(status, GNSSstatus::BIT_INDEX_IS_HEALTHY, value);
  }

  inline void setIsMonitoredFlag(GNSSstatus& status, const bool value) {
    setGNSSstatusBit(status, GNSSstatus::BIT_INDEX_IS_MONITORED, value);
  }

  inline void setBaseStationTypeFlag(GNSSstatus& status, const bool value) {
    setGNSSstatusBit(status, GNSSstatus::BIT_INDEX_BASE_STATION_TYPE, value);
  }

  inline void setAPDOPofUnder5Flag(GNSSstatus& status, const bool value) {
    setGNSSstatusBit(status, GNSSstatus::BIT_INDEX_A_PDO_POF_UNDER5, value);
  }

  inline void setInViewOfUnder5Flag(GNSSstatus& status, const bool value) {
    setGNSSstatusBit(status, GNSSstatus::BIT_INDEX_IN_VIEW_OF_UNDER5, value);
  }

  inline void setLocalCorrectionsPresentFlag(GNSSstatus& status, const bool value) {
    setGNSSstatusBit(status, GNSSstatus::BIT_INDEX_LOCAL_CORRECTIONS_PRESENT, value);
  }

  inline void setNetworkCorrectionsPresentFlag(GNSSstatus& status, const bool value) {
    setGNSSstatusBit(status, GNSSstatus::BIT_INDEX_NETWORK_CORRECTIONS_PRESENT, value);
  }

  inline void setAntennaOffsetX(OffsetB12& field, const int16_t value) {
    throwIfOutOfRange(value, OffsetB12::MIN, OffsetB12::MAX, "OffsetB12");
    field.value = value;
  }

  inline void setAntennaOffsetY(OffsetB09& field, const int16_t value) {
    throwIfOutOfRange(value, OffsetB09::MIN, OffsetB09::MAX, "OffsetB09");
    field.value = value;
  }

  inline void setAntennaOffsetZ(OffsetB10& field, const int16_t value) {
    throwIfOutOfRange(value, OffsetB10::MIN, OffsetB10::MAX, "OffsetB10");
    field.value = value;
  }

  inline void setAntennaOffsetX(AntennaOffsetSet& offset, const int16_t value) {
    setAntennaOffsetX(offset.ant_offset_x, value);
  }

  inline void setAntennaOffsetY(AntennaOffsetSet& offset, const int16_t value) {
    setAntennaOffsetY(offset.ant_offset_y, value);
  }

  inline void setAntennaOffsetZ(AntennaOffsetSet& offset, const int16_t value) {
    setAntennaOffsetZ(offset.ant_offset_z, value);
  }

  inline void setLongitude(Longitude& longitude, const int32_t value) {
    throwIfOutOfRange(value, Longitude::MIN, Longitude::MAX, "Longitude");
    longitude.value = value;
  }

  inline void setLongitude(Longitude& longitude, const double value) {
    int64_t longitude_value = static_cast<int64_t>(std::round(value * 1e7));
    throwIfOutOfRange(longitude_value, Longitude::MIN, Longitude::MAX, "Longitude");
    longitude.value = longitude_value;
  }

  inline void setLatitude(Latitude& latitude, const int32_t value) {
    throwIfOutOfRange(value, Latitude::MIN, Latitude::MAX, "Latitude");
    latitude.value = value;
  }

  inline void setLatitude(Latitude& latitude, const double value) {
    int64_t latitude_value = static_cast<int64_t>(std::round(value * 1e7));
    throwIfOutOfRange(latitude_value, Latitude::MIN, Latitude::MAX, "Latitude");
    latitude.value = latitude_value;
  }

  inline void setElevation(Elevation& elevation, const int32_t value) {
    throwIfOutOfRange(value, Elevation::MIN, Elevation::MAX, "Elevation");
    elevation.value = value;
  }

  inline void setElevation(Elevation& elevation, const double value) {
    int64_t elevation_value = static_cast<int64_t>(std::round(value * 1e1));
    throwIfOutOfRange(elevation_value, Elevation::MIN, Elevation::MAX, "Elevation");
    elevation.value = elevation_value;
  }

  inline void setHeading(HeadingDSRC& heading, const uint16_t value) {
    throwIfOutOfRange(value, HeadingDSRC::MIN, HeadingDSRC::MAX, "HeadingDSRC");
    heading.value = value;
  }

  inline void setUTCTime(FullPositionVector& pos, const DDateTime& utc_time) {
    pos.utc_time = utc_time;
    pos.utc_time_is_present = true;
  }

  inline void clearUTCTime(FullPositionVector& pos) {
    pos.utc_time_is_present = false;
  }

  inline void setLongitude(FullPositionVector& pos, const int32_t value) {
    setLongitude(pos.lon, value);
  }

  inline void setLongitude(FullPositionVector& pos, const double value) {
    setLongitude(pos.lon, value);
  }

  inline void setLatitude(FullPositionVector& pos, const int32_t value) {
    setLatitude(pos.lat, value);
  }

  inline void setLatitude(FullPositionVector& pos, const double value) {
    setLatitude(pos.lat, value);
  }

  inline void setElevation(FullPositionVector& pos, const Elevation& elevation) {
    pos.elevation = elevation;
    pos.elevation_is_present = true;
  }

  inline void setElevation(FullPositionVector& pos, const int32_t value) {
    setElevation(pos.elevation, value);
    pos.elevation_is_present = true;
  }

  inline void setElevation(FullPositionVector& pos, const double value) {
    setElevation(pos.elevation, value);
    pos.elevation_is_present = true;
  }

  inline void clearElevation(FullPositionVector& pos) {
    pos.elevation_is_present = false;
  }

  inline void setHeading(FullPositionVector& pos, const HeadingDSRC& heading) {
    pos.heading = heading;
    pos.heading_is_present = true;
  }

  inline void setHeading(FullPositionVector& pos, const uint16_t value) {
    setHeading(pos.heading, value);
    pos.heading_is_present = true;
  }

  inline void clearHeading(FullPositionVector& pos) {
    pos.heading_is_present = false;
  }

  inline void setSpeed(FullPositionVector& pos, const TransmissionAndSpeed& speed) {
    pos.speed = speed;
    pos.speed_is_present = true;
  }

  inline void clearSpeed(FullPositionVector& pos) {
    pos.speed_is_present = false;
  }

  inline void setPositionalAccuracy(FullPositionVector& pos, const PositionalAccuracy& accuracy) {
    pos.pos_accuracy = accuracy;
    pos.pos_accuracy_is_present = true;
  }

  inline void clearPositionalAccuracy(FullPositionVector& pos) {
    pos.pos_accuracy_is_present = false;
  }

  inline void setTimeConfidence(TimeConfidence& time_confidence, const uint8_t value) {
    throwIfOutOfRange(value, TimeConfidence::UNAVAILABLE, TimeConfidence::TIME_000_000_000_01,
                      "TimeConfidence");
    time_confidence.value = value;
  }

  inline void setTimeConfidence(FullPositionVector& pos, const TimeConfidence& time_confidence) {
    pos.time_confidence = time_confidence;
    pos.time_confidence_is_present = true;
  }

  inline void setTimeConfidence(FullPositionVector& pos, const uint8_t value) {
    setTimeConfidence(pos.time_confidence, value);
    pos.time_confidence_is_present = true;
  }

  inline void clearTimeConfidence(FullPositionVector& pos) {
    pos.time_confidence_is_present = false;
  }

  inline void setPositionConfidence(FullPositionVector& pos, const PositionConfidenceSet& confidence) {
    pos.pos_confidence = confidence;
    pos.pos_confidence_is_present = true;
  }

  inline void clearPositionConfidence(FullPositionVector& pos) {
    pos.pos_confidence_is_present = false;
  }

  inline void setSpeedConfidence(FullPositionVector& pos,
                                 const SpeedandHeadingandThrottleConfidence& confidence) {
    pos.speed_confidence = confidence;
    pos.speed_confidence_is_present = true;
  }

  inline void clearSpeedConfidence(FullPositionVector& pos) {
    pos.speed_confidence_is_present = false;
  }

  inline void setTransmissionState(TransmissionState& transmission_state, const uint8_t value) {
    throwIfOutOfRange(value, TransmissionState::NEUTRAL, TransmissionState::UNAVAILABLE, "TransmissionState");
    transmission_state.value = value;
  }

  inline void setTransmissionState(TransmissionAndSpeed& speed, const uint8_t value) {
    setTransmissionState(speed.transmisson, value);
  }

  inline void setVelocity(Velocity& velocity, const uint16_t value) {
    throwIfOutOfRange(value, Velocity::MIN, Velocity::MAX, "Velocity");
    velocity.value = value;
  }

  inline void setVelocity(TransmissionAndSpeed& speed, const uint16_t value) {
    setVelocity(speed.speed, value);
  }

  inline void setTransmissionAndSpeed(TransmissionAndSpeed& speed, const uint8_t transmission_state,
                                      const uint16_t velocity) {
    setTransmissionState(speed, transmission_state);
    setVelocity(speed, velocity);
  }

  inline void setSemiMajorAxisAccuracy(SemiMajorAxisAccuracy& accuracy, const uint8_t value) {
    throwIfOutOfRange(value, SemiMajorAxisAccuracy::MIN, SemiMajorAxisAccuracy::MAX, "SemiMajorAxisAccuracy");
    accuracy.value = value;
  }

  inline void setSemiMajorAxisAccuracy(PositionalAccuracy& accuracy, const uint8_t value) {
    setSemiMajorAxisAccuracy(accuracy.semi_major, value);
  }

  inline void setSemiMinorAxisAccuracy(SemiMinorAxisAccuracy& accuracy, const uint8_t value) {
    throwIfOutOfRange(value, SemiMinorAxisAccuracy::MIN, SemiMinorAxisAccuracy::MAX, "SemiMinorAxisAccuracy");
    accuracy.value = value;
  }

  inline void setSemiMinorAxisAccuracy(PositionalAccuracy& accuracy, const uint8_t value) {
    setSemiMinorAxisAccuracy(accuracy.semi_minor, value);
  }

  inline void setSemiMajorAxisOrientation(SemiMajorAxisOrientation& orientation, const uint16_t value) {
    throwIfOutOfRange(value, SemiMajorAxisOrientation::MIN, SemiMajorAxisOrientation::MAX,
                      "SemiMajorAxisOrientation");
    orientation.value = value;
  }

  inline void setSemiMajorAxisOrientation(PositionalAccuracy& accuracy, const uint16_t value) {
    setSemiMajorAxisOrientation(accuracy.orientation, value);
  }

  inline void setPositionConfidence(PositionConfidence& confidence, const uint8_t value) {
    throwIfOutOfRange(value, PositionConfidence::UNAVAILABLE, PositionConfidence::A1CM, "PositionConfidence");
    confidence.value = value;
  }

  inline void setPositionConfidence(PositionConfidenceSet& confidence, const uint8_t value) {
    setPositionConfidence(confidence.pos, value);
  }

  inline void setElevationConfidence(ElevationConfidence& confidence, const uint8_t value) {
    throwIfOutOfRange(value, ElevationConfidence::UNAVAILABLE, ElevationConfidence::ELEV_000_01,
                      "ElevationConfidence");
    confidence.value = value;
  }

  inline void setElevationConfidence(PositionConfidenceSet& confidence, const uint8_t value) {
    setElevationConfidence(confidence.elevation, value);
  }

  inline void setHeadingConfidence(HeadingConfidenceDSRC& confidence, const uint8_t value) {
    throwIfOutOfRange(value, HeadingConfidenceDSRC::UNAVAILABLE, HeadingConfidenceDSRC::PREC0_0125DEG,
                      "HeadingConfidenceDSRC");
    confidence.value = value;
  }

  inline void setHeadingConfidence(SpeedandHeadingandThrottleConfidence& confidence, const uint8_t value) {
    setHeadingConfidence(confidence.heading, value);
  }

  inline void setSpeedConfidence(SpeedConfidenceDSRC& confidence, const uint8_t value) {
    throwIfOutOfRange(value, SpeedConfidenceDSRC::UNAVAILABLE, SpeedConfidenceDSRC::PREC0_01MS,
                      "SpeedConfidenceDSRC");
    confidence.value = value;
  }

  inline void setSpeedConfidence(SpeedandHeadingandThrottleConfidence& confidence, const uint8_t value) {
    setSpeedConfidence(confidence.speed, value);
  }

  inline void setThrottleConfidence(ThrottleConfidence& confidence, const uint8_t value) {
    throwIfOutOfRange(value, ThrottleConfidence::UNAVAILABLE, ThrottleConfidence::PREC0_5PERCENT,
                      "ThrottleConfidence");
    confidence.value = value;
  }

  inline void setThrottleConfidence(SpeedandHeadingandThrottleConfidence& confidence, const uint8_t value) {
    setThrottleConfidence(confidence.throttle, value);
  }

  inline void setYear(DYear& year, const uint16_t value) {
    throwIfOutOfRange(value, DYear::MIN, DYear::MAX, "DYear");
    year.value = value;
  }

  inline void setYear(DDateTime& date_time, const uint16_t value) {
    setYear(date_time.year, value);
    date_time.year_is_present = true;
  }

  inline void clearYear(DDateTime& date_time) {
    date_time.year_is_present = false;
  }

  inline void setMonth(DMonth& month, const uint8_t value) {
    throwIfOutOfRange(value, DMonth::MIN, DMonth::MAX, "DMonth");
    month.value = value;
  }

  inline void setMonth(DDateTime& date_time, const uint8_t value) {
    setMonth(date_time.month, value);
    date_time.month_is_present = true;
  }

  inline void clearMonth(DDateTime& date_time) {
    date_time.month_is_present = false;
  }

  inline void setDay(DDay& day, const uint8_t value) {
    throwIfOutOfRange(value, DDay::MIN, DDay::MAX, "DDay");
    day.value = value;
  }

  inline void setDay(DDateTime& date_time, const uint8_t value) {
    setDay(date_time.day, value);
    date_time.day_is_present = true;
  }

  inline void clearDay(DDateTime& date_time) {
    date_time.day_is_present = false;
  }

  inline void setHour(DHour& hour, const uint8_t value) {
    throwIfOutOfRange(value, DHour::MIN, DHour::MAX, "DHour");
    hour.value = value;
  }

  inline void setHour(DDateTime& date_time, const uint8_t value) {
    setHour(date_time.hour, value);
    date_time.hour_is_present = true;
  }

  inline void clearHour(DDateTime& date_time) {
    date_time.hour_is_present = false;
  }

  inline void setMinute(DMinute& minute, const uint8_t value) {
    throwIfOutOfRange(value, DMinute::MIN, DMinute::MAX, "DMinute");
    minute.value = value;
  }

  inline void setMinute(DDateTime& date_time, const uint8_t value) {
    setMinute(date_time.minute, value);
    date_time.minute_is_present = true;
  }

  inline void clearMinute(DDateTime& date_time) {
    date_time.minute_is_present = false;
  }

  inline void setSecond(DSecond& second, const uint16_t value) {
    throwIfOutOfRange(value, DSecond::MIN, DSecond::MAX, "DSecond");
    second.value = value;
  }

  inline void setSecond(DSecond& second, const double value) {
    setSecond(second, static_cast<uint16_t>(std::round(value * 1e3)));
  }

  inline void setSecond(DDateTime& date_time, const uint16_t value) {
    setSecond(date_time.second, value);
    date_time.second_is_present = true;
  }

  inline void setSecond(DDateTime& date_time, const double value) {
    setSecond(date_time.second, value);
    date_time.second_is_present = true;
  }

  inline void clearSecond(DDateTime& date_time) {
    date_time.second_is_present = false;
  }

  inline void setOffset(DOffset& offset, const int16_t value) {
    throwIfOutOfRange(value, DOffset::MIN, DOffset::MAX, "DOffset");
    offset.value = value;
  }

  inline void setOffset(DDateTime& date_time, const int16_t value) {
    setOffset(date_time.offset, value);
    date_time.offset_is_present = true;
  }

  inline void clearOffset(DDateTime& date_time) {
    date_time.offset_is_present = false;
  }
 
} // namespace access
 
} // namespace etsi_its_rtcmem_ts_msgs