etsi_its_messages v3.3.0
 
Loading...
Searching...
No Matches
denm_setters.h File Reference

Setter functions for the ETSI ITS DENM (EN) More...

#include <etsi_its_msgs_utils/impl/constants.h>
#include <etsi_its_msgs_utils/impl/checks.h>
#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

Go to the source code of this file.

Classes

struct  etsi_its_denm_msgs::access::etsi_its_msgs::OneCentimeterHelper< SemiAxisLength, typename >
 
struct  etsi_its_denm_msgs::access::etsi_its_msgs::OneCentimeterHelper< SemiAxisLength, std::void_t< decltype(SemiAxisLength::ONE_CENTIMETER)> >
 

Functions

template<typename T1, typename T2>
void etsi_its_denm_msgs::access::throwIfOutOfRange (const T1 &val, const T2 &min, const T2 &max, const std::string val_desc)
 Throws an exception if a given value is out of a defined range.
 
void etsi_its_denm_msgs::access::throwIfNotPresent (const bool is_present, const std::string val_desc)
 Throws an exception if the given value is not present.
 
template<typename T>
void etsi_its_denm_msgs::access::setBitString (T &bitstring, const std::vector< bool > &bits)
 Set a Bit String by a vector of bools.
 
uint16_t etsi_its_denm_msgs::access::etsi_its_msgs::getLeapSecondInsertionsSince2004 (const uint64_t unix_seconds)
 Get the leap second insertions since 2004 for given unix seconds.
 
void etsi_its_denm_msgs::access::setTimestampITS (TimestampIts &timestamp_its, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
 Set the TimestampITS object.
 
void etsi_its_denm_msgs::access::setLatitude (Latitude &latitude, const double deg)
 Set the Latitude object.
 
void etsi_its_denm_msgs::access::setLongitude (Longitude &longitude, const double deg)
 Set the Longitude object.
 
void etsi_its_denm_msgs::access::setAltitudeValue (AltitudeValue &altitude, const double value)
 Set the AltitudeValue object.
 
void etsi_its_denm_msgs::access::setAltitude (Altitude &altitude, const double value)
 Set the Altitude object.
 
void etsi_its_denm_msgs::access::setSpeedValue (SpeedValue &speed, const double value)
 Set the SpeedValue object.
 
void etsi_its_denm_msgs::access::setSpeedConfidence (SpeedConfidence &speed_confidence, const double value)
 Set the Speed Confidence object.
 
void etsi_its_denm_msgs::access::setSpeed (Speed &speed, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the Speed object.
 
template<typename AccelerationMagnitudeValue>
void etsi_its_denm_msgs::access::setAccelerationMagnitudeValue (AccelerationMagnitudeValue &accel_mag_value, const double value)
 Set the Acceleration Magnitude Value object.
 
template<typename AccelerationConfidence>
void etsi_its_denm_msgs::access::setAccelerationMagnitudeConfidence (AccelerationConfidence &accel_mag_confidence, const double value)
 Set the AccelerationMagnitude Confidence object.
 
template<typename AccelerationMagnitude>
void etsi_its_denm_msgs::access::setAccelerationMagnitude (AccelerationMagnitude &accel_mag, const double value, const double confidence=std::numeric_limits< double >::infinity())
 Set the AccelerationMagnitude object.
 
template<typename AccelerationConfidence>
void etsi_its_denm_msgs::access::setAccelerationConfidence (AccelerationConfidence &accel_confidence, const double value)
 Set the Acceleration Confidence object.
 
template<typename T>
void etsi_its_denm_msgs::access::setReferencePosition (T &ref_position, const double latitude, const double longitude, const double altitude=AltitudeValue::UNAVAILABLE)
 Sets the reference position in the given ReferencePostion object.
 
template<typename T>
void etsi_its_denm_msgs::access::setFromUTMPosition (T &reference_position, const gm::PointStamped &utm_position, const int zone, const bool northp)
 Set the ReferencePosition from a given UTM-Position.
 
template<typename HeadingValue>
void etsi_its_denm_msgs::access::setHeadingValue (HeadingValue &heading, const double value)
 Set the HeadingValue object.
 
template<typename HeadingConfidence>
void etsi_its_denm_msgs::access::setHeadingConfidence (HeadingConfidence &heading_confidence, const double value)
 Set the Heading Confidence object.
 
template<typename Heading, typename HeadingConfidence = decltype(Heading::heading_confidence)>
void etsi_its_denm_msgs::access::setHeadingCDD (Heading &heading, const double value, double confidence=std::numeric_limits< double >::infinity())
 Set the Heading object.
 
template<typename YawRate, typename YawRateValue = decltype(YawRate::yaw_rate_value), typename YawRateConfidence = decltype(YawRate::yaw_rate_confidence)>
void etsi_its_denm_msgs::access::setYawRateCDD (YawRate &yaw_rate, const double value, double confidence=std::numeric_limits< double >::infinity())
 Set the Yaw Rate object.
 
template<typename SemiAxisLength>
void etsi_its_denm_msgs::access::setSemiAxis (SemiAxisLength &semi_axis_length, const double length)
 Set the Semi Axis length.
 
template<typename PosConfidenceEllipse>
void etsi_its_denm_msgs::access::setPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const double semi_major_axis, const double semi_minor_axis, const double orientation)
 Set the Pos Confidence Ellipse object.
 
std::tuple< double, double, double > etsi_its_denm_msgs::access::confidenceEllipseFromCovMatrix (const std::array< double, 4 > &covariance_matrix, const double object_heading)
 Gets the values needed to set a confidence ellipse from a covariance matrix.
 
std::tuple< double, double, double > etsi_its_denm_msgs::access::confidenceEllipseFromWGSCovMatrix (const std::array< double, 4 > &covariance_matrix)
 Gets the values needed to set a confidence ellipse from a covariance matrix.
 
template<typename PosConfidenceEllipse>
void etsi_its_denm_msgs::access::setPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix, const double object_heading)
 Set the Pos Confidence Ellipse object.
 
template<typename PosConfidenceEllipse>
void etsi_its_denm_msgs::access::setWGSPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix)
 Set the Pos Confidence Ellipse object.
 
void etsi_its_denm_msgs::access::setStationId (StationID &station_id, const uint32_t id_value)
 Set the Station Id object.
 
void etsi_its_denm_msgs::access::setItsPduHeader (ItsPduHeader &header, const uint8_t message_id, const uint32_t station_id, const uint8_t protocol_version=0)
 Set the Its Pdu Header object.
 
void etsi_its_denm_msgs::access::setStationType (StationType &station_type, const uint8_t value)
 Set the Station Type.
 
void etsi_its_denm_msgs::access::setItsPduHeader (DENM &denm, const uint32_t station_id, const uint8_t protocol_version=0)
 Set the ItsPduHeader-object for a DENM.
 
void etsi_its_denm_msgs::access::setReferenceTime (DENM &denm, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
 Set the ReferenceTime-value.
 
void etsi_its_denm_msgs::access::setStationType (DENM &denm, const int value)
 Set the StationType for a DENM.
 
void etsi_its_denm_msgs::access::setReferencePosition (DENM &denm, const double latitude, const double longitude, const double altitude=AltitudeValue::UNAVAILABLE)
 Set the ReferencePositionWithConfidence for a DENM.
 
void etsi_its_denm_msgs::access::setIsHeadingPresent (DENM &denm, bool presence_of_heading)
 Set the IsHeadingPresent object for DENM.
 
void etsi_its_denm_msgs::access::setHeading (DENM &denm, const double heading_val, const double confidence=std::numeric_limits< double >::infinity())
 Set the Heading for a DENM.
 
void etsi_its_denm_msgs::access::setIsSpeedPresent (DENM &denm, bool presence_of_speed)
 Set the IsSpeedPresent object for DENM.
 
void etsi_its_denm_msgs::access::setSpeed (DENM &denm, const double speed_val, const double confidence=std::numeric_limits< double >::infinity())
 Set the vehicle speed.
 
void etsi_its_denm_msgs::access::setFromUTMPosition (DENM &denm, const gm::PointStamped &utm_position, const int &zone, const bool &northp)
 Set the ReferencePosition of a DENM from a given UTM-Position.
 
void etsi_its_denm_msgs::access::setDrivingLaneStatus (DrivingLaneStatus &driving_lane_status, const std::vector< bool > &bits)
 Set the Driving Lane Status by a vector of bools.
 
void etsi_its_denm_msgs::access::setLightBarSirenInUse (LightBarSirenInUse &light_bar_siren_in_use, const std::vector< bool > &bits)
 Set the Lightbar Siren In Use by a vector of bools.
 

Detailed Description

Setter functions for the ETSI ITS DENM (EN)

Definition in file denm_setters.h.

Function Documentation

◆ confidenceEllipseFromCovMatrix()

std::tuple< double, double, double > etsi_its_denm_msgs::access::confidenceEllipseFromCovMatrix ( const std::array< double, 4 > & covariance_matrix,
const double object_heading )
inline

Gets the values needed to set a confidence ellipse from a covariance matrix.

Parameters
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the object (x = longitudinal, y = lateral)
object_headingThe heading of the object in rad, with respect to WGS84
Returns
std::tuple<double, double, double> semi_major_axis [m], semi_minor_axis [m], orientation [deg], with respect to WGS84

Definition at line 467 of file denm_setters.h.

◆ confidenceEllipseFromWGSCovMatrix()

std::tuple< double, double, double > etsi_its_denm_msgs::access::confidenceEllipseFromWGSCovMatrix ( const std::array< double, 4 > & covariance_matrix)
inline

Gets the values needed to set a confidence ellipse from a covariance matrix.

Parameters
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the WGS axes (x = North, y = East)
object_headingThe heading of the object in rad, with respect to WGS84
Returns
std::tuple<double, double, double> semi_major_axis [m], semi_minor_axis [m], orientation [deg], with respect to WGS84

Definition at line 508 of file denm_setters.h.

556inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
557 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
558}
559
567inline void setReferenceTime(
568 DENM& denm, const uint64_t unix_nanosecs,
569 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
570 TimestampIts t_its;
571 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
572 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
573 denm.denm.management.reference_time = t_its;
574}
575
582inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
583
595inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
596 const double altitude = AltitudeValue::UNAVAILABLE) {
597 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
598}
599
606inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
607 if (denm.denm.location_is_present) {
608 denm.denm.location.event_position_heading_is_present = presence_of_heading;
609 } else {
610 throw std::invalid_argument("LocationContainer is not present!");
611 }
612}
613
624inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
625 if (denm.denm.location_is_present) {
626 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
627 setIsHeadingPresent(denm, true);
628 } else {
629 throw std::invalid_argument("LocationContainer is not present!");
630 }
631}
632
639inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
640 if (denm.denm.location_is_present) {
641 denm.denm.location.event_speed_is_present = presence_of_speed;
642 } else {
643 throw std::invalid_argument("LocationContainer is not present!");
644 }
645}
646
654inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
655 if (denm.denm.location_is_present) {
656 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
657 setIsSpeedPresent(denm, true);
658 } else {
659 throw std::invalid_argument("LocationContainer is not present!");
660 }
661}
662
675inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
676 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
677}
678
685inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
686 setBitString(driving_lane_status, bits);
687}
688
695inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
696 setBitString(light_bar_siren_in_use, bits);
697}
698
699} // namespace etsi_its_denm_msgs::access
void setStationType(CAM &cam, const uint8_t value)
Set the StationType for a CAM.
void setTimestampITS(TimestampIts &timestamp_its, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
Set the TimestampITS object.
Setter functions for the ETSI ITS Common Data Dictionary (CDD) v1.3.1.
Sanity-check functions etc.
void throwIfOutOfRange(const T1 &val, const T2 &min, const T2 &max, const std::string val_desc)
Throws an exception if a given value is out of a defined range.
Definition checks.h:46
const std::map< uint64_t, uint16_t > LEAP_SECOND_INSERTIONS_SINCE_2004
std::map that stores all leap second insertions since 2004 with the corresponding unix-date of the in...
Definition constants.h:45
void setReferencePosition(T &ref_position, const double latitude, const double longitude, const double altitude=AltitudeValue::UNAVAILABLE)
Sets the reference position in the given ReferencePostion object.
void setHeading(DENM &denm, const double heading_val, const double confidence=std::numeric_limits< double >::infinity())
Set the Heading for a DENM.
void setDrivingLaneStatus(DrivingLaneStatus &driving_lane_status, const std::vector< bool > &bits)
Set the Driving Lane Status by a vector of bools.
void setIsSpeedPresent(DENM &denm, bool presence_of_speed)
Set the IsSpeedPresent object for DENM.
void setHeadingCDD(Heading &heading, const double value, double confidence=std::numeric_limits< double >::infinity())
Set the Heading object.
void setFromUTMPosition(T &reference_position, const gm::PointStamped &utm_position, const int zone, const bool northp)
Set the ReferencePosition from a given UTM-Position.
void setIsHeadingPresent(DENM &denm, bool presence_of_heading)
Set the IsHeadingPresent object for DENM.
void setLightBarSirenInUse(LightBarSirenInUse &light_bar_siren_in_use, const std::vector< bool > &bits)
Set the Lightbar Siren In Use by a vector of bools.
void setSpeed(Speed &speed, const double value, const double confidence=std::numeric_limits< double >::infinity())
Set the Speed object.
void setBitString(T &bitstring, const std::vector< bool > &bits)
Set a Bit String by a vector of bools.
void setItsPduHeader(ItsPduHeader &header, const uint8_t message_id, const uint32_t station_id, const uint8_t protocol_version=0)
Set the Its Pdu Header object.

◆ getLeapSecondInsertionsSince2004()

uint16_t etsi_its_denm_msgs::access::etsi_its_msgs::getLeapSecondInsertionsSince2004 ( const uint64_t unix_seconds)
inline

Get the leap second insertions since 2004 for given unix seconds.

Parameters
unix_secondsthe current unix seconds for that the leap second insertions since 2004 shall be provided
Returns
uint16_t the number of leap second insertions since 2004 for unix_seconds

Definition at line 61 of file denm_access.h.

114 {
116}
Utility functions for the ETSI ITS DENM (EN)

◆ setAccelerationConfidence()

template<typename AccelerationConfidence>
void etsi_its_denm_msgs::access::setAccelerationConfidence ( AccelerationConfidence & accel_confidence,
const double value )
inline

Set the Acceleration Confidence object.

Parameters
accel_confidenceobject to set
valuestandard deviation in m/s^2 as decimal number

Definition at line 266 of file denm_setters.h.

301 {
302
304#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
306
314inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
315 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
316}
317
325inline void setReferenceTime(
326 DENM& denm, const uint64_t unix_nanosecs,
327 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
328 TimestampIts t_its;
329 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
330 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
331 denm.denm.management.reference_time = t_its;
332}
333
340inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
341
353inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
354 const double altitude = AltitudeValue::UNAVAILABLE) {
355 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
356}
357
364inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
365 if (denm.denm.location_is_present) {
366 denm.denm.location.event_position_heading_is_present = presence_of_heading;
367 } else {
368 throw std::invalid_argument("LocationContainer is not present!");
369 }
370}
371
382inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
383 if (denm.denm.location_is_present) {
384 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
385 setIsHeadingPresent(denm, true);
386 } else {
387 throw std::invalid_argument("LocationContainer is not present!");
388 }
389}
390
397inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
398 if (denm.denm.location_is_present) {
399 denm.denm.location.event_speed_is_present = presence_of_speed;
400 } else {
401 throw std::invalid_argument("LocationContainer is not present!");
402 }
403}
404
412inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
413 if (denm.denm.location_is_present) {
414 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
415 setIsSpeedPresent(denm, true);
416 } else {
417 throw std::invalid_argument("LocationContainer is not present!");
418 }
419}
420
433inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
434 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
435}
436
443inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
444 setBitString(driving_lane_status, bits);
445}
446
453inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
454 setBitString(light_bar_siren_in_use, bits);
455}
456
457} // namespace etsi_its_denm_msgs::access

◆ setAccelerationMagnitude()

template<typename AccelerationMagnitude>
void etsi_its_denm_msgs::access::setAccelerationMagnitude ( AccelerationMagnitude & accel_mag,
const double value,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the AccelerationMagnitude object.

AccelerationConfidence is set to UNAVAILABLE

Parameters
accel_magobject to set
valueAccelerationMagnitudeValue in m/s^2 as decimal number
confidencestandard deviation in m/s^2 as decimal number (default: infinity, mapping to AccelerationConfidence::UNAVAILABLE)

Definition at line 253 of file denm_setters.h.

288 {
289
291#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
293
301inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
302 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
303}
304
312inline void setReferenceTime(
313 DENM& denm, const uint64_t unix_nanosecs,
314 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
315 TimestampIts t_its;
316 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
317 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
318 denm.denm.management.reference_time = t_its;
319}
320
327inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
328
340inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
341 const double altitude = AltitudeValue::UNAVAILABLE) {
342 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
343}
344
351inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
352 if (denm.denm.location_is_present) {
353 denm.denm.location.event_position_heading_is_present = presence_of_heading;
354 } else {
355 throw std::invalid_argument("LocationContainer is not present!");
356 }
357}
358
369inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
370 if (denm.denm.location_is_present) {
371 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
372 setIsHeadingPresent(denm, true);
373 } else {
374 throw std::invalid_argument("LocationContainer is not present!");
375 }
376}
377
384inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
385 if (denm.denm.location_is_present) {
386 denm.denm.location.event_speed_is_present = presence_of_speed;
387 } else {
388 throw std::invalid_argument("LocationContainer is not present!");
389 }
390}
391
399inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
400 if (denm.denm.location_is_present) {
401 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
402 setIsSpeedPresent(denm, true);
403 } else {
404 throw std::invalid_argument("LocationContainer is not present!");
405 }
406}
407
420inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
421 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
422}
423
430inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
431 setBitString(driving_lane_status, bits);
432}
433
440inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
441 setBitString(light_bar_siren_in_use, bits);
442}
443
444} // namespace etsi_its_denm_msgs::access

◆ setAccelerationMagnitudeConfidence()

template<typename AccelerationConfidence>
void etsi_its_denm_msgs::access::setAccelerationMagnitudeConfidence ( AccelerationConfidence & accel_mag_confidence,
const double value )
inline

Set the AccelerationMagnitude Confidence object.

Parameters
accel_mag_confidenceobject to set
valuestandard deviation in m/s^2 as decimal number

Definition at line 233 of file denm_setters.h.

268 {
269
271#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
273
281inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
282 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
283}
284
292inline void setReferenceTime(
293 DENM& denm, const uint64_t unix_nanosecs,
294 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
295 TimestampIts t_its;
296 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
297 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
298 denm.denm.management.reference_time = t_its;
299}
300
307inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
308
320inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
321 const double altitude = AltitudeValue::UNAVAILABLE) {
322 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
323}
324
331inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
332 if (denm.denm.location_is_present) {
333 denm.denm.location.event_position_heading_is_present = presence_of_heading;
334 } else {
335 throw std::invalid_argument("LocationContainer is not present!");
336 }
337}
338
349inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
350 if (denm.denm.location_is_present) {
351 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
352 setIsHeadingPresent(denm, true);
353 } else {
354 throw std::invalid_argument("LocationContainer is not present!");
355 }
356}
357
364inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
365 if (denm.denm.location_is_present) {
366 denm.denm.location.event_speed_is_present = presence_of_speed;
367 } else {
368 throw std::invalid_argument("LocationContainer is not present!");
369 }
370}
371
379inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
380 if (denm.denm.location_is_present) {
381 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
382 setIsSpeedPresent(denm, true);
383 } else {
384 throw std::invalid_argument("LocationContainer is not present!");
385 }
386}
387
400inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
401 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
402}
403
410inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
411 setBitString(driving_lane_status, bits);
412}
413
420inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
421 setBitString(light_bar_siren_in_use, bits);
422}
423
424} // namespace etsi_its_denm_msgs::access

◆ setAccelerationMagnitudeValue()

template<typename AccelerationMagnitudeValue>
void etsi_its_denm_msgs::access::setAccelerationMagnitudeValue ( AccelerationMagnitudeValue & accel_mag_value,
const double value )
inline

Set the Acceleration Magnitude Value object.

Parameters
accel_mag_valueobject to set
valueAccelerationMagnitudeValue in m/s^2 as decimal number

Definition at line 220 of file denm_setters.h.

255 {
256
258#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
260
268inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
269 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
270}
271
279inline void setReferenceTime(
280 DENM& denm, const uint64_t unix_nanosecs,
281 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
282 TimestampIts t_its;
283 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
284 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
285 denm.denm.management.reference_time = t_its;
286}
287
294inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
295
307inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
308 const double altitude = AltitudeValue::UNAVAILABLE) {
309 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
310}
311
318inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
319 if (denm.denm.location_is_present) {
320 denm.denm.location.event_position_heading_is_present = presence_of_heading;
321 } else {
322 throw std::invalid_argument("LocationContainer is not present!");
323 }
324}
325
336inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
337 if (denm.denm.location_is_present) {
338 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
339 setIsHeadingPresent(denm, true);
340 } else {
341 throw std::invalid_argument("LocationContainer is not present!");
342 }
343}
344
351inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
352 if (denm.denm.location_is_present) {
353 denm.denm.location.event_speed_is_present = presence_of_speed;
354 } else {
355 throw std::invalid_argument("LocationContainer is not present!");
356 }
357}
358
366inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
367 if (denm.denm.location_is_present) {
368 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
369 setIsSpeedPresent(denm, true);
370 } else {
371 throw std::invalid_argument("LocationContainer is not present!");
372 }
373}
374
387inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
388 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
389}
390
397inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
398 setBitString(driving_lane_status, bits);
399}
400
407inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
408 setBitString(light_bar_siren_in_use, bits);
409}
410
411} // namespace etsi_its_denm_msgs::access

◆ setAltitude()

void etsi_its_denm_msgs::access::setAltitude ( Altitude & altitude,
const double value )
inline

Set the Altitude object.

AltitudeConfidence is set to UNAVAILABLE

Parameters
altitudeobject to set
valueAltitude value (above the reference ellipsoid surface) in meter as decimal number

Definition at line 166 of file denm_setters.h.

168 {
169 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);

◆ setAltitudeValue()

void etsi_its_denm_msgs::access::setAltitudeValue ( AltitudeValue & altitude,
const double value )
inline

Set the AltitudeValue object.

Parameters
altitudeobject to set
valueAltitudeValue value (above the reference ellipsoid surface) in meter as decimal number

Definition at line 147 of file denm_setters.h.

147 {
148 if (denm.denm.location_is_present) {
149 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
150 setIsSpeedPresent(denm, true);
151 } else {
152 throw std::invalid_argument("LocationContainer is not present!");
153 }
154}
155

◆ setBitString()

template<typename T>
void etsi_its_denm_msgs::access::setBitString ( T & bitstring,
const std::vector< bool > & bits )
inline

Set a Bit String by a vector of bools.

Template Parameters
T
Parameters
bitstringBitString to set
bitsvector of bools

Definition at line 44 of file denm_setters.h.

60inline void setReferenceTime(
61 DENM& denm, const uint64_t unix_nanosecs,
62 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
63 TimestampIts t_its;
64 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
65 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
66 denm.denm.management.reference_time = t_its;
67}
68

◆ setDrivingLaneStatus()

void etsi_its_denm_msgs::access::setDrivingLaneStatus ( DrivingLaneStatus & driving_lane_status,
const std::vector< bool > & bits )
inline

Set the Driving Lane Status by a vector of bools.

Parameters
driving_lane_status
bits

Definition at line 244 of file denm_setters.h.

292inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
293 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
294}
295
303inline void setReferenceTime(
304 DENM& denm, const uint64_t unix_nanosecs,
305 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
306 TimestampIts t_its;
307 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
308 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
309 denm.denm.management.reference_time = t_its;
310}
311
318inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
319
331inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
332 const double altitude = AltitudeValue::UNAVAILABLE) {
333 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
334}
335
342inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
343 if (denm.denm.location_is_present) {
344 denm.denm.location.event_position_heading_is_present = presence_of_heading;
345 } else {
346 throw std::invalid_argument("LocationContainer is not present!");
347 }
348}
349
360inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
361 if (denm.denm.location_is_present) {
362 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
363 setIsHeadingPresent(denm, true);
364 } else {
365 throw std::invalid_argument("LocationContainer is not present!");
366 }
367}
368
375inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
376 if (denm.denm.location_is_present) {
377 denm.denm.location.event_speed_is_present = presence_of_speed;
378 } else {
379 throw std::invalid_argument("LocationContainer is not present!");
380 }
381}
382
390inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
391 if (denm.denm.location_is_present) {
392 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
393 setIsSpeedPresent(denm, true);
394 } else {
395 throw std::invalid_argument("LocationContainer is not present!");
396 }
397}
398
411inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
412 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
413}
414
421inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
422 setBitString(driving_lane_status, bits);
423}
424
431inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
432 setBitString(light_bar_siren_in_use, bits);
433}
434
435} // namespace etsi_its_denm_msgs::access

◆ setFromUTMPosition() [1/2]

void etsi_its_denm_msgs::access::setFromUTMPosition ( DENM & denm,
const gm::PointStamped & utm_position,
const int & zone,
const bool & northp )
inline

Set the ReferencePosition of a DENM from a given UTM-Position.

The position is transformed to latitude and longitude by using GeographicLib::UTMUPS The z-Coordinate is directly used as altitude value The frame_id of the given utm_position must be set to 'utm_<zone><N/S>'

Parameters
[out]denmDENM for which to set the ReferencePosition
[in]utm_positiongeometry_msgs::PointStamped describing the given utm position
[in]zonethe UTM zone (zero means UPS) of the given position
[in]northphemisphere (true means north, false means south)

Definition at line 234 of file denm_setters.h.

269 {
270
272#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
274
282inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
283 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
284}
285
293inline void setReferenceTime(
294 DENM& denm, const uint64_t unix_nanosecs,
295 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
296 TimestampIts t_its;
297 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
298 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
299 denm.denm.management.reference_time = t_its;
300}
301
308inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
309
321inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
322 const double altitude = AltitudeValue::UNAVAILABLE) {
323 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
324}
325
332inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
333 if (denm.denm.location_is_present) {
334 denm.denm.location.event_position_heading_is_present = presence_of_heading;
335 } else {
336 throw std::invalid_argument("LocationContainer is not present!");
337 }
338}
339
350inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
351 if (denm.denm.location_is_present) {
352 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
353 setIsHeadingPresent(denm, true);
354 } else {
355 throw std::invalid_argument("LocationContainer is not present!");
356 }
357}
358
365inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
366 if (denm.denm.location_is_present) {
367 denm.denm.location.event_speed_is_present = presence_of_speed;
368 } else {
369 throw std::invalid_argument("LocationContainer is not present!");
370 }
371}
372
380inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
381 if (denm.denm.location_is_present) {
382 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
383 setIsSpeedPresent(denm, true);
384 } else {
385 throw std::invalid_argument("LocationContainer is not present!");
386 }
387}
388
401inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
402 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
403}
404
411inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
412 setBitString(driving_lane_status, bits);
413}
414
421inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
422 setBitString(light_bar_siren_in_use, bits);
423}
424
425} // namespace etsi_its_denm_msgs::access

◆ setFromUTMPosition() [2/2]

template<typename T>
void etsi_its_denm_msgs::access::setFromUTMPosition ( T & reference_position,
const gm::PointStamped & utm_position,
const int zone,
const bool northp )
inline

Set the ReferencePosition from a given UTM-Position.

The position is transformed to latitude and longitude by using GeographicLib::UTMUPS The z-Coordinate is directly used as altitude value The frame_id of the given utm_position must be set to 'utm_<zone><N/S>'

Parameters
[out]reference_positionReferencePostion or ReferencePositionWithConfidence to set
[in]utm_positiongeometry_msgs::PointStamped describing the given utm position
[in]zonethe UTM zone (zero means UPS) of the given position
[in]northphemisphere (true means north, false means south)

Definition at line 314 of file denm_setters.h.

349 {
350
352#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
354
362inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
363 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
364}
365
373inline void setReferenceTime(
374 DENM& denm, const uint64_t unix_nanosecs,
375 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
376 TimestampIts t_its;
377 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
378 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
379 denm.denm.management.reference_time = t_its;
380}
381
388inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
389
401inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
402 const double altitude = AltitudeValue::UNAVAILABLE) {
403 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
404}
405
412inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
413 if (denm.denm.location_is_present) {
414 denm.denm.location.event_position_heading_is_present = presence_of_heading;
415 } else {
416 throw std::invalid_argument("LocationContainer is not present!");
417 }
418}
419
430inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
431 if (denm.denm.location_is_present) {
432 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
433 setIsHeadingPresent(denm, true);
434 } else {
435 throw std::invalid_argument("LocationContainer is not present!");
436 }
437}
438
445inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
446 if (denm.denm.location_is_present) {
447 denm.denm.location.event_speed_is_present = presence_of_speed;
448 } else {
449 throw std::invalid_argument("LocationContainer is not present!");
450 }
451}
452
460inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
461 if (denm.denm.location_is_present) {
462 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
463 setIsSpeedPresent(denm, true);
464 } else {
465 throw std::invalid_argument("LocationContainer is not present!");
466 }
467}
468
481inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
482 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
483}
484
491inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
492 setBitString(driving_lane_status, bits);
493}
494
501inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
502 setBitString(light_bar_siren_in_use, bits);
503}
504
505} // namespace etsi_its_denm_msgs::access

◆ setHeading()

void etsi_its_denm_msgs::access::setHeading ( DENM & denm,
const double heading_val,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the Heading for a DENM.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West HeadingConfidence is set to UNAVAILABLE

Parameters
denmDENM to set the ReferencePosition
valueHeading value in degree as decimal number
confidencestandard deviation of heading in degree as decimal number (default: infinity, mapping to HeadingConfidence::UNAVAILABLE)

Definition at line 183 of file denm_setters.h.

188 {
189 setBitString(light_bar_siren_in_use, bits);
190}

◆ setHeadingCDD()

template<typename Heading, typename HeadingConfidence = decltype(Heading::heading_confidence)>
void etsi_its_denm_msgs::access::setHeadingCDD ( Heading & heading,
const double value,
double confidence = std::numeric_limits<double>::infinity() )

Set the Heading object.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West HeadingConfidence is set to UNAVAILABLE

Parameters
headingobject to set
valueHeading value in degree as decimal number
confidencestandard deviation of heading in degree as decimal number (default: infinity, mapping to HeadingConfidence::UNAVAILABLE)

Definition at line 373 of file denm_setters.h.

408 {
409
411#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
413
421inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
422 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
423}
424
432inline void setReferenceTime(
433 DENM& denm, const uint64_t unix_nanosecs,
434 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
435 TimestampIts t_its;
436 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
437 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
438 denm.denm.management.reference_time = t_its;
439}
440
447inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
448
460inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
461 const double altitude = AltitudeValue::UNAVAILABLE) {
462 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
463}
464
471inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
472 if (denm.denm.location_is_present) {
473 denm.denm.location.event_position_heading_is_present = presence_of_heading;
474 } else {
475 throw std::invalid_argument("LocationContainer is not present!");
476 }
477}
478
489inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
490 if (denm.denm.location_is_present) {
491 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
492 setIsHeadingPresent(denm, true);
493 } else {
494 throw std::invalid_argument("LocationContainer is not present!");
495 }
496}
497
504inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
505 if (denm.denm.location_is_present) {
506 denm.denm.location.event_speed_is_present = presence_of_speed;
507 } else {
508 throw std::invalid_argument("LocationContainer is not present!");
509 }
510}
511
519inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
520 if (denm.denm.location_is_present) {
521 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
522 setIsSpeedPresent(denm, true);
523 } else {
524 throw std::invalid_argument("LocationContainer is not present!");
525 }
526}
527
540inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
541 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
542}
543
550inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
551 setBitString(driving_lane_status, bits);
552}
553
560inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
561 setBitString(light_bar_siren_in_use, bits);
562}
563
564} // namespace etsi_its_denm_msgs::access

◆ setHeadingConfidence()

template<typename HeadingConfidence>
void etsi_its_denm_msgs::access::setHeadingConfidence ( HeadingConfidence & heading_confidence,
const double value )
inline

Set the Heading Confidence object.

Parameters
heading_confidenceobject to set
valuestandard deviation of heading in degree as decimal number

Definition at line 352 of file denm_setters.h.

387 {
388
390#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
392
400inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
401 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
402}
403
411inline void setReferenceTime(
412 DENM& denm, const uint64_t unix_nanosecs,
413 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
414 TimestampIts t_its;
415 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
416 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
417 denm.denm.management.reference_time = t_its;
418}
419
426inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
427
439inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
440 const double altitude = AltitudeValue::UNAVAILABLE) {
441 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
442}
443
450inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
451 if (denm.denm.location_is_present) {
452 denm.denm.location.event_position_heading_is_present = presence_of_heading;
453 } else {
454 throw std::invalid_argument("LocationContainer is not present!");
455 }
456}
457
468inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
469 if (denm.denm.location_is_present) {
470 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
471 setIsHeadingPresent(denm, true);
472 } else {
473 throw std::invalid_argument("LocationContainer is not present!");
474 }
475}
476
483inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
484 if (denm.denm.location_is_present) {
485 denm.denm.location.event_speed_is_present = presence_of_speed;
486 } else {
487 throw std::invalid_argument("LocationContainer is not present!");
488 }
489}
490
498inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
499 if (denm.denm.location_is_present) {
500 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
501 setIsSpeedPresent(denm, true);
502 } else {
503 throw std::invalid_argument("LocationContainer is not present!");
504 }
505}
506
519inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
520 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
521}
522
529inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
530 setBitString(driving_lane_status, bits);
531}
532
539inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
540 setBitString(light_bar_siren_in_use, bits);
541}
542
543} // namespace etsi_its_denm_msgs::access

◆ setHeadingValue()

template<typename HeadingValue>
void etsi_its_denm_msgs::access::setHeadingValue ( HeadingValue & heading,
const double value )
inline

Set the HeadingValue object.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West

Parameters
headingobject to set
valueHeading value in degree as decimal number

Definition at line 339 of file denm_setters.h.

374 {
375
377#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
379
387inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
388 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
389}
390
398inline void setReferenceTime(
399 DENM& denm, const uint64_t unix_nanosecs,
400 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
401 TimestampIts t_its;
402 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
403 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
404 denm.denm.management.reference_time = t_its;
405}
406
413inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
414
426inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
427 const double altitude = AltitudeValue::UNAVAILABLE) {
428 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
429}
430
437inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
438 if (denm.denm.location_is_present) {
439 denm.denm.location.event_position_heading_is_present = presence_of_heading;
440 } else {
441 throw std::invalid_argument("LocationContainer is not present!");
442 }
443}
444
455inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
456 if (denm.denm.location_is_present) {
457 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
458 setIsHeadingPresent(denm, true);
459 } else {
460 throw std::invalid_argument("LocationContainer is not present!");
461 }
462}
463
470inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
471 if (denm.denm.location_is_present) {
472 denm.denm.location.event_speed_is_present = presence_of_speed;
473 } else {
474 throw std::invalid_argument("LocationContainer is not present!");
475 }
476}
477
485inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
486 if (denm.denm.location_is_present) {
487 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
488 setIsSpeedPresent(denm, true);
489 } else {
490 throw std::invalid_argument("LocationContainer is not present!");
491 }
492}
493
506inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
507 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
508}
509
516inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
517 setBitString(driving_lane_status, bits);
518}
519
526inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
527 setBitString(light_bar_siren_in_use, bits);
528}
529
530} // namespace etsi_its_denm_msgs::access

◆ setIsHeadingPresent()

void etsi_its_denm_msgs::access::setIsHeadingPresent ( DENM & denm,
bool presence_of_heading )
inline

Set the IsHeadingPresent object for DENM.

Parameters
denmDENM to set IsHeadingPresent
presence_of_headingIsHeadingPresent-Value (true or false)

Definition at line 165 of file denm_setters.h.

168 {
169 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
170}
171

◆ setIsSpeedPresent()

void etsi_its_denm_msgs::access::setIsSpeedPresent ( DENM & denm,
bool presence_of_speed )
inline

Set the IsSpeedPresent object for DENM.

Parameters
denmDENM to set IsSpeedPresent
presence_of_headingIsSpeedPresent-Value (true or false)

Definition at line 198 of file denm_setters.h.

233 {
234
236#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
238
246inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
247 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
248}
249
257inline void setReferenceTime(
258 DENM& denm, const uint64_t unix_nanosecs,
259 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
260 TimestampIts t_its;
261 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
262 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
263 denm.denm.management.reference_time = t_its;
264}
265
272inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
273
285inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
286 const double altitude = AltitudeValue::UNAVAILABLE) {
287 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
288}
289
296inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
297 if (denm.denm.location_is_present) {
298 denm.denm.location.event_position_heading_is_present = presence_of_heading;
299 } else {
300 throw std::invalid_argument("LocationContainer is not present!");
301 }
302}
303
314inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
315 if (denm.denm.location_is_present) {
316 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
317 setIsHeadingPresent(denm, true);
318 } else {
319 throw std::invalid_argument("LocationContainer is not present!");
320 }
321}
322
329inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
330 if (denm.denm.location_is_present) {
331 denm.denm.location.event_speed_is_present = presence_of_speed;
332 } else {
333 throw std::invalid_argument("LocationContainer is not present!");
334 }
335}
336
344inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
345 if (denm.denm.location_is_present) {
346 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
347 setIsSpeedPresent(denm, true);
348 } else {
349 throw std::invalid_argument("LocationContainer is not present!");
350 }
351}
352
365inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
366 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
367}
368
375inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
376 setBitString(driving_lane_status, bits);
377}
378
385inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
386 setBitString(light_bar_siren_in_use, bits);
387}
388
389} // namespace etsi_its_denm_msgs::access

◆ setItsPduHeader() [1/2]

void etsi_its_denm_msgs::access::setItsPduHeader ( DENM & denm,
const uint32_t station_id,
const uint8_t protocol_version = 0 )
inline

Set the ItsPduHeader-object for a DENM.

Parameters
denmDENM-Message to set the ItsPduHeader
station_id
protocol_version

Definition at line 115 of file denm_setters.h.

115 : infinity, mapping to HeadingConfidence::UNAVAILABLE)
116 */
117inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {

◆ setItsPduHeader() [2/2]

void etsi_its_denm_msgs::access::setItsPduHeader ( ItsPduHeader & header,
const uint8_t message_id,
const uint32_t station_id,
const uint8_t protocol_version = 0 )
inline

Set the Its Pdu Header object.

Parameters
headerItsPduHeader to be set
message_idID of the message
station_id
protocol_version

Definition at line 85 of file denm_setters.h.

89 {
90 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
91}
92

◆ setLatitude()

void etsi_its_denm_msgs::access::setLatitude ( Latitude & latitude,
const double deg )
inline

Set the Latitude object.

Parameters
latitudeobject to set
degLatitude value in degree as decimal number

Definition at line 123 of file denm_setters.h.

◆ setLightBarSirenInUse()

void etsi_its_denm_msgs::access::setLightBarSirenInUse ( LightBarSirenInUse & light_bar_siren_in_use,
const std::vector< bool > & bits )
inline

Set the Lightbar Siren In Use by a vector of bools.

Parameters
light_bar_siren_in_use
bits

Definition at line 254 of file denm_setters.h.

302inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
303 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
304}
305
313inline void setReferenceTime(
314 DENM& denm, const uint64_t unix_nanosecs,
315 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
316 TimestampIts t_its;
317 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
318 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
319 denm.denm.management.reference_time = t_its;
320}
321
328inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
329
341inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
342 const double altitude = AltitudeValue::UNAVAILABLE) {
343 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
344}
345
352inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
353 if (denm.denm.location_is_present) {
354 denm.denm.location.event_position_heading_is_present = presence_of_heading;
355 } else {
356 throw std::invalid_argument("LocationContainer is not present!");
357 }
358}
359
370inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
371 if (denm.denm.location_is_present) {
372 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
373 setIsHeadingPresent(denm, true);
374 } else {
375 throw std::invalid_argument("LocationContainer is not present!");
376 }
377}
378
385inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
386 if (denm.denm.location_is_present) {
387 denm.denm.location.event_speed_is_present = presence_of_speed;
388 } else {
389 throw std::invalid_argument("LocationContainer is not present!");
390 }
391}
392
400inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
401 if (denm.denm.location_is_present) {
402 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
403 setIsSpeedPresent(denm, true);
404 } else {
405 throw std::invalid_argument("LocationContainer is not present!");
406 }
407}
408
421inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
422 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
423}
424
431inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
432 setBitString(driving_lane_status, bits);
433}
434
441inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
442 setBitString(light_bar_siren_in_use, bits);
443}
444
445} // namespace etsi_its_denm_msgs::access

◆ setLongitude()

void etsi_its_denm_msgs::access::setLongitude ( Longitude & longitude,
const double deg )
inline

Set the Longitude object.

Parameters
longitudeobject to set
degLongitude value in degree as decimal number

Definition at line 135 of file denm_setters.h.

135 {
136 throw std::invalid_argument("LocationContainer is not present!");
137 }
138}
139

◆ setPosConfidenceEllipse() [1/2]

template<typename PosConfidenceEllipse>
void etsi_its_denm_msgs::access::setPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse,
const double semi_major_axis,
const double semi_minor_axis,
const double orientation )
inline

Set the Pos Confidence Ellipse object.

Parameters
[out]position_confidence_ellipseThe PosConfidenceEllipse to set
[in]semi_major_axislength of the semi-major axis in meters
[in]semi_minor_axislength of the semi-minor axis in meters
[in]orientationof the semi-major axis in degrees, with respect to WGS84

Definition at line 451 of file denm_setters.h.

486 {
487
489#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
491
499inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
500 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
501}
502
510inline void setReferenceTime(
511 DENM& denm, const uint64_t unix_nanosecs,
512 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
513 TimestampIts t_its;
514 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
515 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
516 denm.denm.management.reference_time = t_its;
517}
518
525inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
526
538inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
539 const double altitude = AltitudeValue::UNAVAILABLE) {
540 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
541}
542
549inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
550 if (denm.denm.location_is_present) {
551 denm.denm.location.event_position_heading_is_present = presence_of_heading;
552 } else {
553 throw std::invalid_argument("LocationContainer is not present!");
554 }
555}
556
567inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
568 if (denm.denm.location_is_present) {
569 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
570 setIsHeadingPresent(denm, true);
571 } else {
572 throw std::invalid_argument("LocationContainer is not present!");
573 }
574}
575
582inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
583 if (denm.denm.location_is_present) {
584 denm.denm.location.event_speed_is_present = presence_of_speed;
585 } else {
586 throw std::invalid_argument("LocationContainer is not present!");
587 }
588}
589
597inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
598 if (denm.denm.location_is_present) {
599 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
600 setIsSpeedPresent(denm, true);
601 } else {
602 throw std::invalid_argument("LocationContainer is not present!");
603 }
604}
605
618inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
619 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
620}
621
628inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
629 setBitString(driving_lane_status, bits);
630}
631
638inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
639 setBitString(light_bar_siren_in_use, bits);
640}
641
642} // namespace etsi_its_denm_msgs::access

◆ setPosConfidenceEllipse() [2/2]

template<typename PosConfidenceEllipse>
void etsi_its_denm_msgs::access::setPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse,
const std::array< double, 4 > & covariance_matrix,
const double object_heading )
inline

Set the Pos Confidence Ellipse object.

Parameters
position_confidence_ellipse
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the object (x = longitudinal, y = lateral)
object_headingThe heading of the object in rad, with respect to WGS84

Definition at line 524 of file denm_setters.h.

559 {
560
562#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
564
572inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
573 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
574}
575
583inline void setReferenceTime(
584 DENM& denm, const uint64_t unix_nanosecs,
585 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
586 TimestampIts t_its;
587 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
588 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
589 denm.denm.management.reference_time = t_its;
590}
591
598inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
599
611inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
612 const double altitude = AltitudeValue::UNAVAILABLE) {
613 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
614}
615
622inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
623 if (denm.denm.location_is_present) {
624 denm.denm.location.event_position_heading_is_present = presence_of_heading;
625 } else {
626 throw std::invalid_argument("LocationContainer is not present!");
627 }
628}
629
640inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
641 if (denm.denm.location_is_present) {
642 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
643 setIsHeadingPresent(denm, true);
644 } else {
645 throw std::invalid_argument("LocationContainer is not present!");
646 }
647}
648
655inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
656 if (denm.denm.location_is_present) {
657 denm.denm.location.event_speed_is_present = presence_of_speed;
658 } else {
659 throw std::invalid_argument("LocationContainer is not present!");
660 }
661}
662
670inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
671 if (denm.denm.location_is_present) {
672 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
673 setIsSpeedPresent(denm, true);
674 } else {
675 throw std::invalid_argument("LocationContainer is not present!");
676 }
677}
678
691inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
692 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
693}
694
701inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
702 setBitString(driving_lane_status, bits);
703}
704
711inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
712 setBitString(light_bar_siren_in_use, bits);
713}
714
715} // namespace etsi_its_denm_msgs::access

◆ setReferencePosition() [1/2]

void etsi_its_denm_msgs::access::setReferencePosition ( DENM & denm,
const double latitude,
const double longitude,
const double altitude = AltitudeValue::UNAVAILABLE )
inline

Set the ReferencePositionWithConfidence for a DENM.

This function sets the latitude, longitude, and altitude of the DENMs reference position. If the altitude is not provided, it is set to AltitudeValue::UNAVAILABLE.

Parameters
denmDENM to set the ReferencePosition
latitudeThe latitude value position in degree as decimal number.
longitudeThe longitude value in degree as decimal number.
altitudeThe altitude value (above the reference ellipsoid surface) in meter as decimal number (optional).

Definition at line 154 of file denm_setters.h.

◆ setReferencePosition() [2/2]

template<typename T>
void etsi_its_denm_msgs::access::setReferencePosition ( T & ref_position,
const double latitude,
const double longitude,
const double altitude = AltitudeValue::UNAVAILABLE )
inline

Sets the reference position in the given ReferencePostion object.

This function sets the latitude, longitude, and altitude of the reference position. If the altitude is not provided, it is set to AltitudeValue::UNAVAILABLE.

Parameters
ref_positionReferencePostion or ReferencePositionWithConfidence object to set the reference position in.
latitudeThe latitude value position in degree as decimal number.
longitudeThe longitude value in degree as decimal number.
altitudeThe altitude value (above the reference ellipsoid surface) in meter as decimal number (optional).

Definition at line 288 of file denm_setters.h.

323 {
324
326#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
328
336inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
337 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
338}
339
347inline void setReferenceTime(
348 DENM& denm, const uint64_t unix_nanosecs,
349 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
350 TimestampIts t_its;
351 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
352 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
353 denm.denm.management.reference_time = t_its;
354}
355
362inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
363
375inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
376 const double altitude = AltitudeValue::UNAVAILABLE) {
377 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
378}
379
386inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
387 if (denm.denm.location_is_present) {
388 denm.denm.location.event_position_heading_is_present = presence_of_heading;
389 } else {
390 throw std::invalid_argument("LocationContainer is not present!");
391 }
392}
393
404inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
405 if (denm.denm.location_is_present) {
406 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
407 setIsHeadingPresent(denm, true);
408 } else {
409 throw std::invalid_argument("LocationContainer is not present!");
410 }
411}
412
419inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
420 if (denm.denm.location_is_present) {
421 denm.denm.location.event_speed_is_present = presence_of_speed;
422 } else {
423 throw std::invalid_argument("LocationContainer is not present!");
424 }
425}
426
434inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
435 if (denm.denm.location_is_present) {
436 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
437 setIsSpeedPresent(denm, true);
438 } else {
439 throw std::invalid_argument("LocationContainer is not present!");
440 }
441}
442
455inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
456 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
457}
458
465inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
466 setBitString(driving_lane_status, bits);
467}
468
475inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
476 setBitString(light_bar_siren_in_use, bits);
477}
478
479} // namespace etsi_its_denm_msgs::access

◆ setReferenceTime()

void etsi_its_denm_msgs::access::setReferenceTime ( DENM & denm,
const uint64_t unix_nanosecs,
const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second )
inline

Set the ReferenceTime-value.

Parameters
denmDENM to set the ReferenceTime-Value for
unix_nanosecsTimestamp in unix-nanoseconds to set the ReferenceTime-Value from
n_leap_secondsNumber of leap seconds since 2004 for the given timestamp (Defaults to the todays number of leap seconds since 2004.)

Definition at line 126 of file denm_setters.h.

132 {
133 if (denm.denm.location_is_present) {

◆ setSemiAxis()

template<typename SemiAxisLength>
void etsi_its_denm_msgs::access::setSemiAxis ( SemiAxisLength & semi_axis_length,
const double length )
inline

Set the Semi Axis length.

// See https://godbolt.org/z/Eceavfo99 on how the OneCentimeterHelper works with this template

Parameters
semi_axis_lengthThe SemiAxisLength to set
lengththe desired length in meters

Definition at line 432 of file denm_setters.h.

467 {
468
470#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
472
480inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
481 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
482}
483
491inline void setReferenceTime(
492 DENM& denm, const uint64_t unix_nanosecs,
493 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
494 TimestampIts t_its;
495 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
496 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
497 denm.denm.management.reference_time = t_its;
498}
499
506inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
507
519inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
520 const double altitude = AltitudeValue::UNAVAILABLE) {
521 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
522}
523
530inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
531 if (denm.denm.location_is_present) {
532 denm.denm.location.event_position_heading_is_present = presence_of_heading;
533 } else {
534 throw std::invalid_argument("LocationContainer is not present!");
535 }
536}
537
548inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
549 if (denm.denm.location_is_present) {
550 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
551 setIsHeadingPresent(denm, true);
552 } else {
553 throw std::invalid_argument("LocationContainer is not present!");
554 }
555}
556
563inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
564 if (denm.denm.location_is_present) {
565 denm.denm.location.event_speed_is_present = presence_of_speed;
566 } else {
567 throw std::invalid_argument("LocationContainer is not present!");
568 }
569}
570
578inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
579 if (denm.denm.location_is_present) {
580 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
581 setIsSpeedPresent(denm, true);
582 } else {
583 throw std::invalid_argument("LocationContainer is not present!");
584 }
585}
586
599inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
600 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
601}
602
609inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
610 setBitString(driving_lane_status, bits);
611}
612
619inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
620 setBitString(light_bar_siren_in_use, bits);
621}
622
623} // namespace etsi_its_denm_msgs::access

◆ setSpeed() [1/2]

void etsi_its_denm_msgs::access::setSpeed ( DENM & denm,
const double speed_val,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the vehicle speed.

Parameters
denmDENM to set the speed value
speed_valspeed value to set in m/s as decimal number
confidencespeed confidence value to set in m/s (default: infinity, mapping to SpeedConfidence::UNAVAILABLE)

Definition at line 213 of file denm_setters.h.

248 {
249
251#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
253
261inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
262 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
263}
264
272inline void setReferenceTime(
273 DENM& denm, const uint64_t unix_nanosecs,
274 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
275 TimestampIts t_its;
276 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
277 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
278 denm.denm.management.reference_time = t_its;
279}
280
287inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
288
300inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
301 const double altitude = AltitudeValue::UNAVAILABLE) {
302 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
303}
304
311inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
312 if (denm.denm.location_is_present) {
313 denm.denm.location.event_position_heading_is_present = presence_of_heading;
314 } else {
315 throw std::invalid_argument("LocationContainer is not present!");
316 }
317}
318
329inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
330 if (denm.denm.location_is_present) {
331 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
332 setIsHeadingPresent(denm, true);
333 } else {
334 throw std::invalid_argument("LocationContainer is not present!");
335 }
336}
337
344inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
345 if (denm.denm.location_is_present) {
346 denm.denm.location.event_speed_is_present = presence_of_speed;
347 } else {
348 throw std::invalid_argument("LocationContainer is not present!");
349 }
350}
351
359inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
360 if (denm.denm.location_is_present) {
361 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
362 setIsSpeedPresent(denm, true);
363 } else {
364 throw std::invalid_argument("LocationContainer is not present!");
365 }
366}
367
380inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
381 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
382}
383
390inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
391 setBitString(driving_lane_status, bits);
392}
393
400inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
401 setBitString(light_bar_siren_in_use, bits);
402}
403
404} // namespace etsi_its_denm_msgs::access

◆ setSpeed() [2/2]

void etsi_its_denm_msgs::access::setSpeed ( Speed & speed,
const double value,
const double confidence = std::numeric_limits<double>::infinity() )
inline

Set the Speed object.

SpeedConfidence is set to UNAVAILABLE

Parameters
speedobject to set
valueSpeed in in m/s as decimal number
confidencestandard deviation in m/s as decimal number (Optional. Default is std::numeric_limits<double>::infinity(), mapping to SpeedConfidence::UNAVAILABLE)

Definition at line 208 of file denm_setters.h.

243 {
244
246#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
248
256inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
257 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
258}
259
267inline void setReferenceTime(
268 DENM& denm, const uint64_t unix_nanosecs,
269 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
270 TimestampIts t_its;
271 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
272 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
273 denm.denm.management.reference_time = t_its;
274}
275
282inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
283
295inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
296 const double altitude = AltitudeValue::UNAVAILABLE) {
297 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
298}
299
306inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
307 if (denm.denm.location_is_present) {
308 denm.denm.location.event_position_heading_is_present = presence_of_heading;
309 } else {
310 throw std::invalid_argument("LocationContainer is not present!");
311 }
312}
313
324inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
325 if (denm.denm.location_is_present) {
326 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
327 setIsHeadingPresent(denm, true);
328 } else {
329 throw std::invalid_argument("LocationContainer is not present!");
330 }
331}
332
339inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
340 if (denm.denm.location_is_present) {
341 denm.denm.location.event_speed_is_present = presence_of_speed;
342 } else {
343 throw std::invalid_argument("LocationContainer is not present!");
344 }
345}
346
354inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
355 if (denm.denm.location_is_present) {
356 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
357 setIsSpeedPresent(denm, true);
358 } else {
359 throw std::invalid_argument("LocationContainer is not present!");
360 }
361}
362
375inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
376 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
377}
378
385inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
386 setBitString(driving_lane_status, bits);
387}
388
395inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
396 setBitString(light_bar_siren_in_use, bits);
397}
398
399} // namespace etsi_its_denm_msgs::access

◆ setSpeedConfidence()

void etsi_its_denm_msgs::access::setSpeedConfidence ( SpeedConfidence & speed_confidence,
const double value )
inline

Set the Speed Confidence object.

Parameters
speed_confidenceobject to set
valuestandard deviation in m/s as decimal number

Definition at line 189 of file denm_setters.h.

◆ setSpeedValue()

void etsi_its_denm_msgs::access::setSpeedValue ( SpeedValue & speed,
const double value )
inline

Set the SpeedValue object.

Parameters
speedobject to set
valueSpeedValue in m/s as decimal number

Definition at line 177 of file denm_setters.h.

178 {
179 setBitString(driving_lane_status, bits);
180}
181

◆ setStationId()

void etsi_its_denm_msgs::access::setStationId ( StationID & station_id,
const uint32_t id_value )
inline

Set the Station Id object.

Parameters
station_id
id_value

Definition at line 72 of file denm_setters.h.

75 { setStationType(denm.denm.management.station_type, value); }
void setStationType(StationType &station_type, const uint8_t value)
Set the Station Type.

◆ setStationType() [1/2]

void etsi_its_denm_msgs::access::setStationType ( DENM & denm,
const int value )
inline

Set the StationType for a DENM.

Parameters
denmDENM-Message to set the station_type value
valuestation_type value to set

Definition at line 141 of file denm_setters.h.

◆ setStationType() [2/2]

void etsi_its_denm_msgs::access::setStationType ( StationType & station_type,
const uint8_t value )
inline

Set the Station Type.

Parameters
station_type
value

Definition at line 101 of file denm_setters.h.

102 {
103 throw std::invalid_argument("LocationContainer is not present!");
104 }

◆ setTimestampITS()

void etsi_its_denm_msgs::access::setTimestampITS ( TimestampIts & timestamp_its,
const uint64_t unix_nanosecs,
const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second )
inline

Set the TimestampITS object.

Parameters
[in]timestamp_itsTimestampITS object to set the timestamp
[in]unix_nanosecsUnix-Nanoseconds to set the timestamp for
[in]n_leap_secondsNumber of leap-seconds since 2004. (Defaults to the todays number of leap seconds since 2004.)
[in]epoch_offsetUnix-Timestamp in seconds for the 01.01.2004 at 00:00:00

Definition at line 109 of file denm_setters.h.

115 : infinity, mapping to HeadingConfidence::UNAVAILABLE)

◆ setWGSPosConfidenceEllipse()

template<typename PosConfidenceEllipse>
void etsi_its_denm_msgs::access::setWGSPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse,
const std::array< double, 4 > & covariance_matrix )
inline

Set the Pos Confidence Ellipse object.

Parameters
position_confidence_ellipse
covariance_matrixThe four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the WGS axes (x = North, y = East)
object_headingThe heading of the object in rad, with respect to WGS84

Definition at line 539 of file denm_setters.h.

574 {
575
577#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
579
587inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
588 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
589}
590
598inline void setReferenceTime(
599 DENM& denm, const uint64_t unix_nanosecs,
600 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
601 TimestampIts t_its;
602 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
603 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
604 denm.denm.management.reference_time = t_its;
605}
606
613inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
614
626inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
627 const double altitude = AltitudeValue::UNAVAILABLE) {
628 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
629}
630
637inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
638 if (denm.denm.location_is_present) {
639 denm.denm.location.event_position_heading_is_present = presence_of_heading;
640 } else {
641 throw std::invalid_argument("LocationContainer is not present!");
642 }
643}
644
655inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
656 if (denm.denm.location_is_present) {
657 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
658 setIsHeadingPresent(denm, true);
659 } else {
660 throw std::invalid_argument("LocationContainer is not present!");
661 }
662}
663
670inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
671 if (denm.denm.location_is_present) {
672 denm.denm.location.event_speed_is_present = presence_of_speed;
673 } else {
674 throw std::invalid_argument("LocationContainer is not present!");
675 }
676}
677
685inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
686 if (denm.denm.location_is_present) {
687 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
688 setIsSpeedPresent(denm, true);
689 } else {
690 throw std::invalid_argument("LocationContainer is not present!");
691 }
692}
693
706inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
707 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
708}
709
716inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
717 setBitString(driving_lane_status, bits);
718}
719
726inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
727 setBitString(light_bar_siren_in_use, bits);
728}
729
730} // namespace etsi_its_denm_msgs::access

◆ setYawRateCDD()

template<typename YawRate, typename YawRateValue = decltype(YawRate::yaw_rate_value), typename YawRateConfidence = decltype(YawRate::yaw_rate_confidence)>
void etsi_its_denm_msgs::access::setYawRateCDD ( YawRate & yaw_rate,
const double value,
double confidence = std::numeric_limits<double>::infinity() )
inline

Set the Yaw Rate object.

Parameters
yaw_rateobject to set
valueYaw rate in degrees per second as decimal number
confidencestandard deviation of yaw rate in degrees per second as decimal number (default: infinity, mapping to YawRateConfidence::UNAVAILABLE)

Definition at line 386 of file denm_setters.h.

421 {
422
424#include <etsi_its_msgs_utils/impl/asn1_primitives/asn1_primitives_setters.h>
426
434inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
435 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
436}
437
445inline void setReferenceTime(
446 DENM& denm, const uint64_t unix_nanosecs,
447 const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second) {
448 TimestampIts t_its;
449 setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
450 throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
451 denm.denm.management.reference_time = t_its;
452}
453
460inline void setStationType(DENM& denm, const int value) { setStationType(denm.denm.management.station_type, value); }
461
473inline void setReferencePosition(DENM& denm, const double latitude, const double longitude,
474 const double altitude = AltitudeValue::UNAVAILABLE) {
475 setReferencePosition(denm.denm.management.event_position, latitude, longitude, altitude);
476}
477
484inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
485 if (denm.denm.location_is_present) {
486 denm.denm.location.event_position_heading_is_present = presence_of_heading;
487 } else {
488 throw std::invalid_argument("LocationContainer is not present!");
489 }
490}
491
502inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
503 if (denm.denm.location_is_present) {
504 setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
505 setIsHeadingPresent(denm, true);
506 } else {
507 throw std::invalid_argument("LocationContainer is not present!");
508 }
509}
510
517inline void setIsSpeedPresent(DENM& denm, bool presence_of_speed) {
518 if (denm.denm.location_is_present) {
519 denm.denm.location.event_speed_is_present = presence_of_speed;
520 } else {
521 throw std::invalid_argument("LocationContainer is not present!");
522 }
523}
524
532inline void setSpeed(DENM& denm, const double speed_val, const double confidence = std::numeric_limits<double>::infinity()) {
533 if (denm.denm.location_is_present) {
534 setSpeed(denm.denm.location.event_speed, speed_val, confidence);
535 setIsSpeedPresent(denm, true);
536 } else {
537 throw std::invalid_argument("LocationContainer is not present!");
538 }
539}
540
553inline void setFromUTMPosition(DENM& denm, const gm::PointStamped& utm_position, const int& zone, const bool& northp) {
554 setFromUTMPosition(denm.denm.management.event_position, utm_position, zone, northp);
555}
556
563inline void setDrivingLaneStatus(DrivingLaneStatus& driving_lane_status, const std::vector<bool>& bits) {
564 setBitString(driving_lane_status, bits);
565}
566
573inline void setLightBarSirenInUse(LightBarSirenInUse& light_bar_siren_in_use, const std::vector<bool>& bits) {
574 setBitString(light_bar_siren_in_use, bits);
575}
576
577} // namespace etsi_its_denm_msgs::access

◆ throwIfNotPresent()

void etsi_its_denm_msgs::access::throwIfNotPresent ( const bool is_present,
const std::string val_desc )
inline

Throws an exception if the given value is not present.

Parameters
is_presentWhether the value is present.
val_descDescription of the value for the exception message.

Definition at line 58 of file denm_setters.h.

◆ throwIfOutOfRange()

template<typename T1, typename T2>
void etsi_its_denm_msgs::access::throwIfOutOfRange ( const T1 & val,
const T2 & min,
const T2 & max,
const std::string val_desc )

Throws an exception if a given value is out of a defined range.

Template Parameters
T1
T2
Parameters
valThe value to check if it is in the range.
minThe minimum value of the range.
maxThe maximum value of the range.
val_descDescription of the value for the exception message.

Definition at line 47 of file denm_setters.h.

49 {
50 setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
51}