convertVruHighFrequencyContainer.h

Go to the documentation of this file.

 
#pragma once
 
#include <etsi_its_vam_ts_coding/vam_ts_VruHighFrequencyContainer.h>
#include <etsi_its_vam_ts_conversion/convertCartesianAngle.h>
#include <etsi_its_vam_ts_conversion/convertCurvature.h>
#include <etsi_its_vam_ts_conversion/convertCurvatureCalculationMode.h>
#include <etsi_its_vam_ts_conversion/convertGeneralizedLanePosition.h>
#include <etsi_its_vam_ts_conversion/convertLateralAcceleration.h>
#include <etsi_its_vam_ts_conversion/convertLongitudinalAcceleration.h>
#include <etsi_its_vam_ts_conversion/convertSpeed.h>
#include <etsi_its_vam_ts_conversion/convertVerticalAcceleration.h>
#include <etsi_its_vam_ts_conversion/convertVruDeviceUsage.h>
#include <etsi_its_vam_ts_conversion/convertVruEnvironment.h>
#include <etsi_its_vam_ts_conversion/convertVruMovementControl.h>
#include <etsi_its_vam_ts_conversion/convertWgs84Angle.h>
#include <etsi_its_vam_ts_conversion/convertYawRate.h>
#ifdef ROS1
#include <etsi_its_vam_ts_msgs/VruHighFrequencyContainer.h>
namespace vam_ts_msgs = etsi_its_vam_ts_msgs;
#else
#include <etsi_its_vam_ts_msgs/msg/vru_high_frequency_container.hpp>
namespace vam_ts_msgs = etsi_its_vam_ts_msgs::msg;
#endif
 
 
namespace etsi_its_vam_ts_conversion {
 
void toRos_VruHighFrequencyContainer(const vam_ts_VruHighFrequencyContainer_t& in, vam_ts_msgs::VruHighFrequencyContainer& out) {
  toRos_Wgs84Angle(in.heading, out.heading);
  toRos_Speed(in.speed, out.speed);
  toRos_LongitudinalAcceleration(in.longitudinalAcceleration, out.longitudinal_acceleration);
  if (in.curvature) {
    toRos_Curvature(*in.curvature, out.curvature);
    out.curvature_is_present = true;
  }
  if (in.curvatureCalculationMode) {
    toRos_CurvatureCalculationMode(*in.curvatureCalculationMode, out.curvature_calculation_mode);
    out.curvature_calculation_mode_is_present = true;
  }
  if (in.yawRate) {
    toRos_YawRate(*in.yawRate, out.yaw_rate);
    out.yaw_rate_is_present = true;
  }
  if (in.lateralAcceleration) {
    toRos_LateralAcceleration(*in.lateralAcceleration, out.lateral_acceleration);
    out.lateral_acceleration_is_present = true;
  }
  if (in.verticalAcceleration) {
    toRos_VerticalAcceleration(*in.verticalAcceleration, out.vertical_acceleration);
    out.vertical_acceleration_is_present = true;
  }
  if (in.vruLanePosition) {
    toRos_GeneralizedLanePosition(*in.vruLanePosition, out.vru_lane_position);
    out.vru_lane_position_is_present = true;
  }
  if (in.environment) {
    toRos_VruEnvironment(*in.environment, out.environment);
    out.environment_is_present = true;
  }
  if (in.movementControl) {
    toRos_VruMovementControl(*in.movementControl, out.movement_control);
    out.movement_control_is_present = true;
  }
  if (in.orientation) {
    toRos_Wgs84Angle(*in.orientation, out.orientation);
    out.orientation_is_present = true;
  }
  if (in.rollAngle) {
    toRos_CartesianAngle(*in.rollAngle, out.roll_angle);
    out.roll_angle_is_present = true;
  }
  if (in.deviceUsage) {
    toRos_VruDeviceUsage(*in.deviceUsage, out.device_usage);
    out.device_usage_is_present = true;
  }
}
 
void toStruct_VruHighFrequencyContainer(const vam_ts_msgs::VruHighFrequencyContainer& in, vam_ts_VruHighFrequencyContainer_t& out) {
  memset(&out, 0, sizeof(vam_ts_VruHighFrequencyContainer_t));
  toStruct_Wgs84Angle(in.heading, out.heading);
  toStruct_Speed(in.speed, out.speed);
  toStruct_LongitudinalAcceleration(in.longitudinal_acceleration, out.longitudinalAcceleration);
  if (in.curvature_is_present) {
    out.curvature = (vam_ts_Curvature_t*) calloc(1, sizeof(vam_ts_Curvature_t));
    toStruct_Curvature(in.curvature, *out.curvature);
  }
  if (in.curvature_calculation_mode_is_present) {
    out.curvatureCalculationMode = (vam_ts_CurvatureCalculationMode_t*) calloc(1, sizeof(vam_ts_CurvatureCalculationMode_t));
    toStruct_CurvatureCalculationMode(in.curvature_calculation_mode, *out.curvatureCalculationMode);
  }
  if (in.yaw_rate_is_present) {
    out.yawRate = (vam_ts_YawRate_t*) calloc(1, sizeof(vam_ts_YawRate_t));
    toStruct_YawRate(in.yaw_rate, *out.yawRate);
  }
  if (in.lateral_acceleration_is_present) {
    out.lateralAcceleration = (vam_ts_LateralAcceleration_t*) calloc(1, sizeof(vam_ts_LateralAcceleration_t));
    toStruct_LateralAcceleration(in.lateral_acceleration, *out.lateralAcceleration);
  }
  if (in.vertical_acceleration_is_present) {
    out.verticalAcceleration = (vam_ts_VerticalAcceleration_t*) calloc(1, sizeof(vam_ts_VerticalAcceleration_t));
    toStruct_VerticalAcceleration(in.vertical_acceleration, *out.verticalAcceleration);
  }
  if (in.vru_lane_position_is_present) {
    out.vruLanePosition = (vam_ts_GeneralizedLanePosition_t*) calloc(1, sizeof(vam_ts_GeneralizedLanePosition_t));
    toStruct_GeneralizedLanePosition(in.vru_lane_position, *out.vruLanePosition);
  }
  if (in.environment_is_present) {
    out.environment = (vam_ts_VruEnvironment_t*) calloc(1, sizeof(vam_ts_VruEnvironment_t));
    toStruct_VruEnvironment(in.environment, *out.environment);
  }
  if (in.movement_control_is_present) {
    out.movementControl = (vam_ts_VruMovementControl_t*) calloc(1, sizeof(vam_ts_VruMovementControl_t));
    toStruct_VruMovementControl(in.movement_control, *out.movementControl);
  }
  if (in.orientation_is_present) {
    out.orientation = (vam_ts_Wgs84Angle_t*) calloc(1, sizeof(vam_ts_Wgs84Angle_t));
    toStruct_Wgs84Angle(in.orientation, *out.orientation);
  }
  if (in.roll_angle_is_present) {
    out.rollAngle = (vam_ts_CartesianAngle_t*) calloc(1, sizeof(vam_ts_CartesianAngle_t));
    toStruct_CartesianAngle(in.roll_angle, *out.rollAngle);
  }
  if (in.device_usage_is_present) {
    out.deviceUsage = (vam_ts_VruDeviceUsage_t*) calloc(1, sizeof(vam_ts_VruDeviceUsage_t));
    toStruct_VruDeviceUsage(in.device_usage, *out.deviceUsage);
  }
}
 
}