facilitiesApi.cpp

Go to the documentation of this file.

#include <facilitiesApi.h>

/*
 * Getters
 */
/*
 * DE
 */
/*
CurvatureCalculationMode_t getConfCurvatureCalculationMode(){return CurvatureCalculationMode_unavailable;}

DangerousGoodsBasic_t getConfDangerousGoodsBasic(){return DangerousGoodsBasic_miscellaneousDangerousSubstances;}

DriveDirection_t getConfDriveDirection(){return DriveDirection_unavailable;}

EmbarkationStatus_t getConfEmbarkationStatus(){return false;}

ExteriorLights_t getConfExteriorLights()
{
    ExteriorLights_t e;

    e.bits_unused = 0;
    e.size = 1;
    e.buf = (uint8_t*)calloc(e.size, 1);

    return e;
}

LightBarSirenInUse_t getConfLightBarSirenInUse()
{
    LightBarSirenInUse_t l;

    l.bits_unused = 6;
    l.size = 1;
    l.buf = (uint8_t*)calloc(l.size, 1);

    return l;
}

SpecialTransportType_t getConfSpecialTransportType()
{
    SpecialTransportType_t s;

    s.bits_unused = 4;
    s.size = 1;
    s.buf = (uint8_t*)calloc(s.size, 1);

    return s;
}

StationID_t getConfStationID()
{
    StationID_t s = rand() % 256;

    return s;

}

StationType_t getConfStationType(){return StationType_passengerCar;}

VehicleRole_t getConfVehicleRole(){return VehicleRole_default;}

VehicleWidth_t getConfVehicleWidth(){return VehicleWidth_unavailable;}
*/

/*
 * DF
 */
/*
Curvature_t getConfCurvature()
{
    Curvature_t c;

    c.curvatureValue = CurvatureValue_unavailable;
    c.curvatureConfidence = CurvatureConfidence_unavailable;

    return c;
}

LongitudinalAcceleration_t getConfLongitudinalAcceleration()
{
    LongitudinalAcceleration_t l;

    l.longitudinalAccelerationValue = LongitudinalAccelerationValue_unavailable;
    l.longitudinalAccelerationConfidence = AccelerationConfidence_unavailable;

    return l;
}

PathHistory_t getConfPathHistory()
{
    PathHistory_t p;

    p.list.array = 0;
    p.list.count = 0;

    return p;
}

VehicleLength_t getConfVehicleLength()
{
    VehicleLength_t v;

    v.vehicleLengthValue = VehicleLengthValue_unavailable;
    v.vehicleLengthConfidenceIndication = VehicleLengthConfidenceIndication_unavailable;

    return v;
}

YawRate_t getConfYawRate()
{
    YawRate_t y;

    y.yawRateValue = YawRateValue_unavailable;
    y.yawRateConfidence = YawRateConfidence_unavailable;

    return y;
}
*/

/*
 * Setters
 */
/*
 * ASN.1
 */
BIT_STRING_t setBitString(BIT_STRING_t b)
{
    BIT_STRING_t other;

    other.bits_unused = b.bits_unused;
    other.size = b.size;
    other.buf = (uint8_t*)calloc(other.size, 1);
    memcpy(other.buf, b.buf, other.size);

    return other;
}

BOOLEAN_t setBoolean(BOOLEAN_t b){return b;}

IA5String_t setIA5String(IA5String_t i)
{
    IA5String_t other;

    other.size = i.size;
    other.buf = (uint8_t*)calloc(i.size, 1);
    memcpy(other.buf, i.buf, other.size);

    return other;
}

INTEGER_t setInteger(INTEGER_t i)
{
    INTEGER_t other;
    memcpy(&other, &i, sizeof i);

    return other;
}

OCTET_STRING_t setOctetString(OCTET_STRING_t o)
{
    OCTET_STRING_t other;

    other.size = o.size;
    other.buf = (uint8_t*)calloc(other.size, 1);
    memcpy(other.buf, o.buf, other.size);

    return other;
}

UTF8String_t setUTF8String(UTF8String_t u)
{
    UTF8String_t other;

    other.size = u.size;
    other.buf = (uint8_t*)calloc(other.size, 1);
    memcpy(other.buf, u.buf, other.size);

    return other;
}

/*
 * Common Data Dictionnary
 */
/*
 * DE
 */
AccelerationConfidence_t setAccelerationConfidence(AccelerationConfidence_t a){return a;}
AccelerationControl_t setAccelerationControl(AccelerationControl_t a){return setBitString(a);}
AccidentSubCauseCode_t setAccidentSubCauseCode(AccidentSubCauseCode_t a){return a;}
AdverseWeatherCondition_AdhesionSubCauseCode_t setAdverseWeatherCondition_AdhesionSubCauseCode(
        AdverseWeatherCondition_AdhesionSubCauseCode_t a){return a;}
AdverseWeatherCondition_ExtremeWeatherConditionSubCauseCode_t
setAdverseWeatherCondition_ExtremeWeatherConditionSubCauseCode(
        AdverseWeatherCondition_ExtremeWeatherConditionSubCauseCode_t a){return a;}
AdverseWeatherCondition_PrecipitationSubCauseCode_t
setAdverseWeatherCondition_PrecipitationSubCauseCode(
        AdverseWeatherCondition_PrecipitationSubCauseCode a){return a;}
AdverseWeatherCondition_VisibilitySubCauseCode_t setAdverseWeatherCondition_VisibilitySubCauseCode(
        AdverseWeatherCondition_VisibilitySubCauseCode_t a){return a;}
AltitudeConfidence_t setAltitudeConfidence(AltitudeConfidence_t a){return a;}
AltitudeValue_t setAltitudeValue(AltitudeValue_t a){return a;}
CauseCodeType_t setCauseCodeType(CauseCodeType_t c){return c;}
CenDsrcTollingZoneID_t setCenDsrcTollingZoneID(CenDsrcTollingZoneID_t c){return c;}
CollisionRiskSubCauseCode_t setCollisionRiskSubCauseCode(CollisionRiskSubCauseCode_t c){return c;}
CurvatureCalculationMode_t setCurvatureCalculationMode(CurvatureCalculationMode_t c){return c;}
CurvatureConfidence_t setCurvatureConfidence(CurvatureConfidence_t c){return c;}
CurvatureValue_t setCurvatureValue(CurvatureValue_t c){return c;}
DangerousEndOfQueueSubCauseCode_t setDangerousEndOfQueueSubCauseCode(
        DangerousEndOfQueueSubCauseCode_t d){return d;}
DangerousGoodsBasic_t setDangerousGoodsBasic(DangerousGoodsBasic_t d){return d;}
DangerousSituationSubCauseCode_t setDangerousSituationSubCauseCode(DangerousSituationSubCauseCode_t d)
{return d;}
DeltaAltitude_t setDeltaAltitude(DeltaAltitude_t d){return d;}
DeltaLatitude_t setDeltaLatitude(DeltaLatitude_t d){return d;}
DeltaLongitude_t setDeltaLongitude(DeltaLongitude_t d){return d;}
DriveDirection_t setDriveDirection(DriveDirection_t d){return d;}
DrivingLaneStatus_t setDrivingLaneStatus(DrivingLaneStatus_t d){return d;}
EmbarkationStatus_t setEmbarkationStatus(EmbarkationStatus_t e){return e;}
EmergencyPriority_t setEmergencyPriority(EmergencyPriority_t e){return e;}
EmergencyVehicleApproachingSubCauseCode_t setEmergencyVehicleApproachingSubCauseCode(
        EmergencyVehicleApproachingSubCauseCode_t e){return e;}
EnergyStorageType_t setEnergyStorageType(EnergyStorageType_t e){return setBitString(e);}
ExteriorLights_t setExteriorLights(ExteriorLights_t e){return setBitString(e);}
HardShoulderStatus_t setHardShoulderStatus(HardShoulderStatus_t h){return h;}
HazardousLocation_AnimalOnTheRoadSubCauseCode_t setHazardousLocation_AnimalOnTheRoadSubCauseCode(
        HazardousLocation_AnimalOnTheRoadSubCauseCode_t h){return h;}
HazardousLocation_DangerousCurveSubCauseCode_t setHazardousLocation_DangerousCurveSubCauseCode(
        HazardousLocation_DangerousCurveSubCauseCode_t h){return h;}
HazardousLocation_ObstacleOnTheRoadSubCauseCode_t setHazardousLocation_ObstacleOnTheRoadSubCauseCode(
        HazardousLocation_ObstacleOnTheRoadSubCauseCode_t h){return h;}
HazardousLocation_SurfaceConditionSubCauseCode_t setHazardousLocation_SurfaceConditionSubCauseCode(
        HazardousLocation_SurfaceConditionSubCauseCode_t h){return h;}
HeadingConfidence_t setHeadingConfidence(HeadingConfidence_t h){return h;}
HeadingValue_t setHeadingValue(HeadingValue_t h){return h;}
HeightLonCarr_t setHeightLonCarr(HeightLonCarr_t h){return h;}
HumanPresenceOnTheRoadSubCauseCode_t setHumanPresenceOnTheRoadSubCauseCode(
        HumanPresenceOnTheRoadSubCauseCode_t h){return h;}
HumanProblemSubCauseCode_t setHumanProblemSubCauseCode(HumanProblemSubCauseCode_t h){return h;}
InformationQuality_t setInformationQuality(InformationQuality_t i){return i;}
LanePosition_t setLanePosition(LanePosition_t l){return l;}
Latitude_t setLatitude(Latitude_t l){return l;}
LateralAccelerationValue_t setLateralAccelerationValue(LateralAccelerationValue_t l){return l;}
LightBarSirenInUse_t setLightBarSirenInUse(LightBarSirenInUse_t l){return setBitString(l);}
Longitude_t setLongitude(Longitude_t l){return l;}
LongitudinalAccelerationValue_t setLongitudinalAccelerationValue(LongitudinalAccelerationValue_t l)
{return l;}
NumberOfOccupants_t setNumberOfOccupants(NumberOfOccupants_t n){return n;}
PathDeltaTime_t setPathDeltaTime(PathDeltaTime_t p){return p;}
PerformanceClass_t setPerformanceClass(PerformanceClass_t p){return p;}
PosCentMass_t setPosCentMass(PosCentMass_t p){return p;}
PositioningSolutionType_t setPositioningSolutionType(PositioningSolutionType_t p){return p;}
PositionOfOccupants_t setPositionOfOccupants(PositionOfOccupants_t p){return setBitString(p);}
PosFrontAx_t setPosFrontAx(PosFrontAx_t p){return p;}
PosLonCarr_t setPosLonCarr(PosLonCarr_t p){return p;}
PosPillar_t setPosPillar(PosPillar_t p){return p;}
PostCrashSubCauseCode_t setPostCrashSubCauseCode(PostCrashSubCauseCode_t p){return p;}
ProtectedZoneID_t setProtectedZoneID(ProtectedZoneID_t p){return p;}
ProtectedZoneRadius_t setProtectedZoneRadius(ProtectedZoneRadius_t p){return p;}
ProtectedZoneType_t setProtectedZoneType(ProtectedZoneType_t p){return p;}
PtActivationData_t setPtActivationData(PtActivationData_t p){return setOctetString(p);}
PtActivationType_t setPtActivationType(PtActivationType_t p){return p;}
RelevanceDistance_t setRelevanceDistance(RelevanceDistance_t r){return r;}
RelevanceTrafficDirection_t setRelevanceTrafficDirection(RelevanceTrafficDirection_t r){return r;}
RequestResponseIndication_t setRequestResponseIndication(RequestResponseIndication_t r){return r;}
RescueAndRecoveryWorkInProgressSubCauseCode_t setRescueAndRecoveryWorkInProgressSubCauseCode(
        RescueAndRecoveryWorkInProgressSubCauseCode_t r){return r;}
RoadType_t setRoadType(RoadType_t r){return r;}
RoadworksSubCauseCode_t setRoadworksSubCauseCode(RoadworksSubCauseCode_t r){return r;}
SemiAxisLength_t setSemiAxisLength(SemiAxisLength_t s){return s;}
SequenceNumber_t setSequenceNumber(SequenceNumber_t s){return s;}
SignalViolationSubCauseCode_t setSignalViolationSubCauseCode(SignalViolationSubCauseCode_t s){return s;}
SlowVehicleSubCauseCode_t setSlowVehicleSubCauseCode(SlowVehicleSubCauseCode_t s){return s;}
SpecialTransportType_t setSpecialTransportType(SpecialTransportType_t s){return s;}
SpeedConfidence_t setSpeedConfidence(SpeedConfidence_t s){return s;}
SpeedLimit_t setSpeedLimit(SpeedLimit_t s){return s;}
SpeedValue_t setSpeedValue(SpeedValue_t s){return s;}
StationarySince_t setStationarySince(StationarySince_t s){return s;}
StationaryVehicleSubCauseCode_t setStationaryVehicleSubCauseCode(StationaryVehicleSubCauseCode_t s)
{return s;}
StationID_t setStationID(StationID_t s){return s;}
StationType_t setStationType(StationType_t s){return s;}
SteeringWheelAngleConfidence_t setSteeringWheelAngleConfidence(SteeringWheelAngleConfidence_t s)
{return s;}
SteeringWheelAngleValue_t setSteeringWheelangleValue(SteeringWheelAngleValue_t s){return s;}
SubCauseCodeType_t setSubCauseCodeType(SubCauseCodeType_t s){return s;}
TimestampIts_t setTimestampIts(TimestampIts_t t){return setInteger(t);}
Temperature_t setTemperature(Temperature_t t){return t;}
TrafficConditionSubCauseCode_t setTrafficConditionSubCauseCode(TrafficConditionSubCauseCode_t t)
{return t;}
TrafficRule_t setTrafficRule(TrafficRule_t t){return t;}
TransmissionInterval_t setTransmissionInterval(TransmissionInterval_t t){return t;}
TurningRadius_t setTurningRadius(TurningRadius_t t){return t;}
ValidityDuration_t setValidityDuration(ValidityDuration_t v){return v;}
VDS_t setVDS(VDS_t v){return setIA5String(v);}
VehicleBreakdownSubCauseCode_t setVehicleBreakdownSubCauseCode(VehicleBreakdownSubCauseCode_t v)
{return v;}
VehicleLengthConfidenceIndication_t setVehicleLengthConfidenceIndication(
        VehicleLengthConfidenceIndication_t v){return v;}
VehicleLengthValue_t setVehicleLengthValue(VehicleLengthValue_t v){return v;}
VehicleMass_t setVehicleMass(VehicleMass_t v){return v;}
VehicleRole_t setVehicleRole(VehicleRole_t v){return v;}
VehicleWidth_t setVehicleWidth(VehicleWidth_t v){return v;}
VerticalAccelerationValue_t setVerticalAccelerationValue(VerticalAccelerationValue_t v){return v;}
WheelBaseVehicle_t setWheelBaseVehicle(WheelBaseVehicle_t w){return w;}
WMInumber_t setWMInumber(WMInumber_t w){return setIA5String(w);}
WrongWayDrivingSubCauseCode_t setWrongWayDrivingSubCauseCode(WrongWayDrivingSubCauseCode_t w){return w;}
YawRateConfidence_t setYawRateConfidence(YawRateConfidence_t y){return y;}
YawRateValue_t setYawRateValue(YawRateValue_t y){return y;}

/*
 * DF
 */
ActionID_t setActionID(ActionID_t a)
{
    ActionID_t other;

    other.originatingStationID = setStationID(a.originatingStationID);
    other.sequenceNumber = setSequenceNumber(a.sequenceNumber);

    return other;
}

Altitude_t setAltitude(Altitude_t a)
{
    Altitude_t other;

    other.altitudeValue = setAltitudeValue(a.altitudeValue);
    other.altitudeConfidence = setAltitudeConfidence(a.altitudeConfidence);

    return other;
}

CauseCode_t setCauseCode(CauseCode_t c)
{
    CauseCode_t other;

    other.causeCode = setCauseCodeType(c.causeCode);
    other.subCauseCode = setSubCauseCodeType(c.subCauseCode);

    return other;
}

CenDsrcTollingZone_t setCenDsrcTollingZone(CenDsrcTollingZone_t c)
{
    CenDsrcTollingZone_t other;

    other.protectedZoneLatitude = setLatitude(c.protectedZoneLatitude);
    other.protectedZoneLongitude = setLongitude(c.protectedZoneLongitude);
    if(c.cenDsrcTollingZoneID)
    {
        other.cenDsrcTollingZoneID = (CenDsrcTollingZoneID_t*)calloc(1,
                                                                     sizeof *other.cenDsrcTollingZoneID);
        *other.cenDsrcTollingZoneID = setCenDsrcTollingZoneID(*c.cenDsrcTollingZoneID);
    }
    else
        other.cenDsrcTollingZoneID = 0;

    return other;
}

ClosedLanes_t setClosedLanes(ClosedLanes_t c)
{
    ClosedLanes_t other;

    if(c.hardShoulderStatus)
    {
        other.hardShoulderStatus = (HardShoulderStatus_t*)calloc(1, sizeof *other.hardShoulderStatus);
        *other.hardShoulderStatus = setHardShoulderStatus(*c.hardShoulderStatus);
    }
    else
        other.hardShoulderStatus = 0;
    other.drivingLaneStatus = setDrivingLaneStatus(c.drivingLaneStatus);

    return other;
}

Curvature_t setCurvature(Curvature_t c)
{
    Curvature_t other;

    other.curvatureValue = setCurvatureValue(c.curvatureValue);
    other.curvatureConfidence = setCurvatureConfidence(c.curvatureConfidence);

    return other;
}

DangerousGoodsExtended_t setDangerousGoodsExtended(DangerousGoodsExtended_t d)
{
    DangerousGoodsExtended_t other;

    other.dangerousGoodsType = setDangerousGoodsBasic(d.dangerousGoodsType);
    other.unNumber = d.unNumber;
    other.elevatedTemperature = setBoolean(d.elevatedTemperature);
    other.tunnelsRestricted = setBoolean(d.tunnelsRestricted);
    other.limitedQuantity = setBoolean(d.limitedQuantity);
    if(d.emergencyActionCode)
    {
        other.emergencyActionCode = (IA5String_t*)calloc(1, sizeof *other.emergencyActionCode);
        *other.emergencyActionCode = setIA5String(*d.emergencyActionCode);
    }
    else
        other.emergencyActionCode = 0;
    if(d.phoneNumber)
    {
        other.phoneNumber = (IA5String_t*)calloc(1, sizeof *other.phoneNumber);
        *other.phoneNumber = setIA5String(*d.phoneNumber);
    }
    else
        other.phoneNumber = 0;
    if(d.companyName)
    {
        other.companyName = (UTF8String_t*)calloc(1, sizeof *other.companyName);
        *other.companyName = setUTF8String(*d.companyName);
    }
    else
        other.companyName = 0;

    return other;
}

DeltaReferencePosition_t setDeltaReferencePosition(DeltaReferencePosition_t d)
{
    DeltaReferencePosition_t other;

    other.deltaLatitude = setDeltaLatitude(d.deltaLatitude);
    other.deltaLongitude = setDeltaLongitude(d.deltaLongitude);
    other.deltaAltitude = setDeltaAltitude(d.deltaAltitude);

    return other;
}

EventHistory_t setEventHistory(EventHistory_t e)
{
    EventHistory_t other;
    EventPoint_t ep;
    int i;

    if(e.list.count)
    {
        other.list.count = 0;
        other.list.array = (EventPoint_t**)calloc(1, sizeof *other.list.array);
        for(i = 0 ; i < e.list.count ; i++)
        {
            ep = setEventPoint(*e.list.array[i]);
            other.list.array[i] = (EventPoint_t*)calloc(1, sizeof *other.list.array[i]);
            ASN_SEQUENCE_ADD(&other, &ep);
        }
    }
    else
    {
        other.list.array = 0;
        other.list.count = 0;
    }

    return other;
}

EventPoint_t setEventPoint(EventPoint_t e)
{
    EventPoint_t other;

    other.eventPosition = setDeltaReferencePosition(e.eventPosition);
    if(e.eventDeltaTime)
    {
        other.eventDeltaTime = (PathDeltaTime_t*)calloc(1, sizeof *other.eventDeltaTime);
        *other.eventDeltaTime = setPathDeltaTime(*e.eventDeltaTime);
    }
    else
        other.eventDeltaTime = 0;
    other.informationQuality = setInformationQuality(e.informationQuality);

    return other;
}

Heading_t setHeading(Heading_t h)
{
    Heading_t other;

    other.headingValue = setHeadingValue(h.headingValue);
    other.headingConfidence = setHeadingConfidence(h.headingConfidence);

    return other;
}

ItineraryPath_t setItinerarryPath(ItineraryPath_t i)
{
    ItineraryPath_t other;
    ReferencePosition_t rp;
    int j;

    if(i.list.count)
    {
        other.list.count = 0;
        other.list.array = (ReferencePosition_t**)calloc(1, sizeof *other.list.array);
        for(j = 0 ; j < i.list.count ; j++)
        {
            rp = setReferencePosition(*i.list.array[j]);
            other.list.array[j] = (ReferencePosition_t*)calloc(1, sizeof *other.list.array[j]);
            ASN_SEQUENCE_ADD(&other, &rp);
        }
    }
    else
    {
        other.list.array = 0;
        other.list.count = 0;
    }

    return other;
}

ItsPduHeader_t setItsPduHeader(ItsPduHeader_t i)
{
    ItsPduHeader_t other;

    other.protocolVersion = i.protocolVersion;
    other.messageID = i.messageID;
    other.stationID = setStationID(i.stationID);

    return other;
}

LateralAcceleration_t setLateralAcceleration(LateralAcceleration_t l)
{
    LateralAcceleration_t other;

    other.lateralAccelerationValue = setLateralAccelerationValue(l.lateralAccelerationValue);
    other.lateralAccelerationConfidence = setAccelerationConfidence(l.lateralAccelerationConfidence);

    return other;
}

LongitudinalAcceleration_t setLongitudinalAcceleration(LongitudinalAcceleration_t l)
{
    LongitudinalAcceleration_t other;

    other.longitudinalAccelerationValue = setLongitudinalAccelerationValue(
                l.longitudinalAccelerationValue);
    other.longitudinalAccelerationConfidence = setAccelerationConfidence(
                l.longitudinalAccelerationConfidence);

    return other;
}

PathHistory_t setPathHistory(PathHistory_t p)
{
    PathHistory_t other;
    PathPoint_t pp;
    int i;

    if(p.list.count)
    {
        other.list.array = (PathPoint_t**)calloc(1, sizeof *other.list.array);
        other.list.count = 0;
        for(i = 0 ; i < p.list.count ; i++)
        {
            pp = setPathPoint(*p.list.array[i]);
            other.list.array[i] = (PathPoint_t*)calloc(1, sizeof *other.list.array[i]);
            ASN_SEQUENCE_ADD(&other, &pp);
        }
    }
    else
    {
        other.list.array = 0;
        other.list.count = 0;
    }

    return other;
}

PathPoint_t setPathPoint(PathPoint_t p)
{
    PathPoint_t other;

    other.pathPosition = setDeltaReferencePosition(p.pathPosition);
    if(p.pathDeltaTime)
    {
        other.pathDeltaTime = (PathDeltaTime_t*) calloc(1, sizeof *other.pathDeltaTime);
        *other.pathDeltaTime = setPathDeltaTime(*p.pathDeltaTime);
    }
    else
        other.pathDeltaTime = 0;

    return other;
}

PosConfidenceEllipse_t setPosConfidenceEllipse(PosConfidenceEllipse_t p)
{
    PosConfidenceEllipse_t other;

    other.semiMajorConfidence = setSemiAxisLength(p.semiMajorConfidence);
    other.semiMinorConfidence = setSemiAxisLength(p.semiMinorConfidence);
    other.semiMajorOrientation = setHeadingValue(p.semiMajorOrientation);

    return other;
}

PositionOfPillars_t setPositionOfPillars(PositionOfPillars_t p)
{
    PositionOfPillars_t other;
    PosPillar_t *pp = 0;
    int i;

    asn_fprint(NULL, &asn_DEF_PositionOfPillars, &p);
    if(p.list.count)
    {
        other.list.count = 0;
        other.list.array = (PosPillar_t**)calloc(1, sizeof *other.list.array);
        for(i = 0 ; i < p.list.count ; i++)
        {
            pp = (PosPillar_t*)calloc(1, sizeof *pp);
            *pp = setPosPillar(*p.list.array[i]);
            other.list.array[i] = (PosPillar_t*)calloc(1, sizeof *other.list.array[i]);
            ASN_SEQUENCE_ADD(&other, pp);
        }
    }
    else
    {
        other.list.array = 0;
        other.list.count = 0;
    }

    return  other;
}

ProtectedCommunicationZone_t setProtectedCommunicationZone(ProtectedCommunicationZone_t p)
{
    ProtectedCommunicationZone_t other;

    other.protectedZoneType = setProtectedZoneType(p.protectedZoneType);
    if(p.expiryTime)
    {
        other.expiryTime = (TimestampIts_t*)calloc(1, sizeof *other.expiryTime);
        *other.expiryTime = setTimestampIts(*p.expiryTime);
    }
    else
        other.expiryTime = 0;
    other.protectedZoneLatitude = setLatitude(p.protectedZoneLatitude);
    other.protectedZoneLongitude = setLongitude(p.protectedZoneLongitude);
    if(p.protectedZoneRadius)
    {
        other.protectedZoneRadius = (ProtectedZoneRadius_t*)calloc(1, sizeof *other.protectedZoneRadius);
        *other.protectedZoneRadius = setProtectedZoneRadius(*p.protectedZoneRadius);
    }
    else
        other.protectedZoneRadius = 0;
    if(p.protectedZoneID)
    {
        other.protectedZoneID = (ProtectedZoneID_t*)calloc(1, sizeof *p.protectedZoneID);
        *other.protectedZoneID = setProtectedZoneID(*p.protectedZoneID);
    }
    else
        other.protectedZoneID = 0;

    return other;
}

ProtectedCommunicationZonesRSU_t setProtectedCommunicationZoneRSU(ProtectedCommunicationZonesRSU_t p)
{
    ProtectedCommunicationZonesRSU_t other;
    ProtectedCommunicationZone_t pcz;
    int i;

    if(p.list.count)
    {
        other.list.count = 0;
        other.list.array = (ProtectedCommunicationZone_t**)calloc(1, sizeof *other.list.array);
        for(i = 0 ; i < p.list.count ; i++)
        {
            pcz = setProtectedCommunicationZone(*p.list.array[i]);
            other.list.array[i] = (ProtectedCommunicationZone_t*)calloc(1, sizeof *other.list.array[i]);
            ASN_SEQUENCE_ADD(&other, &pcz);
        }
    }
    else
    {
        other.list.array = 0;
        other.list.count = 0;
    }

    return other;
}

PtActivation_t setPtActivation(PtActivation_t p)
{
    PtActivation_t other;

    other.ptActivationType = setPtActivationType(p.ptActivationType);
    other.ptActivationData = setPtActivationData(p.ptActivationData);

    return other;
}

ReferencePosition_t setReferencePosition(ReferencePosition_t r)
{
    ReferencePosition_t other;

    other.latitude = setLatitude(r.latitude);
    other.longitude = setLongitude(r.longitude);
    other.positionConfidenceEllipse = setPosConfidenceEllipse(r.positionConfidenceEllipse);
    other.altitude = setAltitude(r.altitude);

    return other;
}

RestrictedTypes_t setRestrictedTypes(RestrictedTypes_t r)
{
    RestrictedTypes_t other;
    StationType_t st;
    int i;

    if(r.list.count)
    {
        other.list.count = 0;
        other.list.array = (StationType_t**)calloc(1, sizeof *other.list.array);
        for(i = 0 ; i < r.list.count ; i++)
        {
            st = setStationType(*r.list.array[i]);
            other.list.array[i] = (StationType_t*)calloc(1, sizeof *other.list.array[i]);
            ASN_SEQUENCE_ADD(&other, &st);
        }
    }
    else
    {
        other.list.array = 0;
        other.list.count = 0;
    }

    return other;
}

Speed_t setSpeed(Speed_t s)
{
    Speed_t other;

    other.speedValue = setSpeedValue(s.speedValue);
    other.speedConfidence = setSpeedConfidence(s.speedConfidence);

    return other;
}

SteeringWheelAngle_t setSteeringWheelangle(SteeringWheelAngle_t s)
{
    SteeringWheelAngle_t other;

    other.steeringWheelAngleValue = setSteeringWheelangleValue(s.steeringWheelAngleValue);
    other.steeringWheelAngleConfidence = setSteeringWheelangleConfidence(s.steeringWheelAngleConfidence);

    return other;
}

Traces_t setTraces(Traces_t t)
{
    Traces_t other;
    int i;

    if(t.list.count)
    {
        other.list.count = t.list.count;
        other.list.array = (PathHistory_t**)calloc(1, sizeof *other.list.array);
        other.list.free = t.list.free;
        other.list.size = t.list.size;

        for(i = 0 ; i < t.list.count ; i++)
            other.list.array[i] = t.list.array[i];
    }
    else
    {
        other.list.array = 0;
        other.list.count = 0;
        other.list.free = 0;
        other.list.size = 0;
    }

    return other;
}

VerticalAcceleration_t setVerticalAcceleration(VerticalAcceleration_t v)
{
    VerticalAcceleration_t other;

    other.verticalAccelerationValue = setVerticalAccelerationValue(v.verticalAccelerationValue);
    other.verticalAccelerationConfidence = setAccelerationConfidence(v.verticalAccelerationConfidence);

    return other;
}

VehicleIdentification_t setVehicleIdentification(VehicleIdentification_t v)
{
    VehicleIdentification_t other;

    if(v.wMInumber)
    {
        other.wMInumber = (WMInumber_t*)calloc(1, sizeof *v.wMInumber);
        *other.wMInumber = setWMInumber(*v.wMInumber);
    }
    else
        other.wMInumber = 0;
    if(v.vDS)
    {
        other.vDS = (VDS_t*)calloc(1, sizeof *v.vDS);
        *other.vDS = setVDS(*v.vDS);
    }
    else
        other.vDS = 0;

    return other;
}

VehicleLength_t setVehicleLength(VehicleLength_t v)
{
    VehicleLength_t other;

    other.vehicleLengthValue = setVehicleLengthValue(v.vehicleLengthValue);
    other.vehicleLengthConfidenceIndication = setVehicleLengthConfidenceIndication(
                v.vehicleLengthConfidenceIndication);

    return other;
}

YawRate_t setYawRate(YawRate_t y)
{
    YawRate_t other;

    other.yawRateValue = setYawRateValue(y.yawRateValue);
    other.yawRateConfidence = setYawRateConfidence(y.yawRateConfidence);

    return other;
}

/*
 * CAM
 */
/*
 * DE
 */
GenerationDeltaTime_t setGenerationDeltaTime(GenerationDeltaTime_t g){return g;}
/*
 * DF
 */
BasicContainer_t setBasicContainer(BasicContainer_t b)
{
    BasicContainer_t other;

    other.stationType = setStationType(b.stationType);
    other.referencePosition = setReferencePosition(b.referencePosition);

    return other;
}

BasicVehicleContainerHighFrequency_t setBasicVehicleContainerHighFrequency(
        BasicVehicleContainerHighFrequency_t b)
{
    BasicVehicleContainerHighFrequency_t other;

    other.heading = setHeading(b.heading);
    other.speed = setSpeed(b.speed);
    other.driveDirection = setDriveDirection(b.driveDirection);
    other.vehicleLength = setVehicleLength(b.vehicleLength);
    other.vehicleWidth = setVehicleWidth(b.vehicleWidth);
    other.longitudinalAcceleration = setLongitudinalAcceleration(b.longitudinalAcceleration);
    other.curvature = setCurvature(b.curvature);
    other.curvatureCalculationMode = setCurvatureCalculationMode(b.curvatureCalculationMode);
    other.yawRate = setYawRate(b.yawRate);
    if(b.accelerationControl)
    {
        other.accelerationControl = (AccelerationControl_t*)calloc(1, sizeof *other.accelerationControl);
        *other.accelerationControl = setAccelerationControl(*b.accelerationControl);
    }
    else
        other.accelerationControl = 0;
    if(b.lanePosition)
    {
        other.lanePosition = (LanePosition_t*)calloc(1, sizeof *other.lanePosition);
        *other.lanePosition = setLanePosition(*b.lanePosition);
    }
    else
        other.lanePosition = 0;
    if(b.steeringWheelAngle)
    {
        other.steeringWheelAngle = (SteeringWheelAngle_t*)calloc(1, sizeof *other.steeringWheelAngle);
        *other.steeringWheelAngle = setSteeringWheelangle(*b.steeringWheelAngle);
    }
    else
        other.steeringWheelAngle = 0;
    if(b.lateralAcceleration)
    {
        other.lateralAcceleration = (LateralAcceleration_t*)calloc(1, sizeof *other.lateralAcceleration);
        *other.lateralAcceleration = setLateralAcceleration(*b.lateralAcceleration);
    }
    else
        other.lateralAcceleration = 0;
    if(b.verticalAcceleration)
    {
        other.verticalAcceleration = (VerticalAcceleration_t*)calloc(1,
                                                                     sizeof *other.verticalAcceleration);
        *other.verticalAcceleration = setVerticalAcceleration(*b.verticalAcceleration);
    }
    else
        other.verticalAcceleration = 0;
    if(b.performanceClass)
    {
        other.performanceClass = (PerformanceClass_t*)calloc(1, sizeof *other.performanceClass);
        *other.performanceClass = setPerformanceClass(*b.performanceClass);
    }
    else
        other.performanceClass = 0;
    if(b.cenDsrcTollingZone)
    {
        other.cenDsrcTollingZone = (CenDsrcTollingZone_t*)calloc(1, sizeof *other.cenDsrcTollingZone);
        *other.cenDsrcTollingZone = setCenDsrcTollingZone(*b.cenDsrcTollingZone);
    }
    else
        other.cenDsrcTollingZone = 0;

    return other;
}

BasicVehicleContainerLowFrequency_t setBasicVehicleContainerLowFrequency(
        BasicVehicleContainerLowFrequency_t b)
{
    BasicVehicleContainerLowFrequency_t other;

    other.vehicleRole = setVehicleRole(b.vehicleRole);
    other.exteriorLights = setExteriorLights(b.exteriorLights);
    other.pathHistory = setPathHistory(b.pathHistory);

    return other;
}

CAM_t setCAM(CAM_t c)
{
    CAM_t other;

    other.header = setItsPduHeader(c.header);
    other.cam = setCoopAwareness(c.cam);

    return other;
}

CamParameters_t setCamParameters(CamParameters_t c)
{
    CamParameters_t other;

    other.basicContainer = setBasicContainer(c.basicContainer);
    other.highFrequencyContainer = setHighFrequencyContainer(c.highFrequencyContainer);
    if(c.lowFrequencyContainer)
    {
        other.lowFrequencyContainer =
                (LowFrequencyContainer_t*)calloc(1, sizeof *other.lowFrequencyContainer);
        *other.lowFrequencyContainer = setLowFrequencyContainer(*c.lowFrequencyContainer);
    }
    else
        other.lowFrequencyContainer = 0;
    if(c.specialVehicleContainer)
    {
        other.specialVehicleContainer =
                (SpecialVehicleContainer_t*)calloc(1, sizeof *c.specialVehicleContainer);
        *other.specialVehicleContainer = setSpecialVehicleContainer(*c.specialVehicleContainer);
    }
    else
        other.specialVehicleContainer = 0;

    return other;
}

CoopAwareness_t setCoopAwareness(CoopAwareness_t c)
{
    CoopAwareness_t other;

    other.generationDeltaTime = setGenerationDeltaTime(c.generationDeltaTime);
    other.camParameters = setCamParameters(c.camParameters);

    return other;
}

DangerousGoodsContainer_t setDangerousGoodsContainer(DangerousGoodsContainer_t d)
{
    DangerousGoodsContainer_t other;

    other.dangerousGoodsBasic = setDangerousGoodsBasic(d.dangerousGoodsBasic);

    return other;
}

EmergencyContainer_t setEmergencyContainer(EmergencyContainer_t e)
{
    EmergencyContainer_t other;

    other.lightBarSirenInUse = setLightBarSirenInUse(e.lightBarSirenInUse);
    if(e.incidentIndication)
    {
        other.incidentIndication = (CauseCode_t*)calloc(1, sizeof *other.incidentIndication);
        *other.incidentIndication = setCauseCode(*e.incidentIndication);
    }
    else
        other.incidentIndication = 0;
    if(e.emergencyPriority)
    {
        other.emergencyPriority = (EmergencyPriority_t*)calloc(1, sizeof *other.emergencyPriority);
        *other.emergencyPriority = setEmergencyPriority(*e.emergencyPriority);
    }
    else
        other.emergencyPriority = 0;

    return other;
}

HighFrequencyContainer_t setHighFrequencyContainer(HighFrequencyContainer_t h)
{
    HighFrequencyContainer_t other;

    other.present = h.present;
    switch (other.present)
    {
    case HighFrequencyContainer_PR_basicVehicleContainerHighFrequency:
        other.choice.basicVehicleContainerHighFrequency = setBasicVehicleContainerHighFrequency(
                    h.choice.basicVehicleContainerHighFrequency);
        break;
    case HighFrequencyContainer_PR_rsuContainerHighFrequency:
        other.choice.rsuContainerHighFrequency = setRSUContainerHighFrequency(
                    h.choice.rsuContainerHighFrequency);
        break;
    default:
        break;
    }

    return other;
}

LowFrequencyContainer_t setLowFrequencyContainer(LowFrequencyContainer_t l)
{
    LowFrequencyContainer_t other;

    other.present = l.present;
    switch (other.present)
    {
    case LowFrequencyContainer_PR_basicVehicleContainerLowFrequency:
        other.choice.basicVehicleContainerLowFrequency = setBasicVehicleContainerLowFrequency(
                    l.choice.basicVehicleContainerLowFrequency);
        break;
    default:
        break;
    }

    return other;
}

PublicTransportContainer_t setPublicTransportContainer(PublicTransportContainer_t p)
{
    PublicTransportContainer_t other;

    other.embarkationStatus = setEmbarkationStatus(p.embarkationStatus);
    if(p.ptActivation)
    {
        other.ptActivation = (PtActivation_t*)calloc(1, sizeof *other.ptActivation);
        *other.ptActivation = setPtActivation(*p.ptActivation);
    }
    else
        other.ptActivation = 0;

    return other;
}

RescueContainer_t setRescueContainer(RescueContainer_t r)
{
    RescueContainer_t other;

    other.lightBarSirenInUse = setLightBarSirenInUse(r.lightBarSirenInUse);

    return other;
}

RoadWorksContainerBasic_t setRoadWorksContainerBasic(RoadWorksContainerBasic_t r)
{
    RoadWorksContainerBasic_t other;

    if(r.roadworksSubCauseCode)
    {
        other.roadworksSubCauseCode =
                (RoadworksSubCauseCode_t*)calloc(1, sizeof other.roadworksSubCauseCode);
        *other.roadworksSubCauseCode = setRoadworksSubCauseCode(*r.roadworksSubCauseCode);
    }
    else
        other.roadworksSubCauseCode = 0;
    other.lightBarSirenInUse = setLightBarSirenInUse(r.lightBarSirenInUse);
    if(r.closedLanes)
    {
        other.closedLanes = (ClosedLanes_t*)calloc(1, sizeof *other.closedLanes);
        *other.closedLanes = setClosedLanes(*r.closedLanes);
    }
    else
        other.closedLanes = 0;

    return other;
}

RSUContainerHighFrequency_t setRSUContainerHighFrequency(RSUContainerHighFrequency_t r)
{
    RSUContainerHighFrequency_t other;

    if(r.protectedCommunicationZonesRSU)
    {
        other.protectedCommunicationZonesRSU =
                (ProtectedCommunicationZonesRSU_t*)calloc(1,
                                                          sizeof *other.protectedCommunicationZonesRSU);
        *other.protectedCommunicationZonesRSU =
                setProtectedCommunicationZoneRSU(*r.protectedCommunicationZonesRSU);
    }
    else
        other.protectedCommunicationZonesRSU = 0;

    return other;
}

SafetyCarContainer_t setSafetyCarContainer(SafetyCarContainer_t s)
{
    SafetyCarContainer_t other;

    other.lightBarSirenInUse = setLightBarSirenInUse(s.lightBarSirenInUse);
    if(s.incidentIndication)
    {
        other.incidentIndication = (CauseCode_t*)calloc(1, sizeof *s.incidentIndication);
        *other.incidentIndication = setCauseCode(*s.incidentIndication);
    }
    else
        other.incidentIndication = 0;
    if(s.trafficRule)
    {
        other.trafficRule = (TrafficRule_t*)calloc(1, sizeof *other.trafficRule);
        *other.trafficRule = setTrafficRule(*s.trafficRule);
    }
    else
        other.trafficRule = 0;
    if(s.speedLimit)
    {
        other.speedLimit = (SpeedLimit_t*)calloc(1, sizeof *other.speedLimit);
        *other.speedLimit = setSpeedLimit(*s.speedLimit);
    }
    else
        other.speedLimit = 0;

    return other;
}

SpecialTransportContainer_t setSpecialTransportContainer(SpecialTransportContainer_t s)
{
    SpecialTransportContainer_t other;

    other.specialTransportType = setSpecialTransportType(s.specialTransportType);
    other.lightBarSirenInUse = setLightBarSirenInUse(s.lightBarSirenInUse);

    return other;
}

SpecialVehicleContainer_t setSpecialVehicleContainer(SpecialVehicleContainer_t s)
{
    SpecialVehicleContainer_t other;

    other.present = s.present;
    switch (other.present)
    {
    case SpecialVehicleContainer_PR_publicTransportContainer:
        other.choice.publicTransportContainer =
                setPublicTransportContainer(s.choice.publicTransportContainer);
        break;
    case SpecialVehicleContainer_PR_specialTransportContainer:
        other.choice.specialTransportContainer =
                setSpecialTransportContainer(s.choice.specialTransportContainer);
        break;
    case SpecialVehicleContainer_PR_dangerousGoodsContainer:
        other.choice.dangerousGoodsContainer =
                setDangerousGoodsContainer(s.choice.dangerousGoodsContainer);
        break;
    case SpecialVehicleContainer_PR_roadWorksContainerBasic:
        other.choice.roadWorksContainerBasic =
                setRoadWorksContainerBasic(s.choice.roadWorksContainerBasic);
        break;
    case SpecialVehicleContainer_PR_rescueContainer:
        other.choice.rescueContainer = setRescueContainer(s.choice.rescueContainer);
        break;
    case SpecialVehicleContainer_PR_emergencyContainer:
        other.choice.emergencyContainer = setEmergencyContainer(s.choice.emergencyContainer);
        break;
    case SpecialVehicleContainer_PR_safetyCarContainer:
        other.choice.safetyCarContainer = setSafetyCarContainer(s.choice.safetyCarContainer);
        break;
    default:
        break;
    }

    return other;
}

/*
 * DENM
 */
/*
 * DE
 */
Termination_t setTermination(Termination_t t){return t;}

/*
 * DF
 */
AlacarteContainer_t setAlacarteContainer(AlacarteContainer_t a)
{
    AlacarteContainer_t other;

    memset(&other, 0, sizeof other);

    if(a.lanePosition)
    {
        other.lanePosition = (LanePosition_t*)calloc(1, sizeof *other.lanePosition);
        *other.lanePosition = setLanePosition(*a.lanePosition);
    }
    else
        other.lanePosition = 0;
    if(a.impactReduction)
    {
        other.impactReduction = (ImpactReductionContainer_t*)calloc(1, sizeof *other.impactReduction);
        *other.impactReduction = setImpactReductionContainer(*a.impactReduction);
    }
    else
        other.impactReduction = 0;
    if(a.externalTemperature)
    {
        other.externalTemperature = (Temperature_t*)calloc(1, sizeof *other.externalTemperature);
        *other.externalTemperature = setTemperature(*a.externalTemperature);
    }
    else
        other.externalTemperature = 0;
    if(a.roadWorks)
    {
        other.roadWorks = (RoadWorksContainerExtended_t*)calloc(1, sizeof *other.roadWorks);
        *other.roadWorks = setRoadWorksContainerExtended(*a.roadWorks);
    }
    else
        other.roadWorks = 0;
    if(a.positioningSolution)
    {
        other.positioningSolution =
                (PositioningSolutionType_t*)calloc(1, sizeof *other.positioningSolution);
        *other.positioningSolution = setPositioningSolutionType(*a.positioningSolution);
    }
    else
        other.positioningSolution = 0;
    if(a.stationaryVehicle)
    {
        other.stationaryVehicle = (StationaryVehicleContainer_t*)calloc(1,
                                                                        sizeof *other.stationaryVehicle);
        *other.stationaryVehicle = setStationaryVehicleContainer(*a.stationaryVehicle);
    }
    else
        other.stationaryVehicle = 0;

    return other;
}

DecentralizedEnvironmentalNotificationMessage_t setDecentralizedEnvironmentalNotificationMessage(
        DecentralizedEnvironmentalNotificationMessage_t d)
{
    DecentralizedEnvironmentalNotificationMessage_t other;

    other.management = setManagementContainer(d.management);
    if(d.situation)
    {
        other.situation = (SituationContainer_t*)calloc(1, sizeof *other.situation);
        *other.situation = setSituationContainer(*d.situation);
    }
    else
        other.situation = 0;
    if(d.location)
    {
        other.location = (LocationContainer_t*)calloc(1, sizeof *other.location);
        *other.location = setLocationContainer(*d.location);
    }
    else
        other.location = 0;
    if(d.alacarte)
    {
        other.alacarte = (AlacarteContainer_t*)calloc(1, sizeof *other.alacarte);
        *other.alacarte = setAlacarteContainer(*d.alacarte);
    }
    else
        other.alacarte = 0;

    return other;
}

DENM_t setDENM(DENM_t d)
{
    DENM_t other;

    other.header = setItsPduHeader(d.header);
    other.denm = setDecentralizedEnvironmentalNotificationMessage(d.denm);

    return other;
}

ImpactReductionContainer_t setImpactReductionContainer(ImpactReductionContainer_t i)
{
    ImpactReductionContainer_t other;

    other.heightLonCarrLeft = setHeightLonCarr(i.heightLonCarrLeft);
    other.heightLonCarrRight = setHeightLonCarr(i.heightLonCarrRight);
    other.posLonCarrLeft = setPosLonCarr(i.posLonCarrLeft);
    other.posLonCarrRight = setPosLonCarr(i.posLonCarrRight);
    other.positionOfPillars = setPositionOfPillars(i.positionOfPillars);
    other.posCentMass = setPosCentMass(i.posCentMass);
    other.wheelBaseVehicle = setWheelBaseVehicle(i.wheelBaseVehicle);
    other.turningRadius = setTurningRadius(i.turningRadius);
    other.posFrontAx = setPosFrontAx(i.posFrontAx);
    other.positionOfOccupants = setPositionOfOccupants(i.positionOfOccupants);
    other.vehicleMass = setVehicleMass(i.vehicleMass);
    other.requestResponseIndication = setRequestResponseIndication(i.requestResponseIndication);

    return other;
}

LocationContainer_t setLocationContainer(LocationContainer_t l)
{
    LocationContainer_t other;

    if(l.eventSpeed)
    {
        other.eventSpeed = (Speed_t*)calloc(1, sizeof *other.eventSpeed);
        *other.eventSpeed = setSpeed(*l.eventSpeed);
    }
    else
        other.eventSpeed = 0;
    if(l.eventPositionHeading)
    {
        other.eventPositionHeading = (Heading_t*)calloc(1, sizeof *other.eventPositionHeading);
        *other.eventPositionHeading = setHeading(*l.eventPositionHeading);
    }
    else
        other.eventPositionHeading = 0;
    other.traces = setTraces(l.traces);
    if(l.roadType)
    {
        other.roadType = (RoadType_t*)calloc(1, sizeof *other.roadType);
        *other.roadType = setRoadType(*l.roadType);
    }
    else
        other.roadType = 0;

    return other;
}

ManagementContainer_t setManagementContainer(ManagementContainer_t m)
{
    ManagementContainer_t other;

    other.actionID = setActionID(m.actionID);
    other.detectionTime = setTimestampIts(m.detectionTime);
    other.referenceTime = setTimestampIts(m.referenceTime);
    if(m.termination)
    {
        other.termination = (Termination_t*)calloc(1, sizeof *other.termination);
        *other.termination = setTermination(*m.termination);
    }
    else
        other.termination = 0;
    other.eventPosition = setReferencePosition(m.eventPosition);
    if(m.relevanceDistance)
    {
        other.relevanceDistance = (RelevanceDistance_t*)calloc(1, sizeof *other.relevanceDistance);
        *other.relevanceDistance = setRelevanceDistance(*m.relevanceDistance);
    }
    else
        other.relevanceDistance = 0;
    if(m.relevanceTrafficDirection)
    {
        other.relevanceTrafficDirection =
                (RelevanceTrafficDirection_t*)calloc(1, sizeof *other.relevanceTrafficDirection);
        *other.relevanceTrafficDirection = setRelevanceTrafficDirection(*m.relevanceTrafficDirection);
    }
    else
        other.relevanceTrafficDirection = 0;
    if(m.validityDuration)
    {
        other.validityDuration = (ValidityDuration_t*)calloc(1, sizeof *other.validityDuration);
        *other.validityDuration = setValidityDuration(*m.validityDuration);
    }
    else
        other.validityDuration = 0;
    if(m.transmissionInterval)
    {
        other.transmissionInterval = (TransmissionInterval_t*)calloc(1,
                                                                     sizeof *other.transmissionInterval);
        *other.transmissionInterval = setTransmissionInterval(*m.transmissionInterval);
    }
    else
        other.transmissionInterval = 0;
    other.stationType = setStationType(m.stationType);

    return other;
}

ReferenceDenms_t setReferenceDenms(ReferenceDenms_t r)
{
    ReferenceDenms_t other;
    ActionID_t aid;
    int i;

    if(r.list.count)
    {
        other.list.count = 0;
        other.list.array = (ActionID_t**)calloc(1, sizeof *other.list.array);
        for(i = 0 ; i < r.list.count ; i++)
        {
            aid = setActionID(*r.list.array[i]);
            other.list.array[i] = (ActionID_t*)calloc(1, sizeof *other.list.array[i]);
            ASN_SEQUENCE_ADD(&other, &aid);
        }
    }
    else
    {
        other.list.array = 0;
        other.list.count = 0;
    }

    return other;
}

RoadWorksContainerExtended_t setRoadWorksContainerExtended(RoadWorksContainerExtended_t r)
{
    RoadWorksContainerExtended_t other;

    if(r.lightBarSirenInUse)
    {
        other.lightBarSirenInUse = (LightBarSirenInUse_t*)calloc(1, sizeof *other.lightBarSirenInUse);
        *other.lightBarSirenInUse = setLightBarSirenInUse(*r.lightBarSirenInUse);
    }
    else
        other.lightBarSirenInUse = 0;
    if(r.closedLanes)
    {
        other.closedLanes = (ClosedLanes_t*)calloc(1, sizeof *other.closedLanes);
        *other.closedLanes = setClosedLanes(*r.closedLanes);
    }
    else
        other.closedLanes = 0;
    if(r.restriction)
    {
        other.restriction = (RestrictedTypes_t*)calloc(1, sizeof *other.restriction);
        *other.restriction = setRestrictedTypes(*r.restriction);
    }
    else
        other.restriction = 0;
    if(r.speedLimit)
    {
        other.speedLimit = (SpeedLimit_t*)calloc(1, sizeof *other.speedLimit);
        *other.speedLimit = setSpeedLimit(*r.speedLimit);
    }
    else
        other.speedLimit = 0;
    if(r.incidentIndication)
    {
        other.incidentIndication = (CauseCode_t*)calloc(1, sizeof *other.incidentIndication);
        *other.incidentIndication = setCauseCode(*r.incidentIndication);
    }
    else
        other.incidentIndication = 0;
    if(r.recommendedPath)
    {
        other.recommendedPath = (ItineraryPath_t*)calloc(1, sizeof *other.recommendedPath);
        *other.recommendedPath = setItinerarryPath(*r.recommendedPath);
    }
    else
        other.recommendedPath = 0;
    if(r.startingPointSpeedLimit)
    {
        other.startingPointSpeedLimit =
                (DeltaReferencePosition_t*)calloc(1, sizeof *other.startingPointSpeedLimit);
        *other.startingPointSpeedLimit = setDeltaReferencePosition(*r.startingPointSpeedLimit);
    }
    else
        other.startingPointSpeedLimit = 0;
    if(r.trafficFlowRule)
    {
        other.trafficFlowRule = (TrafficRule_t*)calloc(1, sizeof *other.trafficFlowRule);
        *other.trafficFlowRule = setTrafficRule(*r.trafficFlowRule);
    }
    else
        other.trafficFlowRule = 0;
    if(r.referenceDenms)
    {
        other.referenceDenms = (ReferenceDenms_t*)calloc(1, sizeof *other.referenceDenms);
        *other.referenceDenms = setReferenceDenms(*r.referenceDenms);
    }
    else
        other.referenceDenms = 0;

    return other;
}

SituationContainer_t setSituationContainer(SituationContainer_t s)
{
    SituationContainer_t other;

    other.informationQuality = setInformationQuality(s.informationQuality);
    other.eventType = setCauseCode(s.eventType);
    if(s.linkedCause)
    {
        other.linkedCause = (CauseCode_t*)calloc(1, sizeof *other.linkedCause);
        *other.linkedCause = setCauseCode(*s.linkedCause);
    }
    else
        other.linkedCause = 0;
    if(s.eventHistory)
    {
        other.eventHistory = (EventHistory_t*)calloc(1, sizeof *other.eventHistory);
        *other.eventHistory = setEventHistory(*s.eventHistory);
    }
    else
        other.eventHistory = 0;

    return other;
}

StationaryVehicleContainer_t setStationaryVehicleContainer(StationaryVehicleContainer_t s)
{
    StationaryVehicleContainer_t other;

    if(s.stationarySince)
    {
        other.stationarySince = (StationarySince_t*)calloc(1, sizeof *other.stationarySince);
        *other.stationarySince = setStationarySince(*s.stationarySince);
    }
    else
        other.stationarySince = 0;
    if(s.stationaryCause)
    {
        other.stationaryCause = (CauseCode_t*)calloc(1, sizeof *other.stationaryCause);
        *other.stationaryCause = setCauseCode(*s.stationaryCause);
    }
    else
        other.stationaryCause = 0;
    if(s.carryingDangerousGoods)
    {
        other.carryingDangerousGoods =
                (DangerousGoodsExtended_t*)calloc(1, sizeof *other.carryingDangerousGoods);
        *other.carryingDangerousGoods = setDangerousGoodsExtended(*s.carryingDangerousGoods);
    }
    else
        other.carryingDangerousGoods = 0;
    if(s.numberOfOccupants)
    {
        other.numberOfOccupants = (NumberOfOccupants_t*)calloc(1, sizeof *other.numberOfOccupants);
        *other.numberOfOccupants = setNumberOfOccupants(*s.numberOfOccupants);
    }
    else
        other.numberOfOccupants = 0;
    if(s.vehicleIdentification)
    {
        other.vehicleIdentification =
                (VehicleIdentification_t*)calloc(1, sizeof *other.vehicleIdentification);
        *other.vehicleIdentification = setVehicleIdentification(*s.vehicleIdentification);
    }
    else
        other.vehicleIdentification = 0;
    if(s.energyStorageType)
    {
        other.energyStorageType = (EnergyStorageType_t*)calloc(1, sizeof *other.energyStorageType);
        *other.energyStorageType = setEnergyStorageType(*s.energyStorageType);
    }
    else
        other.energyStorageType = 0;

    return other;
}