delete obsolete asn1 parser files (b0cc3163) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Asn1c/Asn1cEncDec.cc

deleted100644 → 0

+0 −240

Original line number	Diff line number	Diff line
		#include "Asn1cEncDec.hh"
		#include "loggers.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);
		//}


		extern "C" int asn1c_collect_encoded_data(const void buffer, size_t size, void application_specific_key)
		{
		TTCN_Buffer * tb = (TTCN_Buffer *)application_specific_key;
		tb->put_s(size, (unsigned char *)buffer);
		loggers::get_instance().log_to_hexa("asn1c_collect_encoded_data: Encoding=", *tb);
		return 0;
		}

		// PER Encoding
		#include <ber_decoder.h>
		#include <der_encoder.h>
		#include <per_encoder.h>
		#include <per_decoder.h>

		int asn1c_per2ber(asn_TYPE_descriptor_t &td, const TTCN_Buffer & per, TTCN_Buffer & ber, void** ctx )
		{
		//void** obj = ctx;
		int rc = -1;
		asn_dec_rval_t rc_d;

		rc_d = uper_decode_complete(NULL,
		&td, ctx,
		per.get_read_data(), per.get_read_len());

		if(rc_d.code == RC_OK){
		asn_enc_rval_t rc_e;
		ber.clear();
		rc_e = der_encode(&td,
		(const asn_per_constraints_t*)ctx,
		asn1c_collect_encoded_data,
		&ber);
		rc = rc_e.encoded;
		}
		/*if(obj) {
		ASN_STRUCT_FREE(td, obj);
		}*/
		return rc;
		}

		int asn1c_ber2per(asn_TYPE_descriptor_t &td, const TTCN_Buffer & ber, TTCN_Buffer & per, void** ctx )
		{
		//void** obj = ctx;
		int rc = -1;
		asn_dec_rval_t rc_d;
		rc_d = ber_decode( NULL, &td,
		ctx,
		ber.get_data(), ber.get_len());
		if(rc_d.code == RC_OK){
		loggers::get_instance().log("asn1c_ber2per: BER decoding succeed");
		asn_enc_rval_t rc_e;
		//per.clear();
		rc_e = uper_encode(&td,
		NULL,
		ctx,
		asn1c_collect_encoded_data,
		&per);
		rc = rc_e.encoded;
		if(rc < 0) {
		loggers::get_instance().warning("asn1c_ber2per: PER encoding failed");
		}
		} else {
		loggers::get_instance().warning("asn1c_ber2per: BER decoding failed");
		// td.free_struct(&td, *ctx, 0);
		}
		/*if(obj) {
		ASN_STRUCT_FREE(td, obj);
		}*/
		return rc;
		}

		// OER Encoding
		//#include <xer_decoder.h>
		//#include <xer_encoder.h>
		//#include <oer_decoder.h>
		//#include <oer_encoder.h>
		//
		//int asn1c_oer2xer(asn_TYPE_descriptor_t &td, const TTCN_Buffer & oer, TTCN_Buffer & xer, void** ctx )
		//{
		// //void** obj = ctx;
		// int rc = -1;
		// asn_dec_rval_t rc_d;
		//
		// rc_d = oer_decode(NULL,
		// &td, ctx,
		// oer.get_read_data(), oer.get_read_len());
		//
		// if(rc_d.code == RC_OK){
		// asn_enc_rval_t rc_e;
		// xer.clear();
		// rc_e = xer_encode(&td,
		// (const asn_oer_constraints_t*)ctx,
		// XER_F_BASIC,
		// asn1c_collect_encoded_data,
		// &xer);
		// rc = rc_e.encoded;
		// }
		// /*if(obj) {
		// ASN_STRUCT_FREE(td, obj);
		// }*/
		// return rc;
		//}
		//
		//
		//int asn1c_xer2oer(asn_TYPE_descriptor_t &td, const TTCN_Buffer & xer, TTCN_Buffer & oer, void** ctx )
		//{
		// //void** obj = ctx;
		// int rc = -1;
		// asn_dec_rval_t rc_d;
		// rc_d = xer_decode( NULL, &td,
		// ctx,
		// xer.get_data(), xer.get_len());
		// if(rc_d.code == RC_OK){
		// loggers::get_instance().log("asn1c_ber2per: XER decoding succeed");
		// asn_enc_rval_t rc_e;
		// //per.clear();
		// rc_e = oer_encode(&td,
		// ctx,
		// asn1c_collect_encoded_data,
		// &oer);
		// rc = rc_e.encoded;
		// if(rc < 0) {
		// loggers::get_instance().warning("asn1c_ber2per: OER encoding failed");
		// }
		// } else {
		// loggers::get_instance().warning("asn1c_ber2per: XER decoding failed");
		// // td.free_struct(&td, *ctx, 0);
		// }
		// /*if(obj) {
		// ASN_STRUCT_FREE(td, obj);
		// }*/
		// return rc;
		//}

ccsrc/Asn1c/Asn1cEncDec.hh

deleted100644 → 0

+0 −84

Original line number	Diff line number	Diff line
		#pragma once

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

		// include ASN1C sceleton
		#include "asn1c/INTEGER.h"
		#include "asn1c/BOOLEAN.h"
		#include "asn1c/OCTET_STRING.h"
		#include "asn1c/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;
		//}

		int asn1c_per2ber(asn_TYPE_descriptor_t &td, const TTCN_Buffer & per, TTCN_Buffer & ber, void** ctx );
		int asn1c_ber2per(asn_TYPE_descriptor_t &td, const TTCN_Buffer & ber, TTCN_Buffer & per, void** ctx );
		// int asn1c_oer2xer(asn_TYPE_descriptor_t &td, const TTCN_Buffer & oer, TTCN_Buffer & xer, void** ctx );
		// int asn1c_xer2oer(asn_TYPE_descriptor_t &td, const TTCN_Buffer & xer, TTCN_Buffer & oer, void** ctx );

ccsrc/Asn1c/ITS_ContainerCodec.cc

deleted100644 → 0

+0 −412

Original line number	Diff line number	Diff line
		//#include "ITS_ContainerCodec.hh"
		//#include "asn1/ItsPduHeader.h"
		//#include "asn1/ReferencePosition.h"
		//#include "asn1/PathHistory.h"
		//#include "asn1/ProtectedCommunicationZonesRSU.h"
		//#include "asn1/Heading.h"
		//#include "asn1/Speed.h"
		//#include "asn1/VehicleLength.h"
		//#include "asn1/LongitudinalAcceleration.h"
		//#include "asn1/Curvature.h"
		//#include "asn1/YawRate.h"
		//#include "asn1/SteeringWheelAngle.h"
		//#include "asn1/LateralAcceleration.h"
		//#include "asn1/VerticalAcceleration.h"
		//#include "asn1/CenDsrcTollingZone.h"
		//#include "asn1/CauseCode.h"
		//#include "asn1/PtActivation.h"
		//#include "asn1/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, 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, 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

deleted100644 → 0

+0 −126

File deleted.

Preview size limit exceeded, changes collapsed.