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

#include <etsi_its_msgs_utils/impl/constants.h>
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>

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.
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.
template<typename StationId>
void	etsi_its_denm_msgs::access::setStationId (StationId &station_id, const uint32_t id_value)
	Set the Station Id object.
template<typename StationType>
void	etsi_its_denm_msgs::access::setStationType (StationType &station_type, const uint8_t value)
	Set the Station Type.
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::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.
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.
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::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.
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::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.

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_matrix	The 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_heading	The 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 434 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_matrix	The 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_heading	The 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 475 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // namespace etsi_its_denm_msgs::access

◆ 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_seconds the 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.

                                   {
#include <etsi_its_msgs_utils/impl/denm/denm_utils.h>
}

◆ 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_confidence	object to set
value	standard deviation in m/s^2 as decimal number

Definition at line 233 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_mag	object to set
value	AccelerationMagnitudeValue in m/s^2 as decimal number
confidence	standard deviation in m/s^2 as decimal number (default: infinity, mapping to AccelerationConfidence::UNAVAILABLE)

Definition at line 220 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_confidence	object to set
value	standard deviation in m/s^2 as decimal number

Definition at line 200 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_value	object to set
value	AccelerationMagnitudeValue in m/s^2 as decimal number

Definition at line 187 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

altitude	object to set
value	Altitude value (above the reference ellipsoid surface) in meter as decimal number

Definition at line 133 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // namespace etsi_its_denm_msgs::access

◆ setAltitudeValue()

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

inline

Set the AltitudeValue object.

Parameters

altitude	object to set
value	AltitudeValue value (above the reference ellipsoid surface) in meter as decimal number

Definition at line 114 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // namespace etsi_its_denm_msgs::access

◆ 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

bitstring	BitString to set
bits	vector of bools

Definition at line 44 of file denm_setters.h.

                                                                                                     {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}

◆ 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 131 of file denm_setters.h.

inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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]	denm	DENM for which to set the ReferencePosition
[in]	utm_position	geometry_msgs::PointStamped describing the given utm position
[in]	zone	the UTM zone (zero means UPS) of the given position
[in]	northp	hemisphere (true means north, false means south)

Definition at line 121 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_position	ReferencePostion or ReferencePositionWithConfidence to set
[in]	utm_position	geometry_msgs::PointStamped describing the given utm position
[in]	zone	the UTM zone (zero means UPS) of the given position
[in]	northp	hemisphere (true means north, false means south)

Definition at line 281 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

denm	DENM to set the ReferencePosition
value	Heading value in degree as decimal number
confidence	standard deviation of heading in degree as decimal number (default: infinity, mapping to HeadingConfidence::UNAVAILABLE)

Definition at line 77 of file denm_setters.h.

                                                                                                                          {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}

◆ 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

heading	object to set
value	Heading value in degree as decimal number
confidence	standard deviation of heading in degree as decimal number (default: infinity, mapping to HeadingConfidence::UNAVAILABLE)

Definition at line 340 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_confidence	object to set
value	standard deviation of heading in degree as decimal number

Definition at line 319 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

heading	object to set
value	Heading value in degree as decimal number

Definition at line 306 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

denm	DENM to set IsHeadingPresent
presence_of_heading	IsHeadingPresent-Value (true or false)

Definition at line 59 of file denm_setters.h.

                                                                      {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}

◆ setIsSpeedPresent()

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

inline

Set the IsSpeedPresent object for DENM.

Parameters

denm	DENM to set IsSpeedPresent
presence_of_speed	IsSpeedPresent-Value (true or false)

Definition at line 85 of file denm_setters.h.

◆ 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

denm	DENM-Message to set the ItsPduHeader
station_id
protocol_version

Definition at line 49 of file denm_setters.h.

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

◆ 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

header	ItsPduHeader to be set
message_id	ID of the message
station_id
protocol_version

Definition at line 48 of file denm_setters.h.

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

◆ setLatitude()

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

inline

Set the Latitude object.

Parameters

latitude	object to set
deg	Latitude value in degree as decimal number

Definition at line 90 of file denm_setters.h.

inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // namespace etsi_its_denm_msgs::access

◆ 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 141 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

longitude	object to set
deg	Longitude value in degree as decimal number

Definition at line 102 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // namespace etsi_its_denm_msgs::access

◆ 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_ellipse	The PosConfidenceEllipse to set
[in]	semi_major_axis	length of the semi-major axis in meters
[in]	semi_minor_axis	length of the semi-minor axis in meters
[in]	orientation	of the semi-major axis in degrees, with respect to WGS84

Definition at line 418 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_matrix	The 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_heading	The heading of the object in rad, with respect to WGS84

Definition at line 491 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

denm	DENM to set the ReferencePosition
latitude	The latitude value position in degree as decimal number.
longitude	The longitude value in degree as decimal number.
altitude	The altitude value (above the reference ellipsoid surface) in meter as decimal number (optional).

Definition at line 74 of file denm_setters.h.

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

◆ 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_position	ReferencePostion or ReferencePositionWithConfidence object to set the reference position in.
latitude	The latitude value position in degree as decimal number.
longitude	The longitude value in degree as decimal number.
altitude	The altitude value (above the reference ellipsoid surface) in meter as decimal number (optional).

Definition at line 255 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

denm	DENM to set the ReferenceTime-Value for
unix_nanosecs	Timestamp in unix-nanoseconds to set the ReferenceTime-Value from
n_leap_seconds	Number of leap seconds since 2004 for the given timestamp (Defaults to the todays number of leap seconds since 2004.)

Definition at line 46 of file denm_setters.h.

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

◆ 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_length	The SemiAxisLength to set
length	the desired length in meters

Definition at line 399 of file denm_setters.h.

inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

denm	DENM to set the speed value
speed_val	speed value to set in m/s as decimal number
confidence	speed confidence value to set in m/s (default: infinity, mapping to SpeedConfidence::UNAVAILABLE)

Definition at line 100 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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

speed	object to set
value	Speed in in m/s as decimal number
confidence	standard deviation in m/s as decimal number (Optional. Default is std::numeric_limits<double>::infinity(), mapping to SpeedConfidence::UNAVAILABLE)

Definition at line 175 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_confidence	object to set
value	standard deviation in m/s as decimal number

Definition at line 156 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // namespace etsi_its_denm_msgs::access

◆ setSpeedValue()

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

inline

Set the SpeedValue object.

Parameters

speed	object to set
value	SpeedValue in m/s as decimal number

Definition at line 144 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // namespace etsi_its_denm_msgs::access

◆ setStationId()

template<typename StationId>

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 51 of file denm_setters.h.

◆ setStationType() [1/2]

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

inline

Set the StationType for a DENM.

Parameters

denm	DENM-Message to set the station_type value
value	station_type value to set

Definition at line 61 of file denm_setters.h.

◆ setStationType() [2/2]

template<typename StationType>

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 63 of file denm_setters.h.

◆ 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_its	TimestampITS object to set the timestamp
[in]	unix_nanosecs	Unix-Nanoseconds to set the timestamp for
[in]	n_leap_seconds	Number of leap-seconds since 2004. (Defaults to the todays number of leap seconds since 2004.)
[in]	epoch_offset	Unix-Timestamp in seconds for the 01.01.2004 at 00:00:00

Definition at line 76 of file denm_setters.h.

                                                                                                                          {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");

◆ 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_matrix	The 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_heading	The heading of the object in rad, with respect to WGS84

Definition at line 506 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_rate	object to set
value	Yaw rate in degrees per second as decimal number
confidence	standard deviation of yaw rate in degrees per second as decimal number (default: infinity, mapping to YawRateConfidence::UNAVAILABLE)

Definition at line 353 of file denm_setters.h.

                                   {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
 
#include <etsi_its_msgs_utils/impl/denm/denm_setters_common.h>
inline void setItsPduHeader(DENM& denm, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(denm.header, ItsPduHeader::MESSAGE_ID_DENM, station_id, protocol_version);
}
inline void setIsHeadingPresent(DENM& denm, bool presence_of_heading) {
  if (denm.denm.location_is_present) {
    denm.denm.location.event_position_heading_is_present = presence_of_heading;
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
inline void setHeading(DENM& denm, const double heading_val, const double confidence = std::numeric_limits<double>::infinity()) {
  if (denm.denm.location_is_present) {
    setHeadingCDD(denm.denm.location.event_position_heading, heading_val, confidence);
    setIsHeadingPresent(denm, true);
  } else {
    throw std::invalid_argument("LocationContainer is not present!");
  }
}
 
}  // 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_present	Whether the value is present.
val_desc	Description of the value for the exception message.

Definition at line 58 of file denm_setters.h.

59 {

60 if (denm.denm.location_is_present) {

◆ 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

val	The value to check if it is in the range.
min	The minimum value of the range.
max	The maximum value of the range.
val_desc	Description of the value for the exception message.

Definition at line 47 of file denm_setters.h.

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

Classes

Functions

Detailed Description

Function Documentation

◆ confidenceEllipseFromCovMatrix()

◆ confidenceEllipseFromWGSCovMatrix()

◆ getLeapSecondInsertionsSince2004()

◆ setAccelerationConfidence()

◆ setAccelerationMagnitude()

◆ setAccelerationMagnitudeConfidence()

◆ setAccelerationMagnitudeValue()

◆ setAltitude()

◆ setAltitudeValue()

◆ setBitString()

◆ setDrivingLaneStatus()

◆ setFromUTMPosition() [1/2]

◆ setFromUTMPosition() [2/2]

◆ setHeading()

◆ setHeadingCDD()

◆ setHeadingConfidence()

◆ setHeadingValue()

◆ setIsHeadingPresent()

◆ setIsSpeedPresent()

◆ setItsPduHeader() [1/2]

◆ setItsPduHeader() [2/2]

◆ setLatitude()

◆ setLightBarSirenInUse()

◆ setLongitude()

◆ setPosConfidenceEllipse() [1/2]

◆ setPosConfidenceEllipse() [2/2]

◆ setReferencePosition() [1/2]

◆ setReferencePosition() [2/2]

◆ setReferenceTime()

◆ setSemiAxis()

◆ setSpeed() [1/2]

◆ setSpeed() [2/2]

◆ setSpeedConfidence()

◆ setSpeedValue()

◆ setStationId()

◆ setStationType() [1/2]

◆ setStationType() [2/2]

◆ setTimestampITS()

◆ setWGSPosConfidenceEllipse()

◆ setYawRateCDD()

◆ throwIfNotPresent()

◆ throwIfOutOfRange()