CAM Codec using asn1c (c1b4f354) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Asn1c/Asn1cEncDec.cc

0 → 100755

+104 −0

Original line number	Diff line number	Diff line
		#include "Asn1cEncDec.hh"

		// basic types
		void titan2asn1c(const INTEGER& t, long& a)
		{
		if(t.is_native()){
		a = (int)t;
		}else{
		long long int n = t.get_long_long_val();
		if(n >= LONG_MIN && n <= LONG_MAX){
		a = (long)n;
		}else{
		// TODO: what to do here?
		}
		}
		}

		void titan2asn1c(const INTEGER& t, unsigned long& a)
		{
		if(t.is_native()){
		int n = (int)t;
		if(n >= 0) {
		a = (unsigned)n;
		}else{
		// TODO: what to do here?
		}
		}else{
		long long int n = t.get_long_long_val();
		if(n >= 0 && n <= (long long int)ULONG_MAX){
		a = (unsigned long)n;
		}else{
		// TODO: what to do here?
		}
		}
		}

		void titan2asn1c(const INTEGER& t, INTEGER_t& a) {
		if(t.is_native()){
		asn_long2INTEGER(&a, (int)t);
		}else{
		long long int n = t.get_long_long_val();
		if(n >= LONG_MIN && n <= LONG_MAX){
		asn_long2INTEGER(&a, (long)n);
		}else if(n <= (long long int)ULONG_MAX){
		asn_ulong2INTEGER(&a, (unsigned long)n);
		}else{
		// TODO: what to do here?
		}
		}
		}

		INTEGER asn1c2titan(const INTEGER_t& a) {
		long n;
		unsigned long un;
		INTEGER i;

		if( 0 == asn_INTEGER2long(&a, &n)) {
		i.set_long_long_val((long long int)n);
		}else if( 0 == asn_INTEGER2ulong(&a, &un)) {
		i.set_long_long_val((long long int)un);
		}else{
		//TODO: What to do?
		}
		return i;
		}

		INTEGER asn1c2titan(long n)
		{
		INTEGER i;
		i.set_long_long_val(n);
		return i;
		}

		INTEGER asn1c2titan(unsigned long n)
		{
		INTEGER i;
		i.set_long_long_val(n);
		return i;
		}

		void titan2asn1c(const BOOLEAN& t, BOOLEAN_t& a) {
		a = ((boolean)t) ? 0xFF : 0x00;
		}

		BOOLEAN asn1c2titan(const BOOLEAN_t& a) {
		return BOOLEAN(!!a);
		}

		void titan2asn1c(const OCTETSTRING& t, OCTET_STRING_t& a) {
		OCTET_STRING_fromBuf(&a, (const char)(const unsigned char)t, t.lengthof());
		}

		OCTETSTRING asn1c2titan(const OCTET_STRING_t& a) {
		return OCTETSTRING(a.size, a.buf);
		}

		void titan2asn1c(const BITSTRING& t, BIT_STRING_t& a) {
		int buf_size = (t.lengthof()+7)/8;
		OCTET_STRING_fromBuf((OCTET_STRING_t)&a, (const char)(const unsigned char*)t, buf_size);
		a.bits_unused = (buf_size*8) - t.lengthof();
		}
		BITSTRING asn1c2titan(const BIT_STRING_t& a) {
		return BITSTRING(a.size*8 - a.bits_unused, a.buf);
		}

ccsrc/Asn1c/Asn1cEncDec.hh

0 → 100755

+83 −0

Original line number	Diff line number	Diff line
		#ifndef ASN1CENCDEC_HH
		#define ASN1CENCDEC_HH

		// include titan headers
		#include "TTCN3.hh"

		// include ASN1C sceleton
		#include "asn1/INTEGER.h"
		#include "asn1/BOOLEAN.h"
		#include "asn1/OCTET_STRING.h"
		#include "asn1/BIT_STRING.h"

		extern "C" {
		int asn1c_collect_encoded_data(const void buffer, size_t size, void application_specific_key);
		}

		// OPTIONAL is defined somewhere in WIN32
		#ifdef OPTIONAL
		#undef OPTIONAL
		#endif

		template<typename TT, typename TA>
		TT asn1c2titan(const TA& a) {
		// default implementation:
		return TT(a);
		}

		// basic types
		void titan2asn1c(const INTEGER& t, long& a);
		void titan2asn1c(const INTEGER& t, unsigned long& a);
		void titan2asn1c(const INTEGER& t, INTEGER_t& a);
		void titan2asn1c(const BOOLEAN& t, BOOLEAN_t& a);
		void titan2asn1c(const OCTETSTRING& t, OCTET_STRING_t& a);
		void titan2asn1c(const BITSTRING& t, BIT_STRING_t& a);

		INTEGER asn1c2titan(const INTEGER_t&);
		INTEGER asn1c2titan(long);
		OCTETSTRING asn1c2titan(const OCTET_STRING_t&);
		BITSTRING asn1c2titan(const BIT_STRING_t&);

		// template for optional value
		template <typename TT, typename TA>
		OPTIONAL<TT> asn1c2titan_opt(const TA * pa) {
		if(pa) {
		return OPTIONAL<TT>(asn1c2titan(*pa));
		}
		return OPTIONAL<TT>(OMIT_VALUE);
		}

		template <typename TT, typename TA>
		void titan2asn1c_opt(const OPTIONAL<TT> & ot, TA *& a){
		if(ot.is_present()){
		a = new TA;
		titan2asn1c((const TT&)ot, *a);
		}else{
		a = NULL;
		}
		}

		template<typename T, typename TS, typename TA>
		void titan2asn1c_seq(const TS& t, TA& a){
		a.list.array = (T*)calloc(t.n_elem(), sizeof(void));
		a.list.count = t.n_elem();
		a.list.size = sizeof(void)a.list.count;
		for (int i = 0; i < t.n_elem(); i++){
		a.list.array[i] = (T*)malloc(sizeof(T));
		titan2asn1c(t[i], *a.list.array[i]);
		}
		}

		template<typename TS, typename TA>
		TS asn1c2titan_seq(const TA& a)
		{
		TS t;
		t.set_size(a.list.count);
		for (int i = 0; i < a.list.count; i++){
		t[i] = asn1c2titan(*a.list.array[i]);
		}
		return t;
		}


		#endif

ccsrc/Asn1c/ITS_ContainerCodec.cc

0 → 100755

+412 −0

Original line number	Diff line number	Diff line
		#include "ITS_ContainerCodec.hh"
		#include "ItsPduHeader.h"
		#include "ReferencePosition.h"
		#include "PathHistory.h"
		#include "ProtectedCommunicationZonesRSU.h"
		#include "Heading.h"
		#include "Speed.h"
		#include "VehicleLength.h"
		#include "LongitudinalAcceleration.h"
		#include "Curvature.h"
		#include "YawRate.h"
		#include "SteeringWheelAngle.h"
		#include "LateralAcceleration.h"
		#include "VerticalAcceleration.h"
		#include "CenDsrcTollingZone.h"
		#include "CauseCode.h"
		#include "PtActivation.h"
		#include "ClosedLanes.h"

		#define T2A(F) titan2asn1c(t.F(), a.F)
		#define T2A_O(F) titan2asn1c_opt(t.F(), a.F)
		#define A2T(F) asn1c2titan(a.F)
		#define A2T_O(T,F) asn1c2titan_opt<T>(a.F)

		void titan2asn1c(const ITS__Container::ItsPduHeader& t, ItsPduHeader& a)
		{
		T2A(protocolVersion);
		T2A(messageID);
		T2A(stationID);
		}
		ITS__Container::ItsPduHeader asn1c2titan(const ItsPduHeader& a)
		{
		return ITS__Container::ItsPduHeader(
		asn1c2titan(a.protocolVersion),
		asn1c2titan(a.messageID),
		asn1c2titan(a.stationID)
		);
		}

		// ReferencePosition
		void titan2asn1c(const ITS__Container::ReferencePosition& t, ReferencePosition& a)
		{
		titan2asn1c(t.latitude(), a.latitude);
		titan2asn1c(t.longitude(), a.longitude);
		titan2asn1c(t.positionConfidenceEllipse(), a.positionConfidenceEllipse);
		titan2asn1c(t.altitude(), a.altitude);
		}
		ITS__Container::ReferencePosition asn1c2titan(const ReferencePosition& a)
		{
		return ITS__Container::ReferencePosition(
		asn1c2titan(a.latitude),
		asn1c2titan(a.longitude),
		asn1c2titan(a.positionConfidenceEllipse),
		asn1c2titan(a.altitude)
		);
		}

		// VehicleRole
		void titan2asn1c(const ITS__Container::VehicleRole& t, long& a)
		{
		a = t.as_int();
		}

		// DeltaReferencePosition
		void titan2asn1c(const ITS__Container::DeltaReferencePosition& t, DeltaReferencePosition& a)
		{

		titan2asn1c(t.deltaLatitude(), a.deltaLatitude);
		titan2asn1c(t.deltaLongitude(), a.deltaLongitude);
		titan2asn1c(t.deltaAltitude(), a.deltaAltitude);
		}
		ITS__Container::DeltaReferencePosition asn1c2titan(const DeltaReferencePosition& a)
		{
		return ITS__Container::DeltaReferencePosition(
		asn1c2titan(a.deltaLatitude),
		asn1c2titan(a.deltaLongitude),
		asn1c2titan(a.deltaAltitude)
		);
		}

		//PathPoint
		void titan2asn1c(const ITS__Container::PathPoint& t, PathPoint& a)
		{
		titan2asn1c(t.pathPosition(), a.pathPosition);
		titan2asn1c_opt(t.pathDeltaTime(), a.pathDeltaTime);
		}
		const ITS__Container::PathPoint asn1c2titan(const PathPoint& a)
		{
		return ITS__Container::PathPoint(
		asn1c2titan(a.pathPosition),
		asn1c2titan_opt<INTEGER>(a.pathDeltaTime)
		);
		}

		//PathHistory
		void titan2asn1c(const ITS__Container::PathHistory& t, PathHistory& a)
		{
		titan2asn1c_seq<PathPoint_t>(t, a);
		}

		ITS__Container::PathHistory asn1c2titan(const PathHistory& a)
		{
		return asn1c2titan_seq<ITS__Container::PathHistory>(a);
		}

		// ProtectedCommunicationZone
		void titan2asn1c(const ITS__Container::ProtectedZoneType& t, ProtectedZoneType_t& a)
		{
		a = t.as_int();
		}

		// ProtectedCommunicationZone
		void titan2asn1c(const ITS__Container::ProtectedCommunicationZone& t, ProtectedCommunicationZone_t& a)
		{
		T2A(protectedZoneType);
		T2A_O(expiryTime);
		T2A(protectedZoneLatitude);
		T2A(protectedZoneLongitude);
		T2A_O(protectedZoneRadius);
		T2A_O(protectedZoneID);
		}
		ITS__Container::ProtectedCommunicationZone asn1c2titan(const ProtectedCommunicationZone_t& a)
		{
		return ITS__Container::ProtectedCommunicationZone(
		asn1c2titan<ITS__Container::ProtectedZoneType>(a.protectedZoneType),
		A2T_O(INTEGER, expiryTime),
		A2T(protectedZoneLatitude),
		A2T(protectedZoneLongitude),
		A2T_O(INTEGER, protectedZoneRadius),
		A2T_O(INTEGER, protectedZoneID)
		);
		}

		// ProtectedCommunicationZonesRSU
		void titan2asn1c(const ITS__Container::ProtectedCommunicationZonesRSU& t, ProtectedCommunicationZonesRSU& a)
		{
		titan2asn1c_seq<ProtectedCommunicationZone_t>(t, a);
		}

		ITS__Container::ProtectedCommunicationZonesRSU asn1c2titan(const ProtectedCommunicationZonesRSU& a)
		{
		return asn1c2titan_seq<ITS__Container::ProtectedCommunicationZonesRSU>(a);
		}

		// Heading
		void titan2asn1c(const ITS__Container::Heading& t, Heading& a)
		{
		titan2asn1c(t.headingValue(), a.headingValue);
		titan2asn1c(t.headingConfidence(), a.headingConfidence);
		}
		ITS__Container::Heading asn1c2titan(const Heading& a)
		{
		return ITS__Container::Heading(
		asn1c2titan(a.headingValue),
		asn1c2titan(a.headingConfidence)
		);
		}

		// Speed
		void titan2asn1c(const ITS__Container::Speed& t, Speed& a)
		{
		titan2asn1c(t.speedValue(), a.speedValue);
		titan2asn1c(t.speedConfidence(), a.speedConfidence);
		}
		ITS__Container::Speed asn1c2titan(const Speed& a)
		{
		return ITS__Container::Speed(
		asn1c2titan(a.speedValue),
		asn1c2titan(a.speedConfidence)
		);
		}

		void titan2asn1c(const ITS__Container::VehicleLengthConfidenceIndication& t, VehicleLengthConfidenceIndication_t& a)
		{
		a = t.as_int();
		}

		// VehicleLength
		void titan2asn1c(const ITS__Container::VehicleLength& t, VehicleLength& a)
		{
		titan2asn1c(t.vehicleLengthValue(), a.vehicleLengthValue);
		titan2asn1c(t.vehicleLengthConfidenceIndication(), a.vehicleLengthConfidenceIndication);
		}
		ITS__Container::VehicleLength asn1c2titan(const VehicleLength& a)
		{
		return ITS__Container::VehicleLength(
		asn1c2titan(a.vehicleLengthValue),
		asn1c2titan<ITS__Container::VehicleLengthConfidenceIndication>(a.vehicleLengthConfidenceIndication)
		);
		}

		// LongitudinalAcceleration
		void titan2asn1c(const ITS__Container::LongitudinalAcceleration& t, LongitudinalAcceleration& a)
		{
		titan2asn1c(t.longitudinalAccelerationValue(), a.longitudinalAccelerationValue);
		titan2asn1c(t.longitudinalAccelerationConfidence(), a.longitudinalAccelerationConfidence);
		}
		ITS__Container::LongitudinalAcceleration asn1c2titan(const LongitudinalAcceleration& a)
		{
		return ITS__Container::LongitudinalAcceleration(
		asn1c2titan(a.longitudinalAccelerationValue),
		asn1c2titan(a.longitudinalAccelerationConfidence)
		);
		}

		// CurvatureConfidence
		void titan2asn1c(const ITS__Container::CurvatureConfidence& t, CurvatureConfidence_t& a)
		{
		a = t.as_int();
		}

		// Curvature
		void titan2asn1c(const ITS__Container::Curvature& t, Curvature& a)
		{
		titan2asn1c(t.curvatureValue(), a.curvatureValue);
		titan2asn1c(t.curvatureConfidence(), a.curvatureConfidence);
		}
		ITS__Container::Curvature asn1c2titan(const Curvature& a)
		{
		return ITS__Container::Curvature(
		asn1c2titan(a.curvatureValue),
		asn1c2titan<ITS__Container::CurvatureConfidence>(a.curvatureConfidence)
		);
		}

		// YawRateConfidence
		void titan2asn1c(const ITS__Container::YawRateConfidence& t, YawRateConfidence_t& a)
		{
		a = t.as_int();
		}

		// YawRate
		void titan2asn1c(const ITS__Container::YawRate&t, YawRate& a)
		{
		titan2asn1c(t.yawRateValue(), a.yawRateValue);
		titan2asn1c(t.yawRateConfidence(), a.yawRateConfidence);
		}

		ITS__Container::YawRate asn1c2titan(const YawRate& a)
		{
		return ITS__Container::YawRate(
		asn1c2titan(a.yawRateValue),
		asn1c2titan<ITS__Container::YawRateConfidence>(a.yawRateConfidence)
		);
		}

		// SteeringWheelAngle
		void titan2asn1c(const ITS__Container::SteeringWheelAngle&t, SteeringWheelAngle& a)
		{
		titan2asn1c(t.steeringWheelAngleValue(), a.steeringWheelAngleValue);
		titan2asn1c(t.steeringWheelAngleConfidence(), a.steeringWheelAngleConfidence);
		}

		ITS__Container::SteeringWheelAngle asn1c2titan(const SteeringWheelAngle& a)
		{
		return ITS__Container::SteeringWheelAngle(
		asn1c2titan(a.steeringWheelAngleValue),
		asn1c2titan(a.steeringWheelAngleConfidence)
		);
		}

		// LateralAcceleration
		void titan2asn1c(const ITS__Container::LateralAcceleration&t, LateralAcceleration& a)
		{
		titan2asn1c(t.lateralAccelerationValue(), a.lateralAccelerationValue);
		titan2asn1c(t.lateralAccelerationConfidence(), a.lateralAccelerationConfidence);
		}

		ITS__Container::LateralAcceleration asn1c2titan(const LateralAcceleration& a)
		{
		return ITS__Container::LateralAcceleration(
		asn1c2titan(a.lateralAccelerationValue),
		asn1c2titan(a.lateralAccelerationConfidence)
		);
		}

		// VerticalAcceleration
		void titan2asn1c(const ITS__Container::VerticalAcceleration&t, VerticalAcceleration& a)
		{
		T2A(verticalAccelerationValue);
		T2A(verticalAccelerationConfidence);
		}
		ITS__Container::VerticalAcceleration asn1c2titan(const VerticalAcceleration& a)
		{
		return ITS__Container::VerticalAcceleration(
		A2T(verticalAccelerationValue),
		A2T(verticalAccelerationConfidence)
		);
		}

		// CenDsrcTollingZone
		void titan2asn1c(const ITS__Container::CenDsrcTollingZone&t, CenDsrcTollingZone& a)
		{
		T2A(protectedZoneLatitude);
		T2A(protectedZoneLongitude);
		T2A_O(cenDsrcTollingZoneID);
		}
		ITS__Container::CenDsrcTollingZone asn1c2titan(const CenDsrcTollingZone& a)
		{
		return ITS__Container::CenDsrcTollingZone(
		A2T(protectedZoneLatitude),
		A2T(protectedZoneLongitude),
		A2T_O(INTEGER, cenDsrcTollingZoneID)
		);
		}

		// DriveDirection
		void titan2asn1c(const ITS__Container::DriveDirection&t, long& a)
		{
		a = t.as_int();
		}

		// CurvatureCalculationMode
		void titan2asn1c(const ITS__Container::CurvatureCalculationMode&t, long& a)
		{
		a = t.as_int();
		}

		// DangerousGoodsBasic
		void titan2asn1c(const ITS__Container::DangerousGoodsBasic&t, long& a)
		{
		a = t.as_int();
		}

		// CauseCode
		void titan2asn1c(const ITS__Container::CauseCode&t, CauseCode& a)
		{
		T2A(causeCode);
		T2A(subCauseCode);
		}
		ITS__Container::CauseCode asn1c2titan(const CauseCode& a)
		{
		return ITS__Container::CauseCode(
		A2T(causeCode),
		A2T(subCauseCode)
		);
		}

		// TrafficRule
		void titan2asn1c(const ITS__Container::TrafficRule&t, long& a)
		{
		a = t.as_int();
		}


		// PtActivation
		void titan2asn1c(const ITS__Container::PtActivation&t, PtActivation& a)
		{
		T2A(ptActivationType);
		T2A(ptActivationData);
		}
		ITS__Container::PtActivation asn1c2titan(const PtActivation& a)
		{
		return ITS__Container::PtActivation(
		A2T(ptActivationType),
		A2T(ptActivationData)
		);
		}

		//
		void titan2asn1c(const ITS__Container::HardShoulderStatus&t, HardShoulderStatus_t& a)
		{
		a = t.as_int();
		}

		//ClosedLanes
		void titan2asn1c(const ITS__Container::ClosedLanes&t, ClosedLanes& a)
		{
		T2A_O(hardShoulderStatus);
		T2A(drivingLaneStatus);
		}
		ITS__Container::ClosedLanes asn1c2titan(const ClosedLanes& a)
		{
		return ITS__Container::ClosedLanes(
		A2T_O(ITS__Container::HardShoulderStatus, hardShoulderStatus),
		A2T(drivingLaneStatus)
		);
		}

		void titan2asn1c(const ITS__Container::PosConfidenceEllipse&t, PosConfidenceEllipse& a)
		{
		T2A(semiMajorConfidence);
		T2A(semiMinorConfidence);
		T2A(semiMajorOrientation);
		}
		ITS__Container::PosConfidenceEllipse asn1c2titan(const PosConfidenceEllipse& a)
		{
		return ITS__Container::PosConfidenceEllipse(
		A2T(semiMajorConfidence),
		A2T(semiMinorConfidence),
		A2T(semiMajorOrientation)
		);
		}

		void titan2asn1c(const ITS__Container::AltitudeConfidence&t, AltitudeConfidence_t& a)
		{
		a = t.as_int();
		}

		void titan2asn1c(const ITS__Container::Altitude&t, Altitude& a)
		{
		T2A(altitudeValue);
		T2A(altitudeConfidence);
		}

		ITS__Container::Altitude asn1c2titan(const Altitude& a)
		{
		return ITS__Container::Altitude(
		A2T(altitudeValue),
		asn1c2titan<AltitudeConfidence>(a.altitudeConfidence)
		);
		}

ccsrc/Asn1c/ITS_ContainerCodec.hh

0 → 100755

+126 −0

Original line number	Diff line number	Diff line
		#ifndef ITS_ContainerCodec_HH
		#define ITS_ContainerCodec_HH

		#include "Asn1cEncDec.hh"
		#include "ITS_Container.hh"

		// ItsPduHeader
		struct ItsPduHeader;
		void titan2asn1c(const ITS__Container::ItsPduHeader&, ItsPduHeader&);
		ITS__Container::ItsPduHeader asn1c2titan(const ItsPduHeader& a);

		// ReferencePosition
		struct ReferencePosition;
		void titan2asn1c(const ITS__Container::ReferencePosition&, ReferencePosition& a);
		ITS__Container::ReferencePosition asn1c2titan(const ReferencePosition& a);

		// VehicleRole
		void titan2asn1c(const ITS__Container::VehicleRole&, long& a);
		//template <>
		//ITS__Container::VehicleRole asn1c2titan<ITS__Container::VehicleRole>(const long& a);

		//PathHistory
		struct PathHistory;
		void titan2asn1c(const ITS__Container::PathHistory&, PathHistory& a);
		ITS__Container::PathHistory asn1c2titan(const PathHistory& a);

		// ProtectedCommunicationZonesRSU
		struct ProtectedCommunicationZonesRSU;
		void titan2asn1c(const ITS__Container::ProtectedCommunicationZonesRSU&, ProtectedCommunicationZonesRSU&);
		ITS__Container::ProtectedCommunicationZonesRSU asn1c2titan(const ProtectedCommunicationZonesRSU&);

		// Heading
		struct Heading;
		void titan2asn1c(const ITS__Container::Heading&, Heading& a);
		ITS__Container::Heading asn1c2titan(const Heading& a);

		// Speed
		struct Speed;
		void titan2asn1c(const ITS__Container::Speed&, Speed& a);
		ITS__Container::Speed asn1c2titan(const Speed& a);

		// VehicleLength
		struct VehicleLength;
		void titan2asn1c(const ITS__Container::VehicleLength&, VehicleLength& a);
		ITS__Container::VehicleLength asn1c2titan(const VehicleLength& a);

		// LongitudinalAcceleration
		struct LongitudinalAcceleration;
		void titan2asn1c(const ITS__Container::LongitudinalAcceleration&, LongitudinalAcceleration& a);
		ITS__Container::LongitudinalAcceleration asn1c2titan(const LongitudinalAcceleration& a);

		// Curvature
		struct Curvature;
		void titan2asn1c(const ITS__Container::Curvature&, Curvature& a);
		ITS__Container::Curvature asn1c2titan(const Curvature& a);

		// YawRate
		struct YawRate;
		void titan2asn1c(const ITS__Container::YawRate&, YawRate& a);
		ITS__Container::YawRate asn1c2titan(const YawRate& a);

		// SteeringWheelAngle
		struct SteeringWheelAngle;
		void titan2asn1c(const ITS__Container::SteeringWheelAngle&, SteeringWheelAngle& a);
		ITS__Container::SteeringWheelAngle asn1c2titan(const SteeringWheelAngle& a);

		// LateralAcceleration
		struct LateralAcceleration;
		void titan2asn1c(const ITS__Container::LateralAcceleration&, LateralAcceleration& a);
		ITS__Container::LateralAcceleration asn1c2titan(const LateralAcceleration& a);

		// VerticalAcceleration
		struct VerticalAcceleration;
		void titan2asn1c(const ITS__Container::VerticalAcceleration&, VerticalAcceleration& a);
		ITS__Container::VerticalAcceleration asn1c2titan(const VerticalAcceleration& a);

		// CenDsrcTollingZone
		struct CenDsrcTollingZone;
		void titan2asn1c(const ITS__Container::CenDsrcTollingZone&, CenDsrcTollingZone& a);
		ITS__Container::CenDsrcTollingZone asn1c2titan(const CenDsrcTollingZone& a);

		// DriveDirection
		void titan2asn1c(const ITS__Container::DriveDirection&, long& a);

		// CurvatureCalculationMode
		void titan2asn1c(const ITS__Container::CurvatureCalculationMode&, long&);

		// DangerousGoodsBasic
		void titan2asn1c(const ITS__Container::DangerousGoodsBasic&, long& a);

		// CauseCode
		struct CauseCode;
		void titan2asn1c(const ITS__Container::CauseCode&, CauseCode& a);
		ITS__Container::CauseCode asn1c2titan(const CauseCode& a);

		// TrafficRule
		void titan2asn1c(const ITS__Container::TrafficRule&t, long& a);

		// PtActivation
		struct PtActivation;
		void titan2asn1c(const ITS__Container::PtActivation&t, PtActivation& a);
		ITS__Container::PtActivation asn1c2titan(const PtActivation& a);

		//ClosedLanes
		struct ClosedLanes;
		void titan2asn1c(const ITS__Container::ClosedLanes&t, ClosedLanes& a);
		ITS__Container::ClosedLanes asn1c2titan(const ClosedLanes& a);

		// PosConfidenceEllipse
		struct PosConfidenceEllipse;
		void titan2asn1c(const ITS__Container::PosConfidenceEllipse&t, PosConfidenceEllipse& a);
		ITS__Container::PosConfidenceEllipse asn1c2titan(const PosConfidenceEllipse& a);

		struct Altitude;
		void titan2asn1c(const ITS__Container::Altitude&t, Altitude& a);
		ITS__Container::Altitude asn1c2titan(const Altitude& a);



		/*
		struct TYPE;
		void titan2asn1c(const ITS__Container::TYPE&t, TYPE& a);
		ITS__Container::TYPE asn1c2titan(const TYPE& a);
		*/

		#endif

ccsrc/Protocols/CAM/CAMCodec.cc

0 → 100755

+512 −0

File added.

Preview size limit exceeded, changes collapsed.

Admin message