apiCDD.cpp

Go to the documentation of this file.

#include <apiCDD.h>
#include <QHash>

/*******************************
 * Constraints
 ******************************/
/* ASN */
void constr_BIT_STRING(BIT_STRING_t *b, quint64 min, quint64 max)
{
    if(((min + 7) / 8) < (quint64)b->size || ((max + 7) / 8) > (quint64)b->size)
        *b = make_BIT_STRING(min);
}

void constr_BIT_STRING(BIT_STRING_t *b, quint64 length)
{
    if((length + 7) / 8 != (quint64)b->size)
        *b = make_BIT_STRING(length);
    else
        b->bits_unused = (8 - (length % 8)) % 8;
}

void constr_BOOLEAN(BOOLEAN_t *b)
{
    if(*b < 0)
        *b = 0;
    else if(*b > 1)
        *b = 1;
}

void constr_INTEGER(INTEGER_t *i, quint64 min, quint64 max, quint64 minOutOfRange, quint64 maxOutOfRange)
{
    long int value;

    asn_INTEGER2long(i, &value);

    if((quint64)value < min)
        asn_long2INTEGER(i, minOutOfRange);
    else if((quint64)value > max)
        asn_long2INTEGER(i, maxOutOfRange);
}

void constr_INTEGER(INTEGER_t *i, quint64 min, quint64 max, quint64 outOfRange)
{
    long int value;

    asn_INTEGER2long(i, &value);

    if((quint64)value < min || (quint64)value > max)
        asn_long2INTEGER(i, outOfRange);
}

void constr_INTEGER(INTEGER_t *i, quint64 min, quint64 max)
{
    long int value;

    asn_INTEGER2long(i, &value);

    if((quint64)value < min)
        asn_long2INTEGER(i, min);
    else if((quint64)value > max)
        asn_long2INTEGER(i, max);
}

void constr_int(long int *i, qint64 min, qint64 max, qint64 minOutOfRange, qint64 maxOutOfRange)
{
    if(*i < min)
        *i = minOutOfRange;
    else if(*i > max)
        *i = maxOutOfRange;
}

void constr_int(long int *i, qint64 min, qint64 max)
{
    if(*i < min)
        *i = min;
    else if(*i > max)
        *i = max;
}

void constr_int(long int *i, qint64 min, qint64 max, quint64 outOfRange)
{
    if(*i < min || *i > max)
        *i = outOfRange;
}

void constr_OCTET_STRING(OCTET_STRING_t *o, quint64 min, quint64 max)
{
    if((quint64)o->size < min || (quint64)o->size > max)
        *o = make_OCTET_STRING(min);
}

void constr_OCTET_STRING(OCTET_STRING_t *o, quint64 length)
{
    if((quint64)o->size < length || (quint64)o->size > length)
        *o = make_OCTET_STRING(length);
}

/* DE */
void constr_AccelerationConfidence(AccelerationConfidence_t *a){constr_int(a, 0, 101, AccelerationConfidence_outOfRange);}
void constr_AccelerationControl(AccelerationControl_t *a){constr_BIT_STRING(a, 7);}
void constr_AltitudeConfidence(AltitudeConfidence_t *a){constr_int(a, 0, 15, AltitudeConfidence_outOfRange);}
void constr_AltitudeValue(AltitudeValue_t *a){constr_int(a, -100000, 800001, -100000, 800000);}
void constr_CauseCodeType(CauseCodeType_t *c){constr_int(c, 0, 255, CauseCodeType_reserved);}
void constr_CenDsrcTollingZoneID(CenDsrcTollingZoneID_t *c){constr_ProtectedZoneID(c);}
void constr_CurvatureCalculationMode(CurvatureCalculationMode_t *c){constr_int(c, 0, 2, CurvatureCalculationMode_unavailable);}
void constr_CurvatureConfidence(CurvatureConfidence_t *c){constr_int(c, 0, 7, CurvatureConfidence_outOfRange);}
void constr_CurvatureValue(CurvatureValue_t *c){constr_int(c, -30000, 30001, -30000, 30000);}
void constr_DangerousGoodsBasic(DangerousGoodsBasic_t *d){constr_int(d, 0, 19, DangerousGoodsBasic_miscellaneousDangerousSubstances);}
void constr_DeltaAltitude(DeltaAltitude_t *d){constr_int(d, -12700, 12800, -12700, 12799);}
void constr_DeltaLatitude(DeltaLatitude_t *d){constr_int(d, -131071, 131072, -131071, 131072);}
void constr_DeltaLongitude(DeltaLongitude_t *d){constr_int(d, -131071, 131072, -131071, 131072);}
void constr_DriveDirection(DriveDirection_t *d){constr_int(d, 0, 2, DriveDirection_unavailable);}
void constr_DrivingLaneStatus(DrivingLaneStatus_t *d){constr_BIT_STRING(d, 1, 14);}
void constr_EmbarkationStatus(EmbarkationStatus_t *e){constr_BOOLEAN(e);}
void constr_EmergencyPriority(EmergencyPriority_t *e){constr_BIT_STRING(e, 2);}
void constr_EnergyStorageType(EnergyStorageType_t *e){constr_BIT_STRING(e, 7);}
void constr_ExteriorLights(ExteriorLights_t *e){constr_BIT_STRING(e, 8);}
void constr_HardShoulderStatus(HardShoulderStatus_t *h){constr_int(h, 0, 2, HardShoulderStatus_availableForDriving);}
void constr_HeadingConfidence(HeadingConfidence_t *h){constr_int(h, 1, 127, 125, 126);}
void constr_HeadingValue(HeadingValue_t *h){constr_int(h, 0, 3601, 3600, 0);}
void constr_HeightLonCarr(HeightLonCarr_t *h){constr_int(h, 1, 100, 1, 99);}
void constr_InformationQuality(InformationQuality_t *i){constr_int(i, 0, 7, InformationQuality_unavailable);}
void constr_LanePosition(LanePosition_t *l){constr_int(l, -1, 14, LanePosition_outermostDrivingLane);}
void constr_Latitude(Latitude_t *l){constr_int(l, -900000000, 900000001, -900000000, 900000000);}
void constr_LateralAccelerationValue(LateralAccelerationValue_t *l){constr_int(l, -160, 161, -160, 160);}
void constr_LightBarSirenInUse(LightBarSirenInUse_t *l){constr_BIT_STRING(l, 2);}
void constr_Longitude(Longitude_t *l){constr_int(l, -1800000000, 1800000001, -1800000000, 1800000000);}
void constr_LongitudinalAccelerationValue(LongitudinalAccelerationValue_t *l){constr_int(l, -160, 161, -160, 160);}
void constr_NumberOfOccupants(NumberOfOccupants_t *n){constr_int(n, 0, 127, 0, 126);}
void constr_PathDeltaTime(PathDeltaTime_t *p){constr_int(p, 1, 65535, 1, 65535);}
void constr_PerformanceClass(PerformanceClass_t *p){constr_int(p, 0, 7, 1, 7);}
void constr_PosCentMass(PosCentMass_t *p){constr_int(p, 1, 63, 1, 62);}
void constr_PositioningSolutionType(PositioningSolutionType_t *p){constr_int(p, 0, 5, PositioningSolutionType_noPositioningSolution);}
void constr_PositionOfOccupants(PositionOfOccupants_t *p){constr_BIT_STRING(p, 20);}
void constr_PosFrontAx(PosFrontAx_t *p){constr_int(p, 1, 20, 1, 19);}
void constr_PosLonCarr(PosLonCarr_t *p){constr_int(p, 1, 127, 1, 126);}
void constr_PosPillar(PosPillar_t *p){constr_int(p, 1, 30, 1, 29);}
void constr_ProtectedZoneID(ProtectedZoneID_t *p){constr_int(p, 0, 134217727, 0, 134217727);}
void constr_ProtectedZoneRadius(ProtectedZoneRadius_t *p){constr_int(p, 1, 255, 1, 255);}
void constr_ProtectedZoneType(ProtectedZoneType_t *p){constr_int(p, 0, 0, 0);}
void constr_PtActivationData(PtActivationData_t *p){constr_OCTET_STRING(p, 1, 20);}
void constr_PtActivationType(PtActivationType_t *p){constr_int(p, 0, 255);}
void constr_RelevanceDistance(RelevanceDistance_t *r){constr_int(r, 0, 7);}
void constr_RelevanceTrafficDirection(RelevanceTrafficDirection_t *r){constr_int(r, 0, 3);}
void constr_RequestResponseIndication(RequestResponseIndication_t *r){constr_int(r, 0, 1);}
void constr_RoadType(RoadType_t *r){constr_int(r, 0, 3, 0, 3);}
void constr_SemiAxisLength(SemiAxisLength_t *s){constr_int(s, 0, 4095, 4094);}
void constr_SequenceNumber(SequenceNumber_t *s){constr_int(s, 0, 65535);}
void constr_SpecialTransportType(SpecialTransportType_t *s){constr_BIT_STRING(s, 4);}
void constr_SpeedConfidence(SpeedConfidence_t *s){constr_int(s, 0, 127, SpeedConfidence_outOfRange);}
void constr_SpeedLimit(SpeedLimit_t *s){constr_int(s, 1, 255);}
void constr_SpeedValue(SpeedValue_t *s){constr_int(s, 0, 16383);}
void constr_StationarySince(StationarySince_t *s){constr_int(s, 0, 3);}
void constr_StationID(StationID_t *s){constr_INTEGER((INTEGER_t*)s, 0, 4294967295);}
void constr_StationType(StationType_t *s){constr_int(s, 0, 255, 0);}
void constr_SteeringWheelAngleConfidence(SteeringWheelAngleConfidence_t *s){constr_int(s, 1, 127, SteeringWheelAngleConfidence_unavailable);}
void constr_SteeringWheelAngleValue(SteeringWheelAngleValue_t *s){constr_int(s, -511, 512, -511, 511);}
void constr_SubCauseCodeType(SubCauseCodeType_t *s){constr_int(s, 0, 255);}
void constr_Temperature(Temperature_t *t){constr_int(t, -60, 67);}
void constr_TimestampIts(TimestampIts_t *t){constr_INTEGER(t, 0, 4398046511103);}
void constr_TrafficRule(TrafficRule_t *t){constr_int(t, 0, 3, 0);}
void constr_TransmissionInterval(TransmissionInterval_t *t){constr_int(t, 1, 10000);}
void constr_TurningRadius(TurningRadius_t *t){constr_int(t, 1, 255, 1, 254);}
void constr_ValidityDuration(ValidityDuration_t *v){constr_int(v, 0, 86400);}
void constr_VDS(VDS_t *v){constr_OCTET_STRING((OCTET_STRING_t*)v, 6);}
void constr_VehicleLengthConfidenceIndication(VehicleLengthConfidenceIndication_t *v){constr_int(v, 0, 4, 4);}
void constr_VehicleLengthValue(VehicleLengthValue_t *v){constr_int(v, 1, 1023, 1022);}
void constr_VehicleMass(VehicleMass_t *v){constr_int(v, 1, 1024, 1, 1023);}
void constr_VehicleRole(VehicleRole_t *v){constr_int(v, 0, 15, 0);}
void constr_VehicleWidth(VehicleWidth_t *v){constr_int(v, 1, 62, 1, 61);}
void constr_VerticalAccelerationValue(VerticalAccelerationValue_t *v){constr_int(v, -160, 161, -160, 160);}
void constr_WheelBaseVehicle(WheelBaseVehicle_t *w){constr_int(w, 1, 127, 1, 126);}
void constr_WMInumber(WMInumber_t *w){constr_OCTET_STRING((OCTET_STRING_t*)w, 1, 3);}
void constr_YawRateConfidence(YawRateConfidence_t *y){constr_int(y, 0, 8, 0, 7);}
void constr_YawRateValue(YawRateValue_t *y){constr_int(y, -32766, 32767, -32766, 32766);}

/* DF */
void constr_ActionID(ActionID_t *a)
{
    constr_StationID(&a->originatingStationID);
    constr_SequenceNumber(&a->sequenceNumber);
}

void constr_Altitude(Altitude_t *a)
{
    constr_AltitudeValue(&a->altitudeValue);
    constr_AltitudeConfidence(&a->altitudeConfidence);
}

void constr_CauseCode(CauseCode_t *c)
{
    constr_CauseCodeType(&c->causeCode);
    constr_SubCauseCodeType(&c->subCauseCode);
}

void constr_CenDsrcTollingZone(CenDsrcTollingZone_t *c)
{
    constr_Latitude(&c->protectedZoneLatitude);
    constr_Longitude(&c->protectedZoneLongitude);
    if(c->cenDsrcTollingZoneID)
        constr_CenDsrcTollingZoneID(c->cenDsrcTollingZoneID);
}

void constr_ClosedLanes(ClosedLanes_t *c)
{
    if(c->hardShoulderStatus)
        constr_HardShoulderStatus(c->hardShoulderStatus);
    constr_DrivingLaneStatus(&c->drivingLaneStatus);
}

void constr_Curvature(Curvature_t *c)
{
    constr_CurvatureValue(&c->curvatureValue);
    constr_CurvatureConfidence(&c->curvatureConfidence);
}

void constr_DangerousGoodsExtended(DangerousGoodsExtended_t *d)
{
    constr_DangerousGoodsBasic(&d->dangerousGoodsType);
    constr_int(&d->unNumber, 0, 9999);
    constr_BOOLEAN(&d->elevatedTemperature);
    constr_BOOLEAN(&d->tunnelsRestricted);
    constr_BOOLEAN(&d->limitedQuantity);
    if(d->emergencyActionCode)
        constr_OCTET_STRING((OCTET_STRING_t*)d->emergencyActionCode, 1, 24);
    if(d->phoneNumber)
        constr_OCTET_STRING((OCTET_STRING_t*)d->phoneNumber, 1, 24);
    if(d->companyName)
        constr_OCTET_STRING((OCTET_STRING_t*)d->companyName, 1, 24);
}

void constr_DeltaReferencePosition(DeltaReferencePosition_t *d)
{
    constr_DeltaLatitude(&d->deltaLatitude);
    constr_DeltaLongitude(&d->deltaLongitude);
    constr_DeltaAltitude(&d->deltaAltitude);
}

void constr_EventHistory(EventHistory_t *e)
{
    if(e->list.count > 23)
        for(int i = e->list.count ; i > 23 ; i--)
            asn_sequence_del(e, i, 0);
    else if(e->list.count < 1)
        *e = make_EventHistory();
    else
        for(int i = 0 ; i < e->list.count ; i++)
            constr_EventPoint(e->list.array[i]);
}

void constr_EventPoint(EventPoint_t *e)
{
    constr_DeltaReferencePosition(&e->eventPosition);
    if(e->eventDeltaTime)
        constr_PathDeltaTime(e->eventDeltaTime);
    constr_InformationQuality(&e->informationQuality);
}

void constr_Heading(Heading_t *h)
{
    constr_HeadingValue(&h->headingValue);
    constr_HeadingConfidence(&h->headingConfidence);
}

void constr_ItineraryPath(ItineraryPath_t *i)
{
    if(i->list.count > 40)
        for(int j = i->list.count ; j > 40 ; j--)
            asn_sequence_del(i, j, 0);
    else if(i->list.count < 1)
        *i = make_ItineraryPath();
    else
        for(int j = 0 ; j < i->list.count ; j++)
            constr_ReferencePosition(i->list.array[j]);
}

void constr_ItsPduHeader(ItsPduHeader_t *i)
{
    constr_int(&i->protocolVersion, 0, 255, 1);
    constr_int(&i->messageID, 0, 255, 0);
    constr_StationID(&i->stationID);
}

void constr_LateralAcceleration(LateralAcceleration_t *l)
{
    constr_LateralAccelerationValue(&l->lateralAccelerationValue);
    constr_AccelerationConfidence(&l->lateralAccelerationConfidence);
}

void constr_LongitudinalAcceleration(LongitudinalAcceleration_t *l)
{
    constr_LongitudinalAccelerationValue(&l->longitudinalAccelerationValue);
    constr_AccelerationConfidence(&l->longitudinalAccelerationConfidence);
}

void constr_PathHistory(PathHistory_t *p)
{
    if(p->list.count > 40)
        for(int i = p->list.count ; i > 40 ; i--)
            asn_sequence_del(p, i, 0);
    else if(p->list.count < 0)
        *p = make_PathHistory();
    else
        for(int i = 0 ; i < p->list.count ; i++)
            constr_PathPoint(p->list.array[i]);
}

void constr_PathPoint(PathPoint_t *p)
{
    constr_DeltaReferencePosition(&p->pathPosition);
    if(p->pathDeltaTime)
        constr_PathDeltaTime(p->pathDeltaTime);
}

void constr_PosConfidenceEllipse(PosConfidenceEllipse_t *p)
{
    constr_SemiAxisLength(&p->semiMajorConfidence);
    constr_SemiAxisLength(&p->semiMinorConfidence);
    constr_HeadingValue(&p->semiMajorOrientation);
}

void constr_PositionOfPillars(PositionOfPillars_t *p)
{
    if(p->list.count > 3)
        for(int i = p->list.count ; i > 3 ; i--)
            asn_sequence_del(p, i, 0);
    else if(p->list.count < 1)
        *p = make_PositionOfPillars();
    else
        for(int i = 0 ; i < p->list.count ; i++)
            constr_PosPillar(p->list.array[i]);
}

void constr_ProtectedCommunicationZone(ProtectedCommunicationZone_t *p)
{
    constr_ProtectedZoneType(&p->protectedZoneType);
    if(p->expiryTime)
        constr_TimestampIts(p->expiryTime);
    constr_Latitude(&p->protectedZoneLatitude);
    constr_Longitude(&p->protectedZoneLongitude);
    if(p->protectedZoneRadius)
        constr_ProtectedZoneRadius(p->protectedZoneRadius);
    if(p->protectedZoneID)
        constr_ProtectedZoneID(p->protectedZoneID);
}

void constr_ProtectedCommunicationZoneRSU(ProtectedCommunicationZonesRSU_t *p)
{
    if(p->list.count > 16)
        for(int i = p->list.count ; i > 16 ; i--)
            asn_sequence_del(p, i, 0);
    else if(p->list.count < 1)
        *p = make_ProtectedCommunicationZonesRSU();
    else
        for(int i = 0 ; i < p->list.count ; i++)
            constr_ProtectedCommunicationZone(p->list.array[i]);
}

void constr_PtActivation(PtActivation_t *p)
{
    constr_PtActivationType(&p->ptActivationType);
    constr_PtActivationData(&p->ptActivationData);
}

void constr_ReferencePosition(ReferencePosition_t *r)
{
    constr_Latitude(&r->latitude);
    constr_Longitude(&r->longitude);
    constr_PosConfidenceEllipse(&r->positionConfidenceEllipse);
    constr_Altitude(&r->altitude);
}

void constr_RestrictedTypes(RestrictedTypes_t *r)
{
    if(r->list.count > 3)
        for(int i = r->list.count ; i > 3 ; i--)
            asn_sequence_del(r, i, 0);
    else if(r->list.count < 1)
        *r = make_RestrictedTypes();
    else
        for(int i = 0 ; i < r->list.count ; i++)
            constr_StationType(r->list.array[i]);
}

void constr_Speed(Speed_t *s)
{
    constr_SpeedValue(&s->speedValue);
    constr_SpeedConfidence(&s->speedConfidence);
}

void constr_SteeringWheelAngle(SteeringWheelAngle_t *s)
{
    constr_SteeringWheelAngleValue(&s->steeringWheelAngleValue);
    constr_SteeringWheelAngleConfidence(&s->steeringWheelAngleConfidence);
}

void constr_Traces(Traces_t *t)
{
    if(t->list.count > 3)
        for(int i = t->list.count ; i > 3 ; i--)
            asn_sequence_del(t, i, 0);
    else if(t->list.count < 1)
        *t = make_Traces();
    else
        for(int i = 0 ; i < t->list.count ; i++)
            constr_PathHistory(t->list.array[i]);
}

void constr_VerticalAcceleration(VerticalAcceleration_t *v)
{
    constr_VerticalAccelerationValue(&v->verticalAccelerationValue);
    constr_AccelerationConfidence(&v->verticalAccelerationConfidence);
}

void constr_VehicleIdentification(VehicleIdentification_t *v)
{
    if(v->wMInumber)
        constr_WMInumber(v->wMInumber);
    if(v->vDS)
        constr_VDS(v->vDS);
}

void constr_VehicleLength(VehicleLength_t *v)
{
    constr_VehicleLengthValue(&v->vehicleLengthValue);
    constr_VehicleLengthConfidenceIndication(&v->vehicleLengthConfidenceIndication);
}

void constr_YawRate(YawRate_t *y)
{
    constr_YawRateValue(&y->yawRateValue);
    constr_YawRateConfidence(&y->yawRateConfidence);
}

/****************************
 * Copy
 ***************************/
/* ASN */
BIT_STRING_t cpy_BIT_STRING(BIT_STRING_t b)
{
    BIT_STRING_t b1;
    int i;

    memset(&b1, 0, sizeof b1);
    b1.bits_unused = b.bits_unused;
    b1.size = b.size;
    b1.buf = (uint8_t*)calloc(b1.size, 1);

    for(i = 0 ; i < b1.size ; i++)
        b1.buf[i] = b.buf[i];

    return b1;
}

OCTET_STRING_t cpy_OCTET_STRING(OCTET_STRING_t o)
{
    OCTET_STRING_t o1;
    int i;

    memset(&o1, 0, sizeof o1);
    o1.size = o.size;
    o1.buf = (uint8_t*)calloc(o1.size, 1);

    for(i = 0 ; i < o1.size ; i++)
        o1.buf[i] = o.buf[i];

    return o1;
}

INTEGER_t cpy_INTEGER(INTEGER_t i)
{
    INTEGER_t i1;
    long int l;

    memset(&i1, 0, sizeof i1);
    asn_INTEGER2long(&i, &l);
    asn_long2INTEGER(&i1, l);

    return i1;
}

/* DE */
AccelerationConfidence_t cpy_AccelerationConfidence(AccelerationConfidence_t a)
{return a;}

AccelerationControl_t cpy_AccelerationControl(AccelerationControl_t a)
{return cpy_BIT_STRING(a);}

AltitudeConfidence_t cpy_AltitudeConfidence(AltitudeConfidence_t a){return a;}

AltitudeValue_t cpy_AltitudeValue(AltitudeValue_t a){return a;}

CauseCodeType_t cpy_CauseCodeType(CauseCodeType_t c){return c;}

CenDsrcTollingZoneID_t cpy_CenDsrcTollingZoneID(CenDsrcTollingZoneID_t c){return c;}

CurvatureCalculationMode_t cpy_CurvatureCalculationMode(CurvatureCalculationMode_t c)
{return c;}

CurvatureConfidence_t cpy_CurvatureConfidence(CurvatureConfidence_t c){return c;}

CurvatureValue_t cpy_CurvatureValue(CurvatureValue_t c){return c;}

DangerousGoodsBasic_t cpy_DangerousGoodsBasic(DangerousGoodsBasic_t d){return d;}

DeltaAltitude_t cpy_DeltaAltitude(DeltaAltitude_t d){return d;}

DeltaLatitude_t cpy_DeltaLatitude(DeltaLatitude_t d){return d;}

DeltaLongitude_t cpy_DeltaLongitude(DeltaLongitude_t d){return d;}

DriveDirection_t cpy_DriveDirection(DriveDirection_t d){return d;}

DrivingLaneStatus_t cpy_DrivingLaneStatus(DrivingLaneStatus_t d)
{return cpy_BIT_STRING(d);}

EmbarkationStatus_t cpy_EmbarkationStatus(EmbarkationStatus_t e){return e;}

EmergencyPriority_t cpy_EmergencyPriority(EmergencyPriority_t e)
{return cpy_BIT_STRING(e);}

EnergyStorageType_t cpy_EnergyStorageType(EnergyStorageType_t e)
{return cpy_BIT_STRING(e);}

ExteriorLights_t cpy_ExteriorLights(ExteriorLights_t e){return cpy_BIT_STRING(e);}

HardShoulderStatus_t cpy_HardShoulderStatus(HardShoulderStatus_t h){return h;}

HeadingConfidence_t cpy_HeadingConfidence(HeadingConfidence_t h){return h;}

HeadingValue_t cpy_HeadingValue(HeadingValue_t h){return h;}

HeightLonCarr_t cpy_HeightLonCarr(HeightLonCarr_t h){return h;}

InformationQuality_t cpy_InformationQuality(InformationQuality_t i){return i;}

LanePosition_t cpy_LanePosition(LanePosition_t l){return l;}

Latitude_t cpy_Latitude(Latitude_t l){return l;}

LateralAccelerationValue_t cpy_LateralAccelerationValue(LateralAccelerationValue_t l)
{return l;}

LightBarSirenInUse_t cpy_LightBarSirenInUse(LightBarSirenInUse_t l)
{return cpy_BIT_STRING(l);}

Longitude_t cpy_Longitude(Longitude_t l){return l;}

LongitudinalAccelerationValue_t cpy_LongitudinalAccelerationValue(
        LongitudinalAccelerationValue_t l){return l;}

NumberOfOccupants_t cpy_NumberOfOccupants(NumberOfOccupants_t n){return n;}

PathDeltaTime_t cpy_PathDeltaTime(PathDeltaTime_t p){return p;}

PerformanceClass_t cpy_PerformanceClass(PerformanceClass_t p){return p;}

PosCentMass_t cpy_PosCentMass(PosCentMass_t p){return p;}

PositioningSolutionType_t cpy_PositioningSolutionType(PositioningSolutionType_t p)
{return p;}

PositionOfOccupants_t cpy_PositionOfOccupants(PositionOfOccupants_t p)
{return cpy_BIT_STRING(p);}

PosFrontAx_t cpy_PosFrontAx(PosFrontAx_t p){return p;}

PosLonCarr_t cpy_PosLonCarr(PosLonCarr_t p){return p;}

PosPillar_t cpy_PosPillar(PosPillar_t p){return p;}

ProtectedZoneID_t cpy_ProtectedZoneID(ProtectedZoneID_t p){return p;}

ProtectedZoneRadius_t cpy_ProtectedZoneRadius(ProtectedZoneRadius_t p){return p;}

ProtectedZoneType_t cpy_ProtectedZoneType(ProtectedZoneType_t p){return p;}

PtActivationData_t cpy_PtActivationData(PtActivationData_t p){return p;}

PtActivationType_t cpy_PtActivationType(PtActivationType_t p){return p;}

RelevanceDistance_t cpy_RelevanceDistance(RelevanceDistance_t r){return r;}

RelevanceTrafficDirection_t cpy_RelevanceTrafficDirection(
        RelevanceTrafficDirection_t r){return r;}

RequestResponseIndication_t cpy_RequestResponseIndication(
        RequestResponseIndication_t r){return r;}

RoadType_t cpy_RoadType(RoadType_t r){return r;}

SemiAxisLength_t cpy_SemiAxisLength(SemiAxisLength_t s){return s;}

SequenceNumber_t cpy_SequenceNumber(SequenceNumber_t s){return s;}

SpecialTransportType_t cpy_SpecialTransportType(SpecialTransportType_t s)
{return s;}

SpeedConfidence_t cpy_SpeedConfidence(SpeedConfidence_t s){return s;}

SpeedLimit_t cpy_SpeedLimit(SpeedLimit_t s){return s;}

SpeedValue_t cpy_SpeedValue(SpeedValue_t s){return s;}

StationarySince_t cpy_StationarySince(StationarySince_t s){return s;}

StationID_t cpy_StationID(StationID_t s){return s;}

StationType_t cpy_StationType(StationType_t s){return s;}

SteeringWheelAngleConfidence_t cpy_SteeringWheelAngleConfidence(
        SteeringWheelAngleConfidence_t s){return s;}

SteeringWheelAngleValue_t cpy_SteeringWheelAngleValue(SteeringWheelAngleValue_t s)
{return s;}

SubCauseCodeType_t cpy_SubCauseCodeType(SubCauseCodeType_t s){return s;}

TimestampIts_t cpy_TimestampIts(TimestampIts_t t){return cpy_INTEGER(t);}

Temperature_t cpy_Temperature(Temperature_t t){return t;}

TrafficRule_t cpy_TrafficRule(TrafficRule_t t){return t;}

TransmissionInterval_t cpy_TransmissionInterval(TransmissionInterval_t t)
{return t;}

TurningRadius_t cpy_TurningRadius(TurningRadius_t t){return t;}

ValidityDuration_t cpy_ValidityDuration(ValidityDuration_t v){return v;}

VDS_t cpy_VDS(VDS_t v){return cpy_OCTET_STRING(v);}

VehicleLengthConfidenceIndication_t cpy_VehicleLengthConfidenceIndication(
        VehicleLengthConfidenceIndication_t v){return v;}

VehicleLengthValue_t cpy_VehicleLengthValue(VehicleLengthValue_t v){return v;}

VehicleMass_t cpy_VehicleMass(VehicleMass_t v){return v;}

VehicleRole_t cpy_VehicleRole(VehicleRole_t v){return v;}

VehicleWidth_t cpy_VehicleWidth(VehicleWidth_t v){return v;}

VerticalAccelerationValue_t cpy_VerticalAccelerationValue(
        VerticalAccelerationValue_t v){return v;}

WheelBaseVehicle_t cpy_WheelBaseVehicle(WheelBaseVehicle_t w){return w;}

WMInumber_t cpy_WMInumber(WMInumber_t w){return cpy_OCTET_STRING(w);}

YawRateConfidence_t cpy_YawRateConfidence(YawRateConfidence_t y){return y;}

YawRateValue_t cpy_YawRateValue(YawRateValue_t y){return y;}
/*
 * DF
 */
ActionID_t cpy_ActionID(ActionID_t a)
{
    ActionID_t a1;

    memset(&a1, 0, sizeof a1);
    a1.originatingStationID = cpy_StationID(a.originatingStationID);
    a1.sequenceNumber = cpy_SequenceNumber(a.sequenceNumber);

    return a1;
}

Altitude_t cpy_Altitude(Altitude_t a)
{
    Altitude_t a1;

    memset(&a1, 0, sizeof a1);
    a1.altitudeValue = cpy_AltitudeValue(a.altitudeValue);
    a1.altitudeConfidence = cpy_AltitudeConfidence(a.altitudeConfidence);

    return a1;
}

CauseCode_t cpy_CauseCode(CauseCode_t c)
{
    CauseCode_t c1;

    memset(&c1, 0, sizeof c1);
    c1.causeCode = cpy_CauseCodeType(c.causeCode);
    c1.subCauseCode = cpy_SubCauseCodeType(c.subCauseCode);

    return c1;
}

CenDsrcTollingZone_t cpy_CenDsrcTollingZone(CenDsrcTollingZone_t c)
{
    CenDsrcTollingZone_t c1;

    memset(&c1, 0, sizeof c1);
    c1.protectedZoneLatitude = cpy_Latitude(c.protectedZoneLatitude);
    c1.protectedZoneLongitude = cpy_Longitude(c.protectedZoneLongitude);
    if(c.cenDsrcTollingZoneID)
    {
        c1.cenDsrcTollingZoneID = (CenDsrcTollingZoneID_t*)calloc(1, sizeof *c1.cenDsrcTollingZoneID);
        *c1.cenDsrcTollingZoneID = cpy_CenDsrcTollingZoneID(*c.cenDsrcTollingZoneID);
    }

    return c1;
}

ClosedLanes_t cpy_ClosedLanes(ClosedLanes_t c)
{
    ClosedLanes_t c1;

    memset(&c1, 0, sizeof c1);
    if(c.hardShoulderStatus)
    {
        c1.hardShoulderStatus = (HardShoulderStatus_t*)calloc(1, sizeof *c1.hardShoulderStatus);
        *c1.hardShoulderStatus = cpy_HardShoulderStatus(*c.hardShoulderStatus);
    }
    c1.drivingLaneStatus = cpy_DrivingLaneStatus(c.drivingLaneStatus);

    return c1;
}

Curvature_t cpy_Curvature(Curvature_t c)
{
    Curvature_t c1;

    memset(&c1, 0, sizeof c1);
    c1.curvatureValue = cpy_CurvatureValue(c.curvatureValue);
    c1.curvatureConfidence = cpy_CurvatureConfidence(c.curvatureConfidence);

    return c1;
}

DangerousGoodsExtended_t cpy_DangerousGoodsExtended(DangerousGoodsExtended_t d)
{
    DangerousGoodsExtended_t d1;

    memset(&d1, 0, sizeof d1);
    d1.dangerousGoodsType = cpy_DangerousGoodsBasic(d.dangerousGoodsType);
    d1.unNumber = d.unNumber;
    d1.elevatedTemperature = d.elevatedTemperature;
    d1.tunnelsRestricted = d.tunnelsRestricted;
    d1.limitedQuantity = d.limitedQuantity;
    if(d.emergencyActionCode)
    {
        d1.emergencyActionCode = (IA5String_t*)calloc(1, sizeof *d1.emergencyActionCode);
        *d1.emergencyActionCode = cpy_OCTET_STRING(*d.emergencyActionCode);
    }
    if(d.phoneNumber)
    {
        d1.phoneNumber = (IA5String_t*)calloc(1, sizeof *d1.phoneNumber);
        *d1.phoneNumber = cpy_OCTET_STRING(*d.phoneNumber);
    }
    if(d.companyName)
    {
        d1.companyName = (UTF8String_t*)calloc(1, sizeof *d1.companyName);
        *d1.companyName = cpy_OCTET_STRING(*d.companyName);
    }

    return d1;
}

DeltaReferencePosition_t cpy_DeltaReferencePosition(DeltaReferencePosition_t d)
{
    DeltaReferencePosition_t d1;

    memset(&d1, 0, sizeof d1);
    d1.deltaLatitude = cpy_DeltaLatitude(d.deltaLatitude);
    d1.deltaLongitude = cpy_DeltaLongitude(d.deltaLongitude);
    d1.deltaAltitude = cpy_DeltaAltitude(d.deltaAltitude);

    return d1;
}

EventHistory_t cpy_EventHistory(EventHistory_t e)
{
    EventHistory_t e1;
    EventPoint_t ep;
    int i;

    memset(&e1, 0, sizeof e1);
    e1.list.array = (EventPoint_t**)calloc(1, sizeof *e1.list.array);
    for(i = 0 ; i < e.list.count ; i++)
    {
        ep = cpy_EventPoint(*e.list.array[i]);
        e1.list.array[i] = (EventPoint_t*)calloc(1, sizeof *e1.list.array[i]);
        asn_sequence_add(&e1, &ep);
    }

    return e1;
}

EventPoint_t cpy_EventPoint(EventPoint_t e)
{
    EventPoint_t e1;

    memset(&e1, 0, sizeof e1);
    e1.eventPosition = cpy_DeltaReferencePosition(e.eventPosition);
    if(e.eventDeltaTime)
    {
        e1.eventDeltaTime = (PathDeltaTime_t*)calloc(1, sizeof *e1.eventDeltaTime);
        *e1.eventDeltaTime = cpy_PathDeltaTime(*e.eventDeltaTime);
    }
    e1.informationQuality = cpy_InformationQuality(e.informationQuality);

    return e1;
}

Heading_t cpy_Heading(Heading_t h)
{
    Heading_t h1;

    memset(&h1, 0, sizeof h1);
    h1.headingValue = cpy_HeadingValue(h.headingValue);
    h1.headingConfidence = cpy_HeadingConfidence(h.headingConfidence);

    return h1;
}

ItineraryPath_t cpy_ItineraryPath(ItineraryPath_t i)
{
    ItineraryPath_t i1;
    ReferencePosition_t r;
    int j;

    memset(&i1, 0, sizeof i1);
    i1.list.array = (ReferencePosition_t**)calloc(1, sizeof *i1.list.array);

    for(j = 0 ; j < i.list.count ; j++)
    {
        r = cpy_ReferencePosition(*i.list.array[j]);
        i1.list.array[j] = (ReferencePosition_t*)calloc(1, sizeof *i1.list.array[j]);
        asn_sequence_add(&i1, &r);
    }

    return i1;
}

ItsPduHeader_t cpy_ItsPduHeader(ItsPduHeader_t i)
{
    ItsPduHeader_t i1;

    memset(&i1, 0, sizeof i1);
    i1.protocolVersion = i.protocolVersion;
    i1.messageID = i.messageID;
    i1.stationID = cpy_StationID(i.stationID);

    return i1;
}

LateralAcceleration_t cpy_LateralAcceleration(LateralAcceleration_t l)
{
    LateralAcceleration_t l1;

    memset(&l1, 0, sizeof l1);
    l1.lateralAccelerationValue = cpy_LateralAccelerationValue(l.lateralAccelerationValue);
    l1.lateralAccelerationConfidence = cpy_AccelerationConfidence(l.lateralAccelerationConfidence);

    return l1;
}

LongitudinalAcceleration_t cpy_LongitudinalAcceleration(LongitudinalAcceleration_t l)
{
    LongitudinalAcceleration_t l1;

    memset(&l1, 0, sizeof l1);
    l1.longitudinalAccelerationValue = cpy_LongitudinalAccelerationValue(
                l.longitudinalAccelerationValue);
    l1.longitudinalAccelerationConfidence = cpy_AccelerationConfidence(
                l.longitudinalAccelerationConfidence);

    return l1;
}

PathHistory_t cpy_PathHistory(PathHistory_t p)
{
    PathHistory_t p1;
    PathPoint_t pp;
    int i;

    memset(&p1, 0, sizeof p1);
    p1.list.array = (PathPoint_t**)calloc(1, sizeof *p1.list.array);

    for(i = 0 ; i < p.list.count ; i++)
    {
        pp = cpy_PathPoint(*p.list.array[i]);
        p1.list.array[i] = (PathPoint_t*)calloc(1, sizeof *p1.list.array[i]);
        asn_sequence_add(&p1, &pp);
    }

    return p1;
}

PathPoint_t cpy_PathPoint(PathPoint_t p)
{
    PathPoint_t p1;

    memset(&p1, 0, sizeof p1);
    p1.pathPosition = cpy_DeltaReferencePosition(p.pathPosition);
    if(p.pathDeltaTime)
    {
        p1.pathDeltaTime = (PathDeltaTime_t*)calloc(1, sizeof *p1.pathDeltaTime);
        *p1.pathDeltaTime = cpy_PathDeltaTime(*p.pathDeltaTime);
    }

    return p1;
}

PosConfidenceEllipse_t cpy_PosConfidenceEllipse(PosConfidenceEllipse_t p)
{
    PosConfidenceEllipse_t p1;

    memset(&p1, 0, sizeof p1);
    p1.semiMajorConfidence = cpy_SemiAxisLength(p.semiMajorConfidence);
    p1.semiMinorConfidence = cpy_SemiAxisLength(p.semiMinorConfidence);
    p1.semiMajorOrientation = cpy_HeadingValue(p.semiMajorOrientation);

    return p1;
}

PositionOfPillars_t cpy_PositionOfPillars(PositionOfPillars_t p)
{
    PositionOfPillars_t p1;
    PosPillar_t pp;
    int i;

    memset(&p1, 0, sizeof p1);
    p1.list.array = (PosPillar_t**)calloc(1, sizeof *p1.list.array);

    for(i = 0 ; i < p.list.count ; i++)
    {
        pp = cpy_PosPillar(*p.list.array[i]);
        p1.list.array[i] = (PosPillar_t*)calloc(1, sizeof *p1.list.array[i]);
        asn_sequence_add(&p1, &pp);
    }

    return p1;
}

ProtectedCommunicationZone_t cpy_ProtectedCommunicationZone(
        ProtectedCommunicationZone_t p)
{
    ProtectedCommunicationZone_t p1;

    memset(&p1, 0, sizeof p1);
    p1.protectedZoneType = cpy_ProtectedZoneType(p.protectedZoneType);
    if(p.expiryTime)
    {
        p1.expiryTime = (TimestampIts_t*)calloc(1, sizeof *p1.expiryTime);
        *p1.expiryTime = cpy_TimestampIts(*p.expiryTime);
    }
    p1.protectedZoneLatitude = cpy_Latitude(p.protectedZoneLatitude);
    p1.protectedZoneLongitude = cpy_Longitude(p.protectedZoneLongitude);
    if(p.protectedZoneRadius)
    {
        p1.protectedZoneRadius = (ProtectedZoneRadius_t*)calloc(1, sizeof *p1.protectedZoneRadius);
        *p1.protectedZoneRadius = cpy_ProtectedZoneRadius(*p.protectedZoneRadius);
    }
    if(p.protectedZoneID)
    {
        p1.protectedZoneID = (ProtectedZoneID_t*)calloc(1, sizeof *p1.protectedZoneID);
        *p1.protectedZoneID = cpy_ProtectedZoneID(*p.protectedZoneID);
    }

    return p1;
}

ProtectedCommunicationZonesRSU_t cpy_ProtectedCommunicationZoneRSU(
        ProtectedCommunicationZonesRSU_t p)
{
    ProtectedCommunicationZonesRSU_t p1;
    ProtectedCommunicationZone_t pc;
    int i;

    memset(&p1, 0, sizeof p1);
    p1.list.array = (ProtectedCommunicationZone_t**)calloc(1, sizeof *p1.list.array);

    for(i = 0 ; i < p.list.count ; i++)
    {
        pc = cpy_ProtectedCommunicationZone(*p.list.array[i]);
        p1.list.array[i] = (ProtectedCommunicationZone_t*)calloc(1, sizeof *p1.list.array[i]);
        asn_sequence_add(&p1, &pc);
    }

    return p1;
}

PtActivation_t cpy_PtActivation(PtActivation_t p)
{
    PtActivation_t p1;

    memset(&p1, 0, sizeof p1);
    p1.ptActivationType = cpy_PtActivationType(p.ptActivationType);
    p1.ptActivationData = cpy_PtActivationData(p.ptActivationData);

    return p1;
}

ReferencePosition_t cpy_ReferencePosition(ReferencePosition_t r)
{
    ReferencePosition_t r1;

    memset(&r1, 0, sizeof r1);
    r1.latitude = cpy_Latitude(r.latitude);
    r1.longitude = cpy_Longitude(r.longitude);
    r1.positionConfidenceEllipse = cpy_PosConfidenceEllipse(r.positionConfidenceEllipse);
    r1.altitude = cpy_Altitude(r.altitude);

    return r1;
}

RestrictedTypes_t cpy_RestrictedTypes(RestrictedTypes_t r)
{
    RestrictedTypes_t r1;
    StationType_t s;
    int i;

    memset(&r1, 0, sizeof r1);
    r1.list.array = (StationType_t**)calloc(1, sizeof *r1.list.array);

    for(i = 0 ; i < r.list.count ; i++)
    {
        s = cpy_StationType(*r.list.array[i]);
        r1.list.array[i] = (StationType_t*)calloc(1, sizeof *r.list.array[i]);
        asn_sequence_add(&r1, &s);
    }

    return r1;
}

Speed_t cpy_Speed(Speed_t s)
{
    Speed_t s1;

    memset(&s1, 0, sizeof s1);
    s1.speedValue = cpy_SpeedValue(s.speedValue);
    s1.speedConfidence = cpy_SpeedConfidence(s.speedConfidence);

    return s1;
}

SteeringWheelAngle_t cpy_SteeringWheelAngle(SteeringWheelAngle_t s)
{
    SteeringWheelAngle_t s1;

    memset(&s1, 0, sizeof s1);
    s1.steeringWheelAngleValue = cpy_SteeringWheelAngleValue(s.steeringWheelAngleValue);
    s1.steeringWheelAngleConfidence = cpy_SteeringWheelAngleConfidence(s.steeringWheelAngleConfidence);

    return s1;
}

Traces_t cpy_Traces(Traces_t t)
{
    Traces_t t1;
    PathHistory_t p;
    int i;

    memset(&t1, 0, sizeof t1);
    t1.list.array = (PathHistory_t**)calloc(1, sizeof *t1.list.array);

    for(i = 0 ; i < t.list.count ; i++)
    {
        p = cpy_PathHistory(*t.list.array[i]);
        t1.list.array[i] = (PathHistory_t*)calloc(1, sizeof *t1.list.array[i]);
        asn_sequence_add(&t1, &p);
    }

    return t1;
}

VerticalAcceleration_t cpy_VerticalAcceleration(VerticalAcceleration_t v)
{
    VerticalAcceleration_t v1;

    memset(&v1, 0, sizeof v1);
    v1.verticalAccelerationValue = cpy_VerticalAccelerationValue(v.verticalAccelerationValue);
    v1.verticalAccelerationConfidence = cpy_AccelerationConfidence(v.verticalAccelerationConfidence);

    return v1;
}

VehicleIdentification_t cpy_VehicleIdentification(VehicleIdentification_t v)
{
    VehicleIdentification_t v1;

    memset(&v1, 0, sizeof v1);
    if(v.wMInumber)
    {
        v1.wMInumber = (WMInumber_t*)calloc(1, sizeof *v1.wMInumber);
        *v1.wMInumber = cpy_WMInumber(*v.wMInumber);
    }
    if(v.vDS)
    {
        v1.vDS = (VDS_t*)calloc(1, sizeof *v1.vDS);
        *v1.vDS = cpy_VDS(*v.vDS);
    }

    return v1;
}

VehicleLength_t cpy_VehicleLength(VehicleLength_t v)
{
    VehicleLength_t v1;

    memset(&v1, 0, sizeof v1);
    v1.vehicleLengthValue = cpy_VehicleLengthValue(v.vehicleLengthValue);
    v1.vehicleLengthConfidenceIndication = cpy_VehicleLengthConfidenceIndication(
                v.vehicleLengthConfidenceIndication);

    return v1;
}

YawRate_t cpy_YawRate(YawRate_t y)
{
    YawRate_t y1;

    memset(&y1, 0, sizeof y1);
    y1.yawRateValue = cpy_YawRateValue(y.yawRateValue);
    y1.yawRateConfidence = cpy_YawRateConfidence(y.yawRateConfidence);

    return y1;
}

/************************
 * Equals
 ***********************/
/* ASN */
bool isEqual_BIT_STRING(BIT_STRING_t a, BIT_STRING_t b)
{
    int i;

    if((a.buf && !b.buf) || (!a.buf && b.buf))
        return false;
    if(a.size != b.size)
        return false;
    if(a.bits_unused != b.bits_unused)
        return false;
    for(i = 0 ; i < a.size && (a.buf[i] == b.buf[i]) ; i++);

    return i == a.size;
}

bool isEqual_INTEGER(INTEGER_t a, INTEGER_t b)
{
    long int la, lb;

    asn_INTEGER2long(&a, &la);
    asn_INTEGER2long(&b, &lb);

    return la == lb;
}

bool isEqual_OCTET_STRING(OCTET_STRING_t a, OCTET_STRING_t b)
{
    int i;

    if((!a.buf && b.buf) || (a.buf && !b.buf))
        return false;
    if(a.size != b.size)
        return false;
    for(i = 0 ; i < a.size && a.buf[i] == b.buf[i] ; i++);

    return i == a.size;
}

/* DE */
bool isEqual_AccelerationConfidence(AccelerationConfidence_t a,
                                                      AccelerationConfidence_t b)
{return a == b;}

bool isEqual_AccelerationControl(AccelerationControl_t a,
                                                     AccelerationControl_t b)
{return isEqual_BIT_STRING(a, b);}

bool isEqual_AltitudeConfidence(AltitudeConfidence_t a, AltitudeConfidence_t b)
{return a == b;}

bool isEqual_AltitudeValue(AltitudeValue_t a, AltitudeValue_t b)
{return a == b;}

bool isEqual_CauseCodeType(CauseCodeType_t a, CauseCodeType_t b)
{return a == b;}

bool isEqual_CenDsrcTollingZoneID(CenDsrcTollingZoneID_t a,
                                                    CenDsrcTollingZoneID_t b)
{return isEqual_ProtectedZoneID(a, b);}

bool isEqual_CurvatureCalculationMode(CurvatureCalculationMode_t a,
                                                        CurvatureCalculationMode_t b)
{return a == b;}

bool isEqual_CurvatureConfidence(CurvatureConfidence_t a,
                                                     CurvatureConfidence_t b){return a == b;}

bool isEqual_CurvatureValue(CurvatureValue_t a, CurvatureValue_t b)
{return a == b;}

bool isEqual_DangerousGoodsBasic(DangerousGoodsBasic_t a,
                                                     DangerousGoodsBasic_t b){return a == b;}

bool isEqual_DeltaAltitude(DeltaAltitude_t a, DeltaAltitude_t b)
{return a == b;}

bool isEqual_DeltaLatitude(DeltaLatitude_t a, DeltaLatitude_t b)
{return a == b;}

bool isEqual_DeltaLongitude(DeltaLongitude_t a, DeltaLongitude_t b)
{return a == b;}

bool isEqual_DriveDirection(DriveDirection_t a, DriveDirection_t b)
{return a == b;}

bool isEqual_DrivingLaneStatus(DrivingLaneStatus_t a, DrivingLaneStatus_t b)
{return isEqual_BIT_STRING(a, b);}

bool isEqual_EmbarkationStatus(EmbarkationStatus_t a, EmbarkationStatus_t b)
{return a == b;}

bool isEqual_EmergencyPriority(EmergencyPriority_t a, EmergencyPriority_t b)
{return isEqual_BIT_STRING(a, b);}

bool isEqual_EnergyStorageType(EnergyStorageType_t a, EnergyStorageType_t b)
{return isEqual_BIT_STRING(a, b);}

bool isEqual_ExteriorLights(ExteriorLights_t a, ExteriorLights_t b)
{return isEqual_BIT_STRING(a, b);}

bool isEqual_HardShoulderStatus(HardShoulderStatus_t a, HardShoulderStatus_t b)
{return a == b;}

bool isEqual_HeadingConfidence(HeadingConfidence_t a, HeadingConfidence_t b)
{return a == b;}

bool isEqual_HeadingValue(HeadingValue_t a, HeadingValue_t b)
{return a == b;}

bool isEqual_HeightLonCarr(HeightLonCarr_t a, HeightLonCarr_t b)
{return a == b;}

bool isEqual_InformationQuality(InformationQuality_t a, InformationQuality_t b)
{return a == b;}

bool isEqual_LanePosition(LanePosition_t a, LanePosition_t b){return a == b;}

bool isEqual_Latitude(Latitude_t a, Latitude_t b){return a == b;}

bool isEqual_LateralAccelerationValue(LateralAccelerationValue_t a,
                                                        LateralAccelerationValue_t b)
{return a == b;}

bool isEqual_LightBarSirenInUse(LightBarSirenInUse_t a, LightBarSirenInUse_t b)
{return isEqual_BIT_STRING(a, b);}

bool isEqual_Longitude(Longitude_t a, Longitude_t b){return a == b;}

bool isEqual_LongitudinalAccelerationValue(LongitudinalAccelerationValue_t a,
                                                             LongitudinalAccelerationValue_t b)
{return a == b;}

bool isEqual_NumberOfOccupants(NumberOfOccupants_t a, NumberOfOccupants_t b)
{return a == b;}

bool isEqual_PathDeltaTime(PathDeltaTime_t a, PathDeltaTime_t b)
{return a == b;}

bool isEqual_PerformanceClass(PerformanceClass_t a, PerformanceClass_t b)
{return a == b;}

bool isEqual_PosCentMass(PosCentMass_t a, PosCentMass_t b){return a == b;}

bool isEqual_PositioningSolutionType(PositioningSolutionType_t a,
                                                       PositioningSolutionType_t b){return a == b;}

bool isEqual_PositionOfOccupants(PositionOfOccupants_t a,
                                                     PositionOfOccupants_t b)
{return isEqual_BIT_STRING(a, b);}

bool isEqual_PosFrontAx(PosFrontAx_t a, PosFrontAx_t b){return a == b;}

bool isEqual_PosLonCarr(PosLonCarr_t a, PosLonCarr_t b){return a == b;}

bool isEqual_PosPillar(PosPillar_t a, PosPillar_t b){return a == b;}

bool isEqual_ProtectedZoneID(ProtectedZoneID_t a, ProtectedZoneID_t b)
{return a == b;}

bool isEqual_ProtectedZoneRadius(ProtectedZoneRadius_t a,
                                                     ProtectedZoneRadius_t b){return a == b;}

bool isEqual_ProtectedZoneType(ProtectedZoneType_t a, ProtectedZoneType_t b)
{return a == b;}

bool isEqual_PtActivationData(PtActivationData_t a, PtActivationData_t b)
{return isEqual_OCTET_STRING(a, b);}

bool isEqual_PtActivationType(PtActivationType_t a, PtActivationType_t b)
{return a == b;}

bool isEqual_RelevanceDistance(RelevanceDistance_t a, RelevanceDistance_t b)
{return a == b;}

bool isEqual_RelevanceTrafficDirection(RelevanceTrafficDirection_t a,
                                                         RelevanceTrafficDirection_t b)
{return a == b;}

bool isEqual_RequestResponseIndication(RequestResponseIndication_t a,
                                                         RequestResponseIndication_t b)
{return a == b;}

bool isEqual_RoadType(RoadType_t a, RoadType_t b)
{return a == b;}

bool isEqual_SemiAxisLength(SemiAxisLength_t a, SemiAxisLength_t b)
{return a == b;}

bool isEqual_SequenceNumber(SequenceNumber_t a, SequenceNumber_t b)
{return a == b;}

bool isEqual_SpecialTransportType(SpecialTransportType_t a,
                                                    SpecialTransportType_t b)
{return isEqual_BIT_STRING(a, b);}

bool isEqual_SpeedConfidence(SpeedConfidence_t a, SpeedConfidence_t b)
{return a == b;}

bool isEqual_SpeedLimit(SpeedLimit_t a, SpeedLimit_t b)
{return a == b;}

bool isEqual_SpeedValue(SpeedValue_t a, SpeedValue_t b)
{return a == b;}

bool isEqual_StationarySince(StationarySince_t a, StationarySince_t b)
{return a == b;}

bool isEqual_StationID(StationID_t a, StationID_t b)
{return a == b;}

bool isEqual_StationType(StationType_t a, StationType_t b)
{return a == b;}

bool isEqual_SteeringWheelAngleConfidence(SteeringWheelAngleConfidence_t a,
                                                            SteeringWheelAngleConfidence_t b)
{return a == b;}

bool isEqual_SteeringWheelAngleValue(SteeringWheelAngleValue_t a,
                                                       SteeringWheelAngleValue_t b)
{return a == b;}

bool isEqual_SubCauseCodeType(SubCauseCodeType_t a, SubCauseCodeType_t b)
{return a == b;}

bool isEqual_TimestampIts(TimestampIts_t a, TimestampIts_t b)
{return isEqual_INTEGER((INTEGER_t)a, (INTEGER_t)b);}

bool isEqual_Temperature(Temperature_t a, Temperature_t b)
{return a == b;}

bool isEqual_TrafficRule(TrafficRule_t a, TrafficRule_t b)
{return a == b;}

bool isEqual_TransmissionInterval(TransmissionInterval_t a,
                                                    TransmissionInterval_t b)
{return a == b;}

bool isEqual_TurningRadius(TurningRadius_t a, TurningRadius_t b)
{return a == b;}

bool isEqual_ValidityDuration(ValidityDuration_t a, ValidityDuration_t b)
{return a == b;}

bool isEqual_VDS(VDS_t a, VDS_t b)
{return isEqual_OCTET_STRING(a, b);}

bool isEqual_VehicleLengthConfidenceIndication(
        VehicleLengthConfidenceIndication_t a, VehicleLengthConfidenceIndication_t b)
{return a == b;}

bool isEqual_VehicleLengthValue(VehicleLengthValue_t a, VehicleLengthValue_t b)
{return a == b;}

bool isEqual_VehicleMass(VehicleMass_t a, VehicleMass_t b){return a == b;}

bool isEqual_VehicleRole(VehicleRole_t a, VehicleRole_t b){return a == b;}

bool isEqual_VehicleWidth(VehicleWidth_t a, VehicleWidth_t b){return a == b;}

bool isEqual_VerticalAccelerationValue(VerticalAccelerationValue_t a,
                                                         VerticalAccelerationValue_t b)
{return a == b;}

bool isEqual_WheelBaseVehicle(WheelBaseVehicle_t a, WheelBaseVehicle_t b)
{return a == b;}

bool isEqual_WMInumber(WMInumber_t a, WMInumber_t b)
{return isEqual_OCTET_STRING(a, b);}

bool isEqual_YawRateConfidence(YawRateConfidence_t a, YawRateConfidence_t b)
{return a == b;}

bool isEqual_YawRateValue(YawRateValue_t a, YawRateValue_t b)
{return a == b;}

/* DF */
bool isEqual_ActionID(ActionID_t a, ActionID_t b)
{
    return isEqual_StationID(a.originatingStationID, b.originatingStationID) &&
            isEqual_SequenceNumber(a.sequenceNumber, b.sequenceNumber);
}

bool isEqual_Altitude(Altitude_t a, Altitude_t b)
{
    return isEqual_AltitudeValue(a.altitudeValue, b.altitudeValue) &&
            isEqual_AltitudeConfidence(a.altitudeConfidence, b.altitudeConfidence);
}

bool isEqual_CauseCode(CauseCode_t a, CauseCode_t b)
{
    return isEqual_CauseCodeType(a.causeCode, b.causeCode) &&
            isEqual_SubCauseCodeType(a.subCauseCode, b.subCauseCode);
}

bool isEqual_CenDsrcTollingZone(CenDsrcTollingZone_t a, CenDsrcTollingZone_t b)
{
    if((!a.cenDsrcTollingZoneID && b.cenDsrcTollingZoneID) ||
       (a.cenDsrcTollingZoneID && !b.cenDsrcTollingZoneID))
        return false;
    if(a.cenDsrcTollingZoneID)
        if(!isEqual_CenDsrcTollingZoneID(*a.cenDsrcTollingZoneID, *b.cenDsrcTollingZoneID))
            return false;
    return isEqual_Latitude(a.protectedZoneLatitude, b.protectedZoneLatitude) &&
            isEqual_Longitude(a.protectedZoneLongitude, b.protectedZoneLongitude);
}

bool isEqual_ClosedLanes(ClosedLanes_t a, ClosedLanes_t b)
{
    if((!a.hardShoulderStatus && b.hardShoulderStatus) ||
       (a.hardShoulderStatus && !b.hardShoulderStatus))
        return false;
    if(a.hardShoulderStatus)
        if(!isEqual_HardShoulderStatus(*a.hardShoulderStatus, *b.hardShoulderStatus))
            return false;
    return isEqual_DrivingLaneStatus(a.drivingLaneStatus, b.drivingLaneStatus);
}

bool isEqual_Curvature(Curvature_t a, Curvature_t b)
{
    return isEqual_CurvatureValue(a.curvatureValue, b.curvatureValue) &&
            isEqual_CurvatureConfidence(a.curvatureConfidence, b.curvatureConfidence);
}

bool isEqual_DangerousGoodsExtended(DangerousGoodsExtended_t a,
                                                      DangerousGoodsExtended_t b)
{
    if((!a.emergencyActionCode && b.emergencyActionCode) ||
       (a.emergencyActionCode && !b.elevatedTemperature) ||
       (!a.phoneNumber && b.phoneNumber) ||
       (a.phoneNumber && !b.phoneNumber) ||
       (!a.companyName && b.companyName) ||
       (a.companyName && !b.companyName))
        return false;
    if(a.emergencyActionCode)
        if(!isEqual_OCTET_STRING(*a.emergencyActionCode, *b.emergencyActionCode))
            return false;
    if(a.phoneNumber)
        if(!isEqual_OCTET_STRING(*a.phoneNumber, *b.phoneNumber))
            return false;
    if(a.companyName)
        if(!isEqual_OCTET_STRING(*a.companyName, *b.companyName))
            return false;
    return isEqual_DangerousGoodsBasic(a.dangerousGoodsType, b.dangerousGoodsType) &&
            a.unNumber == b.unNumber &&
            a.elevatedTemperature == b.elevatedTemperature &&
            a.tunnelsRestricted == b.tunnelsRestricted &&
            a.limitedQuantity == b.limitedQuantity;
}

bool isEqual_DeltaReferencePosition(DeltaReferencePosition_t a,
                                                      DeltaReferencePosition_t b)
{
    return isEqual_DeltaLatitude(a.deltaLatitude, b.deltaLatitude) &&
            isEqual_DeltaLongitude(a.deltaLongitude, b.deltaLongitude) &&
            isEqual_DeltaAltitude(a.deltaAltitude, b.deltaAltitude);
}

bool isEqual_EventHistory(EventHistory_t a, EventHistory_t b)
{
    int i;

    if((!a.list.array && b.list.array) || (a.list.array && !b.list.array))
        return false;
    if(a.list.count != b.list.count)
        return false;
    for(i = 0 ; i < a.list.count && isEqual_EventPoint(*a.list.array[i], *b.list.array[i]) ; i++);

    return i == a.list.count;
}

bool isEqual_EventPoint(EventPoint_t a, EventPoint_t b)
{
    if((!a.eventDeltaTime && b.eventDeltaTime) ||
       (a.eventDeltaTime && !b.eventDeltaTime))
        return false;
    if(a.eventDeltaTime)
        if(!isEqual_PathDeltaTime(*a.eventDeltaTime, *b.eventDeltaTime))
            return false;
    return isEqual_DeltaReferencePosition(a.eventPosition, b.eventPosition) &&
            isEqual_InformationQuality(a.informationQuality, b.informationQuality);
}

bool isEqual_Heading(Heading_t a, Heading_t b)
{
    return isEqual_HeadingValue(a.headingValue, b.headingValue) &&
            isEqual_HeadingConfidence(a.headingConfidence, b.headingConfidence);
}

bool isEqual_ItineraryPath(ItineraryPath_t a, ItineraryPath_t b)
{
    int i;

    if((!a.list.array && b.list.array) || (a.list.array && !b.list.array))
        return false;
    if(a.list.count != b.list.count)
        return false;
    for(i = 0 ; i < a.list.count && isEqual_ReferencePosition(*a.list.array[i], *b.list.array[i]) ; i++);
    return i == a.list.count;
}

bool isEqual_ItsPduHeader(ItsPduHeader_t a, ItsPduHeader_t b)
{
    return a.protocolVersion == b.protocolVersion &&
            a.messageID == b.messageID &&
            isEqual_StationID(a.stationID, b.stationID);
}

bool isEqual_LateralAcceleration(LateralAcceleration_t a, LateralAcceleration_t b)
{
    return isEqual_LateralAccelerationValue(a.lateralAccelerationValue, b.lateralAccelerationValue) &&
            isEqual_AccelerationConfidence(a.lateralAccelerationConfidence,
                                         b.lateralAccelerationConfidence);
}

bool isEqual_LongitudinalAcceleration(LongitudinalAcceleration_t a,
                                                        LongitudinalAcceleration_t b)
{
    return isEqual_LongitudinalAccelerationValue(a.longitudinalAccelerationValue,
                                               b.longitudinalAccelerationValue) &&
            isEqual_AccelerationConfidence(a.longitudinalAccelerationConfidence,
                                         b.longitudinalAccelerationConfidence);
}

bool isEqual_PathHistory(PathHistory_t a, PathHistory_t b)
{
    int i;

    if((!a.list.array && b.list.array) || (a.list.array && !b.list.array))
        return false;
    if(a.list.count != b.list.count)
        return false;
    for(i = 0 ; i < a.list.count && isEqual_PathPoint(*a.list.array[i], *b.list.array[i]) ; i++);

    return i == a.list.count;
}

bool isEqual_PathPoint(PathPoint_t a, PathPoint_t b)
{
    if((!a.pathDeltaTime && b.pathDeltaTime) ||
       (a.pathDeltaTime && !b.pathDeltaTime))
        return false;
    if(a.pathDeltaTime)
        if(!isEqual_PathDeltaTime(*a.pathDeltaTime, *b.pathDeltaTime))
            return false;
    return isEqual_DeltaReferencePosition(a.pathPosition, b.pathPosition);
}

bool isEqual_PosConfidenceEllipse(PosConfidenceEllipse_t a,
                                                    PosConfidenceEllipse_t b)
{
    return isEqual_SemiAxisLength(a.semiMajorConfidence, b.semiMajorConfidence) &&
            isEqual_SemiAxisLength(a.semiMinorConfidence, b.semiMinorConfidence) &&
            isEqual_HeadingValue(a.semiMajorOrientation, b.semiMajorOrientation);
}

bool isEqual_PositionOfPillars(PositionOfPillars_t a, PositionOfPillars_t b)
{
    int i;

    if((!a.list.array && b.list.array) || (a.list.array && !b.list.array))
        return false;
    if(a.list.count != b.list.count)
        return false;
    for(i = 0 ; i < a.list.count && isEqual_PosPillar(*a.list.array[i], *b.list.array[i]) ; i++);

    return i == a.list.count;
}

bool isEqual_ProtectedCommunicationZone(ProtectedCommunicationZone_t a,
                                                          ProtectedCommunicationZone_t b)
{
    if((!a.expiryTime && b.expiryTime) ||
       (a.expiryTime && !b.expiryTime) ||
       (!a.protectedZoneRadius && b.protectedZoneRadius) ||
       (a.protectedZoneRadius && !b.protectedZoneRadius) ||
       (!a.protectedZoneID && b.protectedZoneID) ||
       (a.protectedZoneID && !b.protectedZoneID))
        return false;
    if(a.expiryTime)
        if(!isEqual_TimestampIts(*a.expiryTime, *b.expiryTime))
            return false;
    if(a.protectedZoneRadius)
        if(!isEqual_ProtectedZoneRadius(*a.protectedZoneRadius, *b.protectedZoneRadius))
            return false;
    if(a.protectedZoneID)
        if(!isEqual_ProtectedZoneID(*a.protectedZoneID, *b.protectedZoneID))
            return false;
    return isEqual_ProtectedZoneType(a.protectedZoneType, b.protectedZoneType) &&
            isEqual_Latitude(a.protectedZoneLatitude, b.protectedZoneLatitude) &&
            isEqual_Longitude(a.protectedZoneLongitude, b.protectedZoneLongitude);
}

bool isEqual_ProtectedCommunicationZonesRSU(ProtectedCommunicationZonesRSU_t a,
                                                              ProtectedCommunicationZonesRSU_t b)
{
    int i;

    if((!a.list.array && b.list.array) || (a.list.array && !b.list.array))
        return false;
    if(a.list.count != b.list.count)
        return false;
    for(i = 0 ; i < a.list.count && isEqual_ProtectedCommunicationZone(*a.list.array[i],
                                                                       *b.list.array[i]) ; i++);
    return i == a.list.count;
}

bool isEqual_PtActivation(PtActivation_t a, PtActivation_t b)
{
    return isEqual_PtActivationType(a.ptActivationType, b.ptActivationType) &&
            isEqual_PtActivationData(a.ptActivationData, b.ptActivationData);
}

bool isEqual_ReferencePosition(ReferencePosition_t a, ReferencePosition_t b)
{
    return isEqual_Latitude(a.latitude, b.latitude) &&
            isEqual_Longitude(a.longitude, b.longitude) &&
            isEqual_PosConfidenceEllipse(a.positionConfidenceEllipse, b.positionConfidenceEllipse) &&
            isEqual_Altitude(a.altitude, b.altitude);
}

bool isEqual_RestrictedTypes(RestrictedTypes_t a, RestrictedTypes_t b)
{
    int i;

    if((!a.list.array && b.list.array) || (a.list.array && !b.list.array))
        return false;
    if(a.list.count != b.list.count)
        return false;
    for(i = 0 ; i < a.list.count && isEqual_StationType(*a.list.array[i], *b.list.array[i]) ; i++);
    return i == a.list.count;
}

bool isEqual_Speed(Speed_t a, Speed_t b)
{
    return isEqual_SpeedValue(a.speedValue, b.speedValue) &&
            isEqual_SpeedConfidence(a.speedConfidence, b.speedConfidence);
}

bool isEqual_SteeringWheelAngle(SteeringWheelAngle_t a, SteeringWheelAngle_t b)
{
    return isEqual_SteeringWheelAngleValue(a.steeringWheelAngleValue, b.steeringWheelAngleValue) &&
            isEqual_SteeringWheelAngleConfidence(a.steeringWheelAngleConfidence,
                                               b.steeringWheelAngleConfidence);
}

bool isEqual_Traces(Traces_t a, Traces_t b)
{
    int i;

    if((!a.list.array && b.list.array) || (a.list.array && !b.list.array))
        return false;
    if(a.list.count != b.list.count)
        return false;
    for(i = 0 ; i < a.list.count && isEqual_PathHistory(*a.list.array[i], *b.list.array[i]) ; i++);
    return i == a.list.count;
}

bool isEqual_VerticalAcceleration(VerticalAcceleration_t a,
                                                    VerticalAcceleration_t b)
{
    return isEqual_VerticalAccelerationValue(a.verticalAccelerationValue,
                                           b.verticalAccelerationValue) &&
            isEqual_AccelerationConfidence(a.verticalAccelerationConfidence,
                                         b.verticalAccelerationConfidence);
}

bool isEqual_VehicleIdentification(VehicleIdentification_t a,
                                                     VehicleIdentification_t b)
{
    if((!a.wMInumber && b.wMInumber) ||
       (a.wMInumber && !b.wMInumber) ||
       (!a.vDS && b.vDS) ||
       (a.vDS && b.vDS))
        return false;
    if(a.wMInumber)
        if(!isEqual_WMInumber(*a.wMInumber, *b.wMInumber))
            return false;
    if(a.vDS)
        if(!isEqual_VDS(*a.vDS, *b.vDS))
            return false;
    return true;
}

bool isEqual_VehicleLength(VehicleLength_t a, VehicleLength_t b)
{
    return isEqual_VehicleLengthValue(a.vehicleLengthValue, b.vehicleLengthValue) &&
            isEqual_VehicleLengthConfidenceIndication(a.vehicleLengthConfidenceIndication,
                                                    b.vehicleLengthConfidenceIndication);
}

bool isEqual_YawRate(YawRate_t a, YawRate_t b)
{
    return isEqual_YawRateValue(a.yawRateValue, b.yawRateValue) &&
            isEqual_YawRateConfidence(a.yawRateConfidence, b.yawRateConfidence);
}

/************************
 * Maker
 ***********************/
/* ASN */
BIT_STRING_t make_BIT_STRING(int nbits)
{
    BIT_STRING_t b;

    memset(&b, 0, sizeof b);
    b.bits_unused = (8 - (nbits % 8)) % 8;
    b.size = (nbits + 7) / 8;
    b.buf = (uint8_t*)calloc(b.size, 1);

    return b;
}

OCTET_STRING_t make_OCTET_STRING(int length)
{
    char *msg = (char*)calloc(length + 1, sizeof *msg);
    int i;
    OCTET_STRING_t o;

    memset(&o, 0, sizeof o);
    o.size = length;
    o.buf = (uint8_t*)calloc(length, sizeof *o.buf);

    msg[length + 1] = '\0';
    for(i = 0 ; i < length + 1 ; i++)
        msg[i] = 'A';
    OCTET_STRING_fromBuf(&o, msg, length);

    free(msg);

    return o;
}

/* DE */
AccelerationConfidence_t make_AccelerationConfidence()
{
    AccelerationConfidence_t a = AccelerationConfidence_unavailable;

    return a;
}

AccelerationControl_t make_AccelerationControl()
{
    AccelerationControl_t a = make_BIT_STRING(7);

    return a;
}

AccidentSubCauseCode_t make_AccidentSubCauseCode()
{
    AccidentSubCauseCode_t a = AccidentSubCauseCode_unavailable;

    return a;
}

AdverseWeatherCondition_AdhesionSubCauseCode_t make_AdverseWeatherCondition_AdhesionSubCauseCode()
{
    AdverseWeatherCondition_AdhesionSubCauseCode_t a =
            AdverseWeatherCondition_AdhesionSubCauseCode_unavailable;

    return a;
}

AdverseWeatherCondition_ExtremeWeatherConditionSubCauseCode_t make_AdverseWeatherCondition_ExtremeWeatherConditionSubCauseCode()
{
    AdverseWeatherCondition_ExtremeWeatherConditionSubCauseCode_t a = AdverseWeatherCondition_ExtremeWeatherConditionSubCauseCode_unavailable;

    return a;
}

AdverseWeatherCondition_PrecipitationSubCauseCode_t
make_AdverseWeatherCondition_PrecipitationSubCauseCode()
{
    AdverseWeatherCondition_PrecipitationSubCauseCode_t a = AdverseWeatherCondition_PrecipitationSubCauseCode_unavailable;

    return a;
}

AdverseWeatherCondition_VisibilitySubCauseCode_t make_AdverseWeatherCondition_VisibilitySubCauseCode()
{
    AdverseWeatherCondition_VisibilitySubCauseCode_t a =
            AdverseWeatherCondition_VisibilitySubCauseCode_unavailable;

    return a;
}

AltitudeConfidence_t make_AltitudeConfidence()
{
    AltitudeConfidence_t a = AltitudeConfidence_unavailable;

    return a;
}

AltitudeValue_t make_AltitudeValue()
{
    AltitudeValue_t a = AltitudeValue_unavailable;

    return a;
}

CauseCodeType_t make_CauseCodeType()
{
    CauseCodeType_t c = CauseCodeType_reserved;

    return c;
}

CenDsrcTollingZoneID_t make_CenDsrcTollingZoneID()
{
    return make_ProtectedZoneID();
}

CollisionRiskSubCauseCode_t make_CollisionRiskSubCauseCode()
{
    CollisionRiskSubCauseCode_t c = CollisionRiskSubCauseCode_unavailable;

    return c;
}

CurvatureCalculationMode_t make_CurvatureCalculationMode()
{
    CurvatureCalculationMode_t c = CurvatureCalculationMode_unavailable;

    return c;
}

CurvatureConfidence_t make_CurvatureConfidence()
{
    CurvatureConfidence_t c = CurvatureConfidence_unavailable;

    return c;
}

CurvatureValue_t make_CurvatureValue()
{
    CurvatureValue_t c = CurvatureValue_unavailable;

    return c;
}

DangerousEndOfQueueSubCauseCode_t make_DangerousEndOfQueueSubCauseCode()
{
    DangerousEndOfQueueSubCauseCode_t d = DangerousEndOfQueueSubCauseCode_unavailable;

    return d;
}

DangerousGoodsBasic_t make_DangerousGoodsBasic()
{
    DangerousGoodsBasic_t d = DangerousGoodsBasic_miscellaneousDangerousSubstances;

    return d;
}

DangerousSituationSubCauseCode_t make_DangerousSituationSubCauseCode()
{
    DangerousSituationSubCauseCode_t d = DangerousSituationSubCauseCode_unavailable;

    return d;
}

DeltaAltitude_t make_DeltaAltitude()
{
    DeltaAltitude_t d = DeltaAltitude_unavailable;

    return d;
}

DeltaLatitude_t make_DeltaLatitude()
{
    DeltaLatitude_t d = DeltaLatitude_unavailable;

    return d;
}

DeltaLongitude_t make_DeltaLongitude()
{
    DeltaLongitude_t d = DeltaLongitude_unavailable;

    return d;
}

DriveDirection_t make_DriveDirection()
{
    DriveDirection_t d = DriveDirection_unavailable;

    return d;
}

DrivingLaneStatus_t make_DrivingLaneStatus()
{
    DrivingLaneStatus_t d = make_BIT_STRING(1);

    return d;
}

EmbarkationStatus_t make_EmbarkationStatus()
{
    EmbarkationStatus_t e = false;

    return e;
}

EmergencyPriority_t make_EmergencyPriority()
{
    EmergencyPriority_t e = make_BIT_STRING(2);

    return e;
}

EmergencyVehicleApproachingSubCauseCode_t
make_EmergencyVehicleApproachingSubCauseCode()
{
    EmergencyVehicleApproachingSubCauseCode_t e = EmergencyVehicleApproachingSubCauseCode_unavailable;

    return e;
}

EnergyStorageType_t make_EnergyStorageType()
{
    EnergyStorageType_t e = make_BIT_STRING(7);

    return e;
}

ExteriorLights_t make_ExteriorLights()
{
    ExteriorLights_t e = make_BIT_STRING(8);

    return e;
}

HardShoulderStatus_t make_HardShoulderStatus()
{
    HardShoulderStatus_t h = HardShoulderStatus_availableForStopping;

    return h;
}

HazardousLocation_AnimalOnTheRoadSubCauseCode_t make_HazardousLocation_AnimalOnTheRoadSubCauseCode()
{
    HazardousLocation_AnimalOnTheRoadSubCauseCode_t h =
            HazardousLocation_AnimalOnTheRoadSubCauseCode_unavailable;

    return h;
}

HazardousLocation_DangerousCurveSubCauseCode_t make_HazardousLocation_DangerousCurveSubCauseCode()
{
    HazardousLocation_DangerousCurveSubCauseCode_t h =
            HazardousLocation_DangerousCurveSubCauseCode_unavailable;

    return h;
}

HazardousLocation_ObstacleOnTheRoadSubCauseCode_t make_HazardousLocation_ObstacleOnTheRoadSubCauseCode()
{
    HazardousLocation_ObstacleOnTheRoadSubCauseCode_t h =
            HazardousLocation_ObstacleOnTheRoadSubCauseCode_unavailable;

    return h;
}

HazardousLocation_SurfaceConditionSubCauseCode_t make_HazardousLocation_SurfaceConditionSubCauseCode()
{
    HazardousLocation_SurfaceConditionSubCauseCode_t h =
            HazardousLocation_SurfaceConditionSubCauseCode_unavailable;

    return h;
}

HeadingConfidence_t make_HeadingConfidence()
{
    HeadingConfidence_t h = HeadingConfidence_unavailable;

    return h;
}

HeadingValue_t make_HeadingValue()
{
    HeadingValue_t h = HeadingValue_unavailable;

    return h;
}

HeightLonCarr_t make_HeightLonCarr()
{
    HeightLonCarr_t h = HeightLonCarr_unavailable;

    return h;
}

HumanPresenceOnTheRoadSubCauseCode_t make_HumanPresenceOnTheRoadSubCauseCode()
{
    HumanPresenceOnTheRoadSubCauseCode_t h = HumanPresenceOnTheRoadSubCauseCode_unavailable;

    return h;
}

HumanProblemSubCauseCode_t make_HumanProblemSubCauseCode()
{
    HumanProblemSubCauseCode_t h = HumanProblemSubCauseCode_unavailable;

    return h;
}

InformationQuality_t make_InformationQuality()
{
    InformationQuality_t i = InformationQuality_unavailable;

    return i;
}

LanePosition_t make_LanePosition()
{
    LanePosition_t l = LanePosition_offTheRoad;

    return l;
}

LateralAccelerationValue_t make_LateralAccelerationValue()
{
    LateralAccelerationValue_t l = LateralAccelerationValue_unavailable;

    return l;
}

Latitude_t make_Latitude()
{
    Latitude_t l = Latitude_unavailable;

    return l;
}

LightBarSirenInUse_t make_LightBarSirenInUse()
{
    LightBarSirenInUse_t l = make_BIT_STRING(2);

    return l;
}

Longitude_t make_Longitude()
{
    Longitude_t l = Longitude_unavailable;

    return l;
}

LongitudinalAccelerationValue_t make_LongitudinalAccelerationValue()
{
    LongitudinalAccelerationValue_t l = LongitudinalAccelerationValue_unavailable;

    return l;
}

NumberOfOccupants_t make_NumberOfOccupants()
{
    NumberOfOccupants_t n = NumberOfOccupants_unavailable;

    return n;
}

PathDeltaTime_t make_PathDeltaTime()
{
    PathDeltaTime_t p = PathDeltaTime_tenMilliSecondsInPast;

    return p;
}

PerformanceClass_t make_PerformanceClass()
{
    PerformanceClass_t p = PerformanceClass_unavailable;

    return p;
}

PosCentMass_t make_PosCentMass()
{
    PosCentMass_t p = PosCentMass_unavailable;

    return p;
}

PositioningSolutionType_t make_PositioningSolutionType()
{
    PositioningSolutionType_t p = PositioningSolutionType_noPositioningSolution;

    return p;
}

PositionOfOccupants_t make_PositionOfOccupants()
{
    PositionOfOccupants_t p = make_BIT_STRING(20);

    return p;
}

PosFrontAx_t make_PosFrontAx()
{
    PosFrontAx_t p = PosFrontAx_unavailable;

    return p;
}

PosLonCarr_t make_PosLonCarr()
{
    PosLonCarr_t p = PosLonCarr_unavailable;

    return p;
}

PosPillar_t make_PosPillar()
{
    PosPillar_t p = PosPillar_unavailable;

    return p;
}

PostCrashSubCauseCode_t make_PostCrashSubCauseCode()
{
    PostCrashSubCauseCode_t p = PostCrashSubCauseCode_unavailable;

    return p;
}

ProtectedZoneID_t make_ProtectedZoneID()
{
    ProtectedZoneID_t p = 0;

    return p;
}

ProtectedZoneRadius_t make_ProtectedZoneRadius()
{
    ProtectedZoneRadius_t p = ProtectedZoneRadius_oneMeter;

    return p;
}

ProtectedZoneType_t make_ProtectedZoneType()
{
    ProtectedZoneType_t p = ProtectedZoneType_cenDsrcTolling;

    return p;
}

PtActivationData_t make_PtActivationData()
{
    PtActivationData_t p = make_OCTET_STRING(1);

    return p;
}

PtActivationType_t make_PtActivationType()
{
    PtActivationType_t p = PtActivationType_undefinedCodingType;

    return p;
}

RelevanceDistance_t make_RelevanceDistance()
{
    RelevanceDistance_t r = RelevanceDistance_lessThan50m;

    return r;
}

RelevanceTrafficDirection_t make_RelevanceTrafficDirection()
{
    RelevanceTrafficDirection_t r = RelevanceTrafficDirection_allTrafficDirections;

    return r;
}

RequestResponseIndication_t make_RequestResponseIndication()
{
    RequestResponseIndication_t r = RequestResponseIndication_request;

    return r;
}

RescueAndRecoveryWorkInProgressSubCauseCode_t
make_RescueAndRecoveryWorkInProgressSubCauseCode()
{
    RescueAndRecoveryWorkInProgressSubCauseCode_t r =
            RescueAndRecoveryWorkInProgressSubCauseCode_unavailable;

    return r;
}

RoadType_t make_RoadType()
{
    RoadType_t r = RoadType_urban_NoStructuralSeparationToOppositeLanes;

    return r;
}

RoadworksSubCauseCode_t make_RoadworksSubCauseCode()
{
    RoadworksSubCauseCode_t r = RoadworksSubCauseCode_unavailable;

    return r;
}

SemiAxisLength_t make_SemiAxisLength()
{
    SemiAxisLength_t s = SemiAxisLength_unavailable;

    return s;
}

SequenceNumber_t make_SequenceNumber()
{
    SequenceNumber_t s = 0;

    return s;
}

SignalViolationSubCauseCode_t make_SignalViolationSubCauseCode()
{
    SignalViolationSubCauseCode_t s = SignalViolationSubCauseCode_unavailable;

    return s;
}

SlowVehicleSubCauseCode_t make_SlowVehicleSubCauseCode()
{
    SlowVehicleSubCauseCode_t s = SlowVehicleSubCauseCode_unavailable;

    return s;
}

SpecialTransportType_t make_SpecialTransportType()
{
    SpecialTransportType_t s = make_BIT_STRING(4);

    return s;
}

SpeedConfidence_t make_SpeedConfidence()
{
    SpeedConfidence_t s = SpeedConfidence_unavailable;

    return s;
}

SpeedLimit_t make_SpeedLimit()
{
    SpeedLimit_t s = SpeedLimit_oneKmPerHour;

    return s;
}

SpeedValue_t make_SpeedValue()
{
    SpeedValue_t s = SpeedValue_unavailable;

    return s;
}

StationarySince_t make_StationarySince()
{
    StationarySince_t s = StationarySince_lessThan1Minute;

    return s;
}

StationaryVehicleSubCauseCode_t make_StationaryVehicleSubCauseCode()
{
    StationaryVehicleSubCauseCode_t s = StationaryVehicleSubCauseCode_unavailable;

    return s;
}

StationID_t make_StationID()
{
    StationID_t s = 42;

    return s;
}

StationType_t make_StationType()
{
    StationType_t s = StationType_passengerCar;

    return s;
}

SteeringWheelAngleConfidence_t make_SteeringWheelAngleConfidence()
{
    SteeringWheelAngleConfidence_t s = SteeringWheelAngleConfidence_unavailable;

    return s;
}

SteeringWheelAngleValue_t make_SteeringWheelAngleValue()
{
    SteeringWheelAngleValue_t s = SteeringWheelAngleValue_unavailable;

    return s;
}

SubCauseCodeType_t make_SubCauseCodeType(CauseCodeType_t c)
{
    SubCauseCodeType_t s;

    switch(c)
    {
    case(CauseCodeType_reserved):
        s = 0;
        break;
    case(CauseCodeType_trafficCondition):
        s = make_TrafficConditionSubCauseCode();
        break;
    case(CauseCodeType_accident):
        s = make_AccidentSubCauseCode();
        break;
    case(CauseCodeType_roadworks):
        s = make_RoadworksSubCauseCode();
        break;
    case(CauseCodeType_adverseWeatherCondition_Adhesion):
        s = make_AdverseWeatherCondition_AdhesionSubCauseCode();
        break;
    case(CauseCodeType_hazardousLocation_SurfaceCondition):
        s = make_HazardousLocation_SurfaceConditionSubCauseCode();
        break;
    case(CauseCodeType_hazardousLocation_ObstacleOnTheRoad):
        s = make_HazardousLocation_ObstacleOnTheRoadSubCauseCode();
        break;
    case(CauseCodeType_hazardousLocation_AnimalOnTheRoad):
        s = make_HazardousLocation_AnimalOnTheRoadSubCauseCode();
        break;
    case(CauseCodeType_humanPresenceOnTheRoad):
        s = make_HumanPresenceOnTheRoadSubCauseCode();
        break;
    case(CauseCodeType_wrongWayDriving):
        s = make_WrongWayDrivingSubCauseCode();
        break;
    case(CauseCodeType_rescueAndRecoveryWorkInProgress):
        s = make_RescueAndRecoveryWorkInProgressSubCauseCode();
        break;
    case(CauseCodeType_adverseWeatherCondition_ExtremeWeatherCondition):
        s = make_AdverseWeatherCondition_ExtremeWeatherConditionSubCauseCode();
        break;
    case(CauseCodeType_adverseWeatherCondition_Visibility):
        s = make_AdverseWeatherCondition_VisibilitySubCauseCode();
        break;
    case(CauseCodeType_adverseWeatherCondition_Precipitation):
        s = make_AdverseWeatherCondition_PrecipitationSubCauseCode();
        break;
    case(CauseCodeType_slowVehicle):
        s = make_SlowVehicleSubCauseCode();
        break;
    case(CauseCodeType_dangerousEndOfQueue):
        s = make_DangerousEndOfQueueSubCauseCode();
        break;
    case(CauseCodeType_vehicleBreakdown):
        s = make_VehicleBreakdownSubCauseCode();
        break;
    case(CauseCodeType_postCrash):
        s = make_PostCrashSubCauseCode();
        break;
    case(CauseCodeType_humanProblem):
        s = make_HumanProblemSubCauseCode();
        break;
    case(CauseCodeType_stationaryVehicle):
        s = make_StationaryVehicleSubCauseCode();
        break;
    case(CauseCodeType_emergencyVehicleApproaching):
        s = make_EmergencyVehicleApproachingSubCauseCode();
        break;
    case(CauseCodeType_hazardousLocation_DangerousCurve):
        s = make_HazardousLocation_DangerousCurveSubCauseCode();
        break;
    case(CauseCodeType_collisionRisk):
        s = make_CollisionRiskSubCauseCode();
        break;
    case(CauseCodeType_signalViolation):
        s = make_SignalViolationSubCauseCode();
        break;
    case(CauseCodeType_dangerousSituation):
        s = make_DangerousSituationSubCauseCode();
        break;
    default:
        s = 0;
        break;
    }

    return s;
}

TimestampIts_t make_TimestampIts()
{
    TimestampIts_t t;

    memset(&t, 0, sizeof t);
    asn_long2INTEGER((INTEGER_t*)&t, 0);

    return t;
}

Temperature_t make_Temperature()
{
    Temperature_t t = Temperature_equalOrSmallerThanMinus60Deg;

    return t;
}

TrafficConditionSubCauseCode_t make_TrafficConditionSubCauseCode()
{
    TrafficConditionSubCauseCode_t t = TrafficConditionSubCauseCode_unavailable;

    return t;
}

TrafficRule_t make_TrafficRule()
{
    TrafficRule_t t = TrafficRule_noPassing;

    return t;
}

TransmissionInterval_t make_TransmissionInterval()
{
    TransmissionInterval_t t = TransmissionInterval_oneMilliSecond;

    return t;
}

TurningRadius_t make_TurningRadius()
{
    TurningRadius_t t = TurningRadius_unavailable;

    return t;
}

ValidityDuration_t make_ValidityDuration()
{
    ValidityDuration_t v = 600;

    return v;
}

VDS_t make_VDS()
{
    VDS_t v = make_OCTET_STRING(6);

    return v;
}

VehicleBreakdownSubCauseCode_t make_VehicleBreakdownSubCauseCode()
{
    VehicleBreakdownSubCauseCode_t v = VehicleBreakdownSubCauseCode_unavailable;

    return v;
}

VehicleLengthConfidenceIndication_t make_VehicleLengthConfidenceIndication()
{
    VehicleLengthConfidenceIndication_t v = VehicleLengthConfidenceIndication_unavailable;

    return v;
}

VehicleLengthValue_t make_VehicleLengthValue()
{
    VehicleLengthValue_t v = VehicleLengthValue_unavailable;

    return v;
}

VehicleMass_t make_VehicleMass()
{
    VehicleMass_t v = VehicleMass_unavailable;

    return v;
}

VehicleRole_t make_VehicleRole()
{
    VehicleRole_t v = VehicleRole_default;

    return v;
}

VehicleWidth_t make_VehicleWidth()
{
    VehicleWidth_t v = VehicleWidth_unavailable;

    return v;
}

VerticalAccelerationValue_t make_VerticalAccelerationValue()
{
    VerticalAccelerationValue_t v = VerticalAccelerationValue_unavailable;

    return v;
}

WheelBaseVehicle_t make_WheelBaseVehicle()
{
    WheelBaseVehicle_t w = WheelBaseVehicle_unavailable;

    return w;
}

WMInumber_t make_WMINumber()
{
    WMInumber_t w = make_OCTET_STRING(1);

    return w;
}

WrongWayDrivingSubCauseCode_t make_WrongWayDrivingSubCauseCode()
{
    WrongWayDrivingSubCauseCode_t w = WrongWayDrivingSubCauseCode_unavailable;

    return w;
}

YawRateConfidence_t make_YawRateConfidence()
{
    YawRateConfidence_t y = YawRateConfidence_unavailable;

    return y;
}

YawRateValue_t make_YawRateValue()
{
    YawRateValue_t y = YawRateValue_unavailable;

    return y;
}

/* DF */
ActionID_t make_ActionID(StationID_t s)
{
    ActionID_t a;

    memset(&a, 0, sizeof a);
    a.originatingStationID = s;
    a.sequenceNumber = make_SequenceNumber();

    return a;
}

Altitude_t make_Altitude()
{
    Altitude_t a;

    memset(&a, 0, sizeof a);
    a.altitudeValue = make_AltitudeValue();
    a.altitudeConfidence = make_AltitudeConfidence();

    return a;
}

CauseCode_t make_CauseCode()
{
    CauseCode_t c;

    memset(&c, 0, sizeof c);
    c.causeCode = make_CauseCodeType();
    c.subCauseCode = make_SubCauseCodeType(c.causeCode);

    return c;
}

CenDsrcTollingZone_t make_CenDsrcTollingZone()
{
    CenDsrcTollingZone_t c;

    memset(&c, 0, sizeof c);
    c.protectedZoneLatitude = make_Latitude();
    c.protectedZoneLongitude = make_Longitude();
    c.cenDsrcTollingZoneID = 0;

    return c;
}

ClosedLanes_t make_ClosedLanes()
{
    ClosedLanes_t c;

    memset(&c, 0, sizeof c);
    c.hardShoulderStatus = 0;
    c.drivingLaneStatus = make_DrivingLaneStatus();

    return c;
}

Curvature_t make_Curvature()
{
    Curvature_t c;

    memset(&c, 0, sizeof c);
    c.curvatureValue = make_CurvatureValue();
    c.curvatureConfidence = make_CurvatureConfidence();

    return c;
}

DangerousGoodsExtended_t make_DangerousGoodsExtended()
{
    DangerousGoodsExtended_t d;

    memset(&d, 0, sizeof d);
    d.dangerousGoodsType = make_DangerousGoodsBasic();
    d.unNumber = 0;
    d.elevatedTemperature = false;
    d.tunnelsRestricted = false;
    d.limitedQuantity = false;
    d.emergencyActionCode = 0;
    d.phoneNumber = 0;
    d.companyName = 0;

    return d;
}

DeltaReferencePosition_t make_DeltaReferencePosition()
{
    DeltaReferencePosition_t d;

    memset(&d, 0, sizeof d);
    d.deltaLatitude = make_DeltaLatitude();
    d.deltaLongitude = make_DeltaLongitude();
    d.deltaAltitude = make_DeltaAltitude();

    return d;
}

EventHistory_t make_EventHistory()
{
    EventHistory_t e;
    EventPoint_t ep = make_EventPoint();

    memset(&e, 0, sizeof e);
    e.list.array = (EventPoint_t**)calloc(1, sizeof *e.list.array);
    e.list.array[0] = (EventPoint_t*)calloc(1, sizeof *e.list.array[0]);
    e.list.count = 0;
    e.list.size = 0;
    asn_sequence_add(&e, &ep);

    return e;
}

EventPoint_t make_EventPoint()
{
    EventPoint_t e;

    memset(&e, 0, sizeof e);
    e.eventPosition = make_DeltaReferencePosition();
    e.eventDeltaTime = 0;
    e.informationQuality = make_InformationQuality();

    return e;
}

Heading_t make_Heading()
{
    Heading_t h;

    memset(&h, 0, sizeof h);
    h.headingValue = make_HeadingValue();
    h.headingConfidence = make_HeadingConfidence();

    return h;
}

ItineraryPath_t make_ItineraryPath()
{
    ItineraryPath_t i;
    ReferencePosition_t r = make_ReferencePosition();

    memset(&i, 0, sizeof i);
    i.list.array = (ReferencePosition_t**)calloc(1, sizeof *i.list.array);
    i.list.array[0] = (ReferencePosition_t*)calloc(1, sizeof *i.list.array[0]);
    i.list.count = 0;
    i.list.size = 0;
    asn_sequence_add(&i, &r);

    return i;
}

ItsPduHeader_t make_ItsPduHeader(int messageID)
{
    ItsPduHeader_t i;

    memset(&i, 0, sizeof i);
    i.protocolVersion = protocolVersion_currentVersion;
    i.messageID = messageID;
    i.stationID = make_StationID();

    return i;
}

LateralAcceleration_t make_LateralAcceleration()
{
    LateralAcceleration_t l;

    memset(&l, 0, sizeof l);
    l.lateralAccelerationValue = make_LateralAccelerationValue();
    l.lateralAccelerationConfidence = make_AccelerationConfidence();

    return l;
}

LongitudinalAcceleration_t make_LongitudinalAcceleration()
{
    LongitudinalAcceleration_t l;

    memset(&l, 0, sizeof l);
    l.longitudinalAccelerationValue = make_LongitudinalAccelerationValue();
    l.longitudinalAccelerationConfidence = make_AccelerationConfidence();

    return l;
}

PathHistory_t make_PathHistory()
{
    PathHistory_t p;

    memset(&p, 0, sizeof p);
    p.list.array = (PathPoint_t**)calloc(1, sizeof *p.list.array);
    p.list.count = 0;
    p.list.size = 0;

    return p;
}

PathPoint_t make_PathPoint()
{
    PathPoint_t p;

    memset(&p, 0, sizeof p);
    p.pathPosition = make_DeltaReferencePosition();
    p.pathDeltaTime = 0;

    return p;
}

PosConfidenceEllipse_t make_PosConfidenceEllipse()
{
    PosConfidenceEllipse_t p;

    memset(&p, 0, sizeof p);
    p.semiMajorConfidence = make_SemiAxisLength();
    p.semiMinorConfidence = make_SemiAxisLength();
    p.semiMajorOrientation = make_HeadingValue();

    return p;
}

PositionOfPillars_t make_PositionOfPillars()
{
    PositionOfPillars_t p;
    PosPillar_t pp = make_PosPillar();

    memset(&p, 0, sizeof p);
    p.list.array = (PosPillar_t**)calloc(1, sizeof *p.list.array);
    p.list.array[0] = (PosPillar_t*)calloc(1, sizeof p.list.array[0]);
    p.list.count = 0;
    p.list.size = 0;
    asn_sequence_add(&p, &pp);

    return p;
}

ProtectedCommunicationZone_t make_ProtectedCommunicationZone()
{
    ProtectedCommunicationZone_t p;

    memset(&p, 0, sizeof p);
    p.protectedZoneType = make_ProtectedZoneType();
    p.expiryTime = 0;
    p.protectedZoneLatitude = make_Latitude();
    p.protectedZoneLongitude = make_Longitude();
    p.protectedZoneRadius = 0;
    p.protectedZoneID = 0;

    return p;
}

ProtectedCommunicationZonesRSU_t make_ProtectedCommunicationZonesRSU()
{
    ProtectedCommunicationZonesRSU_t p;
    ProtectedCommunicationZone_t pc = make_ProtectedCommunicationZone();

    memset(&p, 0, sizeof p);
    p.list.array = (ProtectedCommunicationZone_t**)calloc(1, sizeof p.list.array);
    p.list.array[0] = (ProtectedCommunicationZone_t*)calloc(1, sizeof p.list.array[0]);
    p.list.count = 0;
    p.list.size = 0;
    asn_sequence_add(&p, &pc);

    return p;
}

PtActivation_t make_PtActivation()
{
    PtActivation_t p;

    memset(&p, 0, sizeof p);
    p.ptActivationType = make_PtActivationType();
    p.ptActivationData = make_PtActivationData();

    return p;
}

ReferencePosition_t make_ReferencePosition()
{
    ReferencePosition_t r;

    memset(&r, 0, sizeof r);
    r.latitude = make_Latitude();
    r.longitude = make_Longitude();
    r.positionConfidenceEllipse = make_PosConfidenceEllipse();
    r.altitude = make_Altitude();

    return r;
}

RestrictedTypes_t make_RestrictedTypes()
{
    RestrictedTypes_t r;
    StationType_t s = make_StationType();

    memset(&r, 0, sizeof r);
    r.list.array = (StationType_t**)calloc(1, sizeof *r.list.array);
    r.list.array[0] = (StationType_t*)calloc(1, sizeof *r.list.array[0]);
    r.list.count = 0;
    r.list.size = 0;
    asn_sequence_add(&r, &s);

    return r;
}

Speed_t make_Speed()
{
    Speed_t s;

    memset(&s, 0, sizeof s);
    s.speedValue = make_SpeedValue();
    s.speedConfidence = make_SpeedConfidence();

    return s;
}

SteeringWheelAngle_t make_SteeringWheelAngle()
{
    SteeringWheelAngle_t s;

    memset(&s, 0, sizeof s);
    s.steeringWheelAngleValue = make_SteeringWheelAngleValue();
    s.steeringWheelAngleConfidence = make_SteeringWheelAngleConfidence();

    return s;
}

Traces_t make_Traces()
{
    Traces_t t;
    PathHistory_t p = make_PathHistory();

    memset(&t, 0, sizeof t);
    t.list.array = (PathHistory_t**)calloc(1, sizeof *t.list.array);
    t.list.array[0] = (PathHistory_t*)calloc(1, sizeof *t.list.array[0]);
    t.list.count = 0;
    t.list.size = 0;
    asn_sequence_add(&t, &p);

    return t;
}

VehicleIdentification_t make_VehicleIdentification()
{
    VehicleIdentification_t v;

    memset(&v, 0, sizeof v);
    v.wMInumber = 0;
    v.vDS = 0;

    return v;
}

VehicleLength_t make_VehicleLength()
{
    VehicleLength_t v;

    memset(&v, 0, sizeof v);
    v.vehicleLengthValue = make_VehicleLengthValue();
    v.vehicleLengthConfidenceIndication = make_VehicleLengthConfidenceIndication();

    return v;
}

VerticalAcceleration_t make_VerticalAcceleration()
{
    VerticalAcceleration_t v;

    v.verticalAccelerationValue = make_VerticalAccelerationValue();
    v.verticalAccelerationConfidence = make_AccelerationConfidence();

    return v;
}

YawRate_t make_YawRate()
{
    YawRate_t y;

    memset(&y, 0, sizeof y);
    y.yawRateValue = make_YawRateValue();
    y.yawRateConfidence = make_YawRateConfidence();

    return y;
}

/*******************************
 * General API
 ******************************/
static QHash<CauseCodeType_t, QString> causeCodeTypeHash;
static QHash<CauseCodeType_t, QList<QString>> subCauseCodeTypeHash;
static bool initializedCauseCodeHash = false;

static QString reservedSubCauseCodeString[] =
{
    "unavailable"
};
static QString accidentSubCauseCodeString[] =
{
    "unavailable",
    "multiVehicleAccident",
    "heavyAccident",
    "accidentInvolvingLorry",
    "accidentInvolvingBus",
    "accidentInvolvingHazardousMaterials",
    "accidentOnOppositeLane",
    "unsecuredAccident",
    "assistanceRequested"
};
static QString adverseWeatherCondition_AdhesionSubCauseCodeString[] =
{
    "unavailable",
    "heavyFrostOnRoad",
    "fuelOnRoad",
    "mudOnRoad",
    "snowOnRoad",
    "iceOnRoad",
    "blackIceOnRoad",
    "oilOnRoad",
    "looseChippings",
    "instantBlackIce",
    "roadsSalted"
};
static QString adverseWeatherCondition_ExtremeWeatherConditionSubCauseCodeString[] =
{
    "unavailable",
    "strongWinds",
    "damagingHail",
    "hurricane",
    "thunderstorm",
    "tornado",
    "blizzard"
};
static QString adverseWeatherCondition_PrecipitationSubCauseCodeString[] =
{
    "unavailable",
    "heavyRain",
    "heavySnowfall",
    "softHail"
};
static QString adverseWeatherCondition_VisibilitySubCauseCodeString[] =
{
    "unavailable",
    "fog",
    "smoke",
    "heavySnowfall",
    "heavyRain",
    "heavyHail",
    "lowSunGlare",
    "sandstorms",
    "swarmsOfInsects"
};
static QString collisionRiskSubCauseCodeString[] =
{
    "unavailable",
    "longitudinalCollisionRisk",
    "crossingCollisionRisk",
    "lateralCollisionRisk",
    "vulnerableRoadUser"
};
static QString dangerousEndOfQueueSubCauseCodeString[] =
{
    "unavailable",
    "suddenEndOfQueue",
    "queueOverHill",
    "queueAroundBend",
    "queueInTunnel"
};
static QString dangerousSituationSubCauseCodeString[] =
{
    "unavailable",
    "emergencyElectronicBrakeEngaged",
    "preCrashSystemEngaged",
    "espEngaged",
    "absEngaged",
    "aebEngaged",
    "brakeWarningEngaged",
    "collisionRiskWarningEngaged"
};
static QString emergencyVehicleApproachingSubCauseCodeString[] =
{
    "unavailable",
    "emergencyVehicleApproaching",
    "prioritizedVehicleApproaching"
};
static QString hazardousLocation_AnimalOnTheRoadSubCauseCodeString[] =
{
    "unavailable",
    "wildAnimals",
    "herdOfAnimals",
    "smallAnimals",
    "largeAnimals"
};
static QString hazardousLocation_DangerousCurveSubCauseCodeString[] =
{
    "unavailable",
    "dangerousLeftTurnCurve",
    "dangerousRightTurnCurve",
    "multipleCurvesStartingWithUnknownTurningDirection",
    "multipleCurvesStartingWithLeftTurn",
    "multipleCurvesStartingWithRightTurn"
};
static QString hazardousLocation_ObstacleOnTheRoadSubCauseCodeString[] =
{
    "unavailable",
    "shedLoad",
    "partsOfVehicles",
    "partsOfTyres",
    "bigObjects",
    "fallenTrees",
    "hubCaps",
    "waitingVehicles"
};
static QString hazardousLocation_SurfaceConditionSubCauseCodeString[] =
{
    "unavailable",
    "rockfalls",
    "earthquakeDamage",
    "sewerCollapse",
    "subsidence",
    "snowDrifts",
    "stormDamage",
    "burstPipe",
    "volcanoEruption",
    "fallingIce"
};
static QString humanPresenceOnTheRoadSubCauseCodeString[] =
{
    "unavailable",
    "childrenOnRoadway",
    "cyclistOnRoadway",
    "motorcyclistOnRoadway"
};
static QString humanProblemSubCauseCodeString[] =
{
    "unavailable",
    "glycemiaProblem",
    "heartProblem"
};
static QString postCrashSubCauseCodeString[] =
{
    "unavailable",
    "accidentWithoutECallTriggered",
    "accidentWithECallManuallyTriggered",
    "accidentWithECallAutomaticallyTriggered",
    "accidentWithECallTriggeredWithoutAccessToCellularNetwork"
};
static QString rescueAndRecoveryWorkInProgressSubCauseCodeString[] =
{
    "unavailable",
    "emergencyVehicles",
    "rescueHelicopterLanding",
    "policeActivityOngoing",
    "medicalEmergencyOngoing",
    "childAbductionInProgress"
};
static QString roadworksSubCauseCodeString[] =
{
    "unavailable",
    "majorRoadworks",
    "roadMarkingWork",
    "slowMovingRoadMaintenance",
    "shortTermStationaryRoadworks",
    "streetCleaning",
    "winterService"
};
static QString signalViolationSubCauseCodeString[] =
{
    "unavailable",
    "stopSignViolation",
    "trafficLightViolation",
    "turningRegulationViolation"
};
static QString slowVehicleSubCauseCodeString[] =
{
    "unavailable",
    "maintenanceVehicle",
    "vehiclesSlowingToLookAtAccident",
    "abnormalLoad",
    "abnormalWideLoad",
    "convoy",
    "snowplough",
    "deicing",
    "saltingVehicles"
};
static QString stationaryVehicleSubCauseCodeString[] =
{
    "unavailable",
    "humanProblem",
    "vehicleBreakdown",
    "postCrash",
    "publicTransportStop",
    "carryingDangerousGoods"
};
static QString trafficConditionSubCauseCodeString[] =
{
    "unavailable",
    "increasedVolumeOfTraffic",
    "trafficJamSlowlyIncreasing",
    "trafficJamIncreasing",
    "trafficJamStronglyIncreasing",
    "trafficStationary",
    "trafficJamSlightlyDecreasing",
    "trafficJamDecreasing",
    "trafficJamStronglyDecreasing"
};
static QString vehicleBreakdownSubCauseCodeString[] =
{
    "unavailable",
    "lackOfFuel",
    "lackOfBatteryPower",
    "engineProblem",
    "transmissionProblem",
    "engineCoolingProblem",
    "brakingSystemProblem",
    "steeringProblem",
    "tyrePuncture"
};
static QString wrongWayDrivingSubCauseCodeString[] =
{
    "unavailable",
    "wrongLane",
    "wrongDirection"
};

void initializeCauseCodeHash()
{
    unsigned int i;

    causeCodeTypeHash[CauseCodeType_reserved] = "reserved";
    causeCodeTypeHash[CauseCodeType_trafficCondition] = "trafficCondition";
    causeCodeTypeHash[CauseCodeType_accident] = "accident";
    causeCodeTypeHash[CauseCodeType_roadworks] = "roadworks";
    causeCodeTypeHash[CauseCodeType_adverseWeatherCondition_Adhesion] = "adverseWeatherCondition_Adhesion";
    causeCodeTypeHash[CauseCodeType_hazardousLocation_SurfaceCondition] = "hazardousLocation_SurfaceCondition";
    causeCodeTypeHash[CauseCodeType_hazardousLocation_ObstacleOnTheRoad] = "hazardousLocation_ObstacleOnTheRoad";
    causeCodeTypeHash[CauseCodeType_hazardousLocation_AnimalOnTheRoad] = "hazardousLocation_AnimalOnTheRoad";
    causeCodeTypeHash[CauseCodeType_humanPresenceOnTheRoad] = "humanPresenceOnTheRoad";
    causeCodeTypeHash[CauseCodeType_wrongWayDriving] = "wrongWayDriving";
    causeCodeTypeHash[CauseCodeType_rescueAndRecoveryWorkInProgress] = "rescueAndRecoveryWorkInProgress";
    causeCodeTypeHash[CauseCodeType_adverseWeatherCondition_ExtremeWeatherCondition] = "adverseWeatherCondition_ExtremeWeatherCondition";
    causeCodeTypeHash[CauseCodeType_adverseWeatherCondition_Visibility] = "adverseWeatherCondition_Visibility";
    causeCodeTypeHash[CauseCodeType_adverseWeatherCondition_Precipitation] = "adverseWeatherCondition_Precipitation";
    causeCodeTypeHash[CauseCodeType_slowVehicle] = "slowVehicle";
    causeCodeTypeHash[CauseCodeType_dangerousEndOfQueue] = "dangerousEndOfQueue";
    causeCodeTypeHash[CauseCodeType_vehicleBreakdown] = "vehicleBreakdown";
    causeCodeTypeHash[CauseCodeType_postCrash] = "postCrash";
    causeCodeTypeHash[CauseCodeType_humanProblem] = "humanProblem";
    causeCodeTypeHash[CauseCodeType_stationaryVehicle] = "stationaryVehicle";
    causeCodeTypeHash[CauseCodeType_emergencyVehicleApproaching] = "emergencyVehicleApproaching";
    causeCodeTypeHash[CauseCodeType_hazardousLocation_DangerousCurve] = "hazardousLocation_DangerousCurve";
    causeCodeTypeHash[CauseCodeType_collisionRisk] = "collisionRisk";
    causeCodeTypeHash[CauseCodeType_signalViolation] = "signalViolation";
    causeCodeTypeHash[CauseCodeType_dangerousSituation] = "dangerousSituation";

    for(i = 0 ; i < 1 ; i++)
        subCauseCodeTypeHash[CauseCodeType_reserved].append(reservedSubCauseCodeString[i]);
    for(i = 0 ; i < 9 ; i++)
        subCauseCodeTypeHash[CauseCodeType_trafficCondition].append(trafficConditionSubCauseCodeString[i]);
    for(i = 0 ; i < 9 ; i++)
        subCauseCodeTypeHash[CauseCodeType_accident].append(accidentSubCauseCodeString[i]);
    for(i = 0 ; i < 7 ; i++)
        subCauseCodeTypeHash[CauseCodeType_roadworks].append(roadworksSubCauseCodeString[i]);
    for(i = 0 ; i < 11 ; i++)
        subCauseCodeTypeHash[CauseCodeType_adverseWeatherCondition_Adhesion].append(adverseWeatherCondition_AdhesionSubCauseCodeString[i]);
    for(i = 0 ; i < 10 ; i++)
        subCauseCodeTypeHash[CauseCodeType_hazardousLocation_SurfaceCondition].append(hazardousLocation_SurfaceConditionSubCauseCodeString[i]);
    for(i = 0 ; i < 8 ; i++)
        subCauseCodeTypeHash[CauseCodeType_hazardousLocation_ObstacleOnTheRoad].append(hazardousLocation_ObstacleOnTheRoadSubCauseCodeString[i]);
    for(i = 0 ; i < 5 ; i++)
        subCauseCodeTypeHash[CauseCodeType_hazardousLocation_AnimalOnTheRoad].append(hazardousLocation_AnimalOnTheRoadSubCauseCodeString[i]);
    for(i = 0 ; i < 4 ; i++)
        subCauseCodeTypeHash[CauseCodeType_humanPresenceOnTheRoad].append(humanPresenceOnTheRoadSubCauseCodeString[i]);
    for(i = 0 ; i < 3 ; i++)
        subCauseCodeTypeHash[CauseCodeType_wrongWayDriving].append(wrongWayDrivingSubCauseCodeString[i]);
    for(i = 0 ; i < 6 ; i++)
        subCauseCodeTypeHash[CauseCodeType_rescueAndRecoveryWorkInProgress].append(rescueAndRecoveryWorkInProgressSubCauseCodeString[i]);
    for(i = 0 ; i < 7 ; i++)
        subCauseCodeTypeHash[CauseCodeType_adverseWeatherCondition_ExtremeWeatherCondition].append(adverseWeatherCondition_ExtremeWeatherConditionSubCauseCodeString[i]);
    for(i = 0 ; i < 9 ; i++)
        subCauseCodeTypeHash[CauseCodeType_adverseWeatherCondition_Visibility].append(adverseWeatherCondition_VisibilitySubCauseCodeString[i]);
    for(i = 0 ; i < 4 ; i++)
        subCauseCodeTypeHash[CauseCodeType_adverseWeatherCondition_Precipitation].append(adverseWeatherCondition_PrecipitationSubCauseCodeString[i]);
    for(i = 0 ; i < 9 ; i++)
        subCauseCodeTypeHash[CauseCodeType_slowVehicle].append(slowVehicleSubCauseCodeString[i]);
    for(i = 0 ; i < 5 ; i++)
        subCauseCodeTypeHash[CauseCodeType_dangerousEndOfQueue].append(dangerousEndOfQueueSubCauseCodeString[i]);
    for(i = 0 ; i < 9 ; i++)
        subCauseCodeTypeHash[CauseCodeType_vehicleBreakdown].append(vehicleBreakdownSubCauseCodeString[i]);
    for(i = 0 ; i < 5 ; i++)
        subCauseCodeTypeHash[CauseCodeType_postCrash].append(postCrashSubCauseCodeString[i]);
    for(i = 0 ; i < 3 ; i++)
        subCauseCodeTypeHash[CauseCodeType_humanProblem].append(humanProblemSubCauseCodeString[i]);
    for(i = 0 ; i < 6 ; i++)
        subCauseCodeTypeHash[CauseCodeType_stationaryVehicle].append(stationaryVehicleSubCauseCodeString[i]);
    for(i = 0 ; i < 3 ; i++)
        subCauseCodeTypeHash[CauseCodeType_emergencyVehicleApproaching].append(emergencyVehicleApproachingSubCauseCodeString[i]);
    for(i = 0 ; i < 6 ; i++)
        subCauseCodeTypeHash[CauseCodeType_hazardousLocation_DangerousCurve].append(hazardousLocation_DangerousCurveSubCauseCodeString[i]);
    for(i = 0 ; i < 5 ; i++)
        subCauseCodeTypeHash[CauseCodeType_collisionRisk].append(collisionRiskSubCauseCodeString[i]);
    for(i = 0 ; i < 4 ; i++)
        subCauseCodeTypeHash[CauseCodeType_signalViolation].append(signalViolationSubCauseCodeString[i]);
    for(i = 0 ; i < 8 ; i++)
        subCauseCodeTypeHash[CauseCodeType_dangerousSituation].append(dangerousSituationSubCauseCodeString[i]);
}

QString CauseCodeType2String(CauseCodeType_t c)
{
    if(!initializedCauseCodeHash)
        initializeCauseCodeHash();

    return causeCodeTypeHash[c];
}

QString SubCauseCodeType2String(CauseCodeType_t c, SubCauseCodeType_t s)
{
    if(!initializedCauseCodeHash)
        initializeCauseCodeHash();

    return subCauseCodeTypeHash[c].at(s);
}