apiDENM.cpp

Go to the documentation of this file.

#include <apiDENM.h>

/*******************************
 * Constraints
 ******************************/
/* DE */
void constr_Termination(Termination_t *t){constr_int(t, 0, 1);}

/* DF */
void constr_AlacarteContainer(AlacarteContainer_t *a)
{
    if(a->lanePosition)
        constr_LanePosition(a->lanePosition);
    if(a->impactReduction)
        constr_ImpactReductionContainer(a->impactReduction);
    if(a->externalTemperature)
        constr_Temperature(a->externalTemperature);
    if(a->roadWorks)
        constr_RoadWorksContainerExtended(a->roadWorks);
    if(a->positioningSolution)
        constr_PositioningSolutionType(a->positioningSolution);
    if(a->stationaryVehicle)
        constr_StationaryVehicleContainer(a->stationaryVehicle);
}

void constr_DecentralizedEnvironmentalNotificationMessage(DecentralizedEnvironmentalNotificationMessage_t *d)
{
    constr_ManagementContainer(&d->management);
    if(d->situation)
        constr_SituationContainer(d->situation);
    if(d->location)
        constr_LocationContainer(d->location);
    if(d->alacarte)
        constr_AlacarteContainer(d->alacarte);
}

void constr_DENM(DENM_t d)
{
    constr_ItsPduHeader(&d.header);
    constr_DecentralizedEnvironmentalNotificationMessage(&d.denm);
}

void constr_ImpactReductionContainer(ImpactReductionContainer_t *i)
{
    constr_HeightLonCarr(&i->heightLonCarrLeft);
    constr_HeightLonCarr(&i->heightLonCarrRight);
    constr_PosLonCarr(&i->posLonCarrLeft);
    constr_PosLonCarr(&i->posLonCarrRight);
    constr_PositionOfPillars(&i->positionOfPillars);
    constr_PosCentMass(&i->posCentMass);
    constr_WheelBaseVehicle(&i->wheelBaseVehicle);
    constr_TurningRadius(&i->turningRadius);
    constr_PosFrontAx(&i->posFrontAx);
    constr_PositionOfOccupants(&i->positionOfOccupants);
    constr_VehicleMass(&i->vehicleMass);
    constr_RequestResponseIndication(&i->requestResponseIndication);
}

void constr_LocationContainer(LocationContainer_t *l)
{
    if(l->eventSpeed)
        constr_Speed(l->eventSpeed);
    if(l->eventPositionHeading)
        constr_Heading(l->eventPositionHeading);
    constr_Traces(&l->traces);
    if(l->roadType)
        constr_RoadType(l->roadType);
}

void constr_ManagementContainer(ManagementContainer_t *m)
{
    constr_ActionID(&m->actionID);
    constr_TimestampIts(&m->detectionTime);
    constr_TimestampIts(&m->referenceTime);
    if(m->termination)
        constr_Termination(m->termination);
    constr_ReferencePosition(&m->eventPosition);
    if(m->relevanceDistance)
        constr_RelevanceDistance(m->relevanceDistance);
    if(m->relevanceTrafficDirection)
        constr_RelevanceTrafficDirection(m->relevanceTrafficDirection);
    if(m->validityDuration)
        constr_ValidityDuration(m->validityDuration);
    if(m->transmissionInterval)
        constr_TransmissionInterval(m->transmissionInterval);
    constr_StationType(&m->stationType);
}

void constr_ReferenceDenms(ReferenceDenms_t *r)
{
    if(r->list.count > 8)
        for(int i = r->list.count ; i > 8 ; i--)
            asn_sequence_del(r, i, 0);
    else if(r->list.count < 1)
        *r = make_ReferenceDenms(make_StationID());
    else
        for(int i = 0 ; i < r->list.count ; i++)
            constr_ActionID(r->list.array[i]);
}

void constr_RoadWorksContainerExtended(RoadWorksContainerExtended_t *r)
{
    if(r->lightBarSirenInUse)
        constr_LightBarSirenInUse(r->lightBarSirenInUse);
    if(r->closedLanes)
        constr_ClosedLanes(r->closedLanes);
    if(r->restriction)
        constr_RestrictedTypes(r->restriction);
    if(r->speedLimit)
        constr_SpeedLimit(r->speedLimit);
    if(r->incidentIndication)
        constr_CauseCode(r->incidentIndication);
    if(r->recommendedPath)
        constr_ItineraryPath(r->recommendedPath);
    if(r->startingPointSpeedLimit)
        constr_DeltaReferencePosition(r->startingPointSpeedLimit);
    if(r->trafficFlowRule)
        constr_TrafficRule(r->trafficFlowRule);
    if(r->referenceDenms)
        constr_ReferenceDenms(r->referenceDenms);
}

void constr_SituationContainer(SituationContainer_t *s)
{
    constr_InformationQuality(&s->informationQuality);
    constr_CauseCode(&s->eventType);
    if(s->linkedCause)
        constr_CauseCode(s->linkedCause);
    if(s->eventHistory)
        constr_EventHistory(s->eventHistory);
}

void constr_StationaryVehicleContainer(StationaryVehicleContainer_t *s)
{
    if(s->stationarySince)
        constr_StationarySince(s->stationarySince);
    if(s->stationaryCause)
        constr_CauseCode(s->stationaryCause);
    if(s->carryingDangerousGoods)
        constr_DangerousGoodsExtended(s->carryingDangerousGoods);
    if(s->numberOfOccupants)
        constr_NumberOfOccupants(s->numberOfOccupants);
    if(s->vehicleIdentification)
        constr_VehicleIdentification(s->vehicleIdentification);
    if(s->energyStorageType)
        constr_EnergyStorageType(s->energyStorageType);
}

/****************************
 * Copy
 ***************************/
/* DE */
Termination_t cpy_Termination(Termination_t t){return t;}

/* DF */
AlacarteContainer_t cpy_AlacarteContainer(AlacarteContainer_t a)
{
    AlacarteContainer_t a1;

    memset(&a1, 0, sizeof a1);
    if(a.lanePosition)
    {
        a1.lanePosition = (LanePosition_t*)calloc(1, sizeof *a1.lanePosition);
        *a1.lanePosition = cpy_LanePosition(*a.lanePosition);
    }
    if(a.impactReduction)
    {
        a1.impactReduction = (ImpactReductionContainer_t*)calloc(1, sizeof *a1.impactReduction);
        *a1.impactReduction = cpy_ImpactReductionContainer(*a.impactReduction);
    }
    if(a.externalTemperature)
    {
        a1.externalTemperature = (Temperature_t*)calloc(1, sizeof *a1.externalTemperature);
        *a1.externalTemperature = cpy_Temperature(*a.externalTemperature);
    }
    if(a.roadWorks)
    {
        a1.roadWorks = (RoadWorksContainerExtended_t*)calloc(1, sizeof *a1.roadWorks);
        *a1.roadWorks = cpy_RoadWorksContainerExtended(*a.roadWorks);
    }
    if(a.positioningSolution)
    {
        a1.positioningSolution = (PositioningSolutionType_t*)calloc(1,
                                                                    sizeof *a1.positioningSolution);
        *a1.positioningSolution = cpy_PositioningSolutionType(*a.positioningSolution);
    }
    if(a.stationaryVehicle)
    {
        a1.stationaryVehicle = (StationaryVehicleContainer_t*)calloc(1,
                                                                     sizeof *a1.stationaryVehicle);
        *a1.stationaryVehicle = cpy_StationaryVehicleContainer(*a.stationaryVehicle);
    }

    return a1;
}

DecentralizedEnvironmentalNotificationMessage_t
cpy_DecentralizedEnvironmentalNotificationMessage(
        DecentralizedEnvironmentalNotificationMessage_t d)
{
    DecentralizedEnvironmentalNotificationMessage_t d1;

    memset(&d1, 0, sizeof d1);
    d1.management = cpy_ManagementContainer(d.management);
    if(d.situation)
    {
        d1.situation = (SituationContainer_t*)calloc(1, sizeof *d1.situation);
        *d1.situation = cpy_SituationContainer(*d.situation);
    }
    if(d.location)
    {
        d1.location = (LocationContainer_t*)calloc(1, sizeof *d1.location);
        *d1.location = cpy_LocationContainer(*d.location);
    }
    if(d.alacarte)
    {
        d1.alacarte = (AlacarteContainer_t*)calloc(1, sizeof *d1.alacarte);
        *d1.alacarte = cpy_AlacarteContainer(*d.alacarte);
    }

    return d1;
}

DENM_t cpy_DENM(DENM_t d)
{
    DENM_t d1;

    memset(&d1, 0, sizeof d1);
    d1.header = cpy_ItsPduHeader(d.header);
    d1.denm = cpy_DecentralizedEnvironmentalNotificationMessage(d.denm);

    return d1;
}

ImpactReductionContainer_t cpy_ImpactReductionContainer(
        ImpactReductionContainer_t i)
{
    ImpactReductionContainer_t i1;

    memset(&i1, 0, sizeof i1);
    i1.heightLonCarrLeft = cpy_HeightLonCarr(i.heightLonCarrLeft);
    i1.heightLonCarrRight = cpy_HeightLonCarr(i.heightLonCarrRight);
    i1.posLonCarrLeft = cpy_PosLonCarr(i.posLonCarrLeft);
    i1.posLonCarrRight = cpy_PosLonCarr(i.posLonCarrRight);
    i1.positionOfPillars = cpy_PositionOfPillars(i.positionOfPillars);
    i1.wheelBaseVehicle = cpy_WheelBaseVehicle(i.wheelBaseVehicle);
    i1.turningRadius = cpy_TurningRadius(i.turningRadius);
    i1.posFrontAx = cpy_PosFrontAx(i.posFrontAx);
    i1.positionOfOccupants = cpy_PositionOfOccupants(i.positionOfOccupants);
    i1.vehicleMass = cpy_VehicleMass(i.vehicleMass);
    i1.requestResponseIndication = cpy_RequestResponseIndication(i.requestResponseIndication);

    return i1;
}

LocationContainer_t cpy_LocationContainer(LocationContainer_t l)
{
    LocationContainer_t l1;

    memset(&l1, 0, sizeof l1);
    if(l.eventSpeed)
    {
        l1.eventSpeed = (Speed_t*)calloc(1, sizeof l1.eventSpeed);
        *l1.eventSpeed = cpy_Speed(*l.eventSpeed);
    }
    if(l.eventPositionHeading)
    {
        l1.eventPositionHeading = (Heading_t*)calloc(1, sizeof *l1.eventPositionHeading);
        *l1.eventPositionHeading = cpy_Heading(*l.eventPositionHeading);
    }
    l1.traces = cpy_Traces(l.traces);
    if(l.roadType)
    {
        l1.roadType = (RoadType_t*)calloc(1, sizeof *l1.roadType);
        *l1.roadType = cpy_RoadType(*l.roadType);
    }

    return l1;
}

ManagementContainer_t cpy_ManagementContainer(ManagementContainer_t m)
{
    ManagementContainer_t m1;

    memset(&m1, 0, sizeof m1);
    m1.actionID = cpy_ActionID(m.actionID);
    m1.detectionTime = cpy_TimestampIts(m.detectionTime);
    m1.referenceTime = cpy_TimestampIts(m.referenceTime);
    if(m.termination)
    {
        m1.termination = (Termination_t*)calloc(1, sizeof *m1.termination);
        *m1.termination = cpy_Termination(*m.termination);
    }
    m1.eventPosition = cpy_ReferencePosition(m.eventPosition);
    if(m.relevanceDistance)
    {
        m1.relevanceDistance = (RelevanceDistance_t*)calloc(1, sizeof *m.relevanceDistance);
        *m1.relevanceDistance = cpy_RelevanceDistance(*m.relevanceDistance);
    }
    if(m.relevanceTrafficDirection)
    {
        m1.relevanceTrafficDirection = (RelevanceTrafficDirection_t*)calloc(1,
                                                                   sizeof *m1.relevanceTrafficDirection);
        *m1.relevanceTrafficDirection = cpy_RelevanceTrafficDirection(*m.relevanceTrafficDirection);
    }
    if(m.validityDuration)
    {
        m1.validityDuration = (ValidityDuration_t*)calloc(1, sizeof *m1.validityDuration);
        *m1.validityDuration = cpy_ValidityDuration(*m.validityDuration);
    }
    if(m.transmissionInterval)
    {
        m1.transmissionInterval = (TransmissionInterval_t*)calloc(1, sizeof *m1.transmissionInterval);
        *m1.transmissionInterval = cpy_TransmissionInterval(*m.transmissionInterval);
    }
    m1.stationType = cpy_StationType(m.stationType);

    return m1;
}

ReferenceDenms_t cpy_ReferenceDenms(ReferenceDenms_t r)
{
    ReferenceDenms_t r1;
    ActionID_t a;
    int i;

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

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

    return r1;
}

RoadWorksContainerExtended_t cpy_RoadWorksContainerExtended(
        RoadWorksContainerExtended_t r)
{
    RoadWorksContainerExtended_t r1;

    memset(&r1, 0, sizeof r1);
    if(r.lightBarSirenInUse)
    {
        r1.lightBarSirenInUse = (LightBarSirenInUse_t*)calloc(1, sizeof *r1.lightBarSirenInUse);
        *r1.lightBarSirenInUse = cpy_LightBarSirenInUse(*r.lightBarSirenInUse);
    }
    if(r.closedLanes)
    {
        r1.closedLanes = (ClosedLanes_t*)calloc(1, sizeof *r1.closedLanes);
        *r1.closedLanes = cpy_ClosedLanes(*r.closedLanes);
    }
    if(r.restriction)
    {
        r1.restriction = (RestrictedTypes_t*)calloc(1, sizeof *r1.restriction);
        *r1.restriction = cpy_RestrictedTypes(*r.restriction);
    }
    if(r.speedLimit)
    {
        r1.speedLimit = (SpeedLimit_t*)calloc(1, sizeof *r1.speedLimit);
        *r1.speedLimit = cpy_SpeedLimit(*r.speedLimit);
    }
    if(r.incidentIndication)
    {
        r1.incidentIndication = (CauseCode_t*)calloc(1, sizeof *r1.incidentIndication);
        *r1.incidentIndication = cpy_CauseCode(*r.incidentIndication);
    }
    if(r.recommendedPath)
    {
        r1.recommendedPath = (ItineraryPath_t*)calloc(1, sizeof *r1.recommendedPath);
        *r1.recommendedPath = cpy_ItineraryPath(*r.recommendedPath);
    }
    if(r.startingPointSpeedLimit)
    {
        r1.startingPointSpeedLimit = (DeltaReferencePosition_t*)calloc(1,
                                                                     sizeof *r1.startingPointSpeedLimit);
        *r1.startingPointSpeedLimit = cpy_DeltaReferencePosition(*r.startingPointSpeedLimit);
    }
    if(r.trafficFlowRule)
    {
        r1.trafficFlowRule = (TrafficRule_t*)calloc(1, sizeof *r1.trafficFlowRule);
        *r1.trafficFlowRule = cpy_TrafficRule(*r.trafficFlowRule);
    }
    if(r.referenceDenms)
    {
        r1.referenceDenms = (ReferenceDenms_t*)calloc(1, sizeof *r1.referenceDenms);
        *r1.referenceDenms = cpy_ReferenceDenms(*r.referenceDenms);
    }

    return r1;
}

SituationContainer_t cpy_SituationContainer(SituationContainer_t s)
{
    SituationContainer_t s1;

    memset(&s1, 0, sizeof s1);
    s1.informationQuality = cpy_InformationQuality(s.informationQuality);
    s1.eventType = cpy_CauseCode(s.eventType);
    if(s.linkedCause)
    {
        s1.linkedCause = (CauseCode_t*)calloc(1, sizeof *s1.linkedCause);
        *s1.linkedCause = cpy_CauseCode(*s.linkedCause);
    }
    if(s.eventHistory)
    {
        s1.eventHistory = (EventHistory_t*)calloc(1, sizeof *s1.eventHistory);
        *s1.eventHistory = cpy_EventHistory(*s.eventHistory);
    }

    return s1;
}

StationaryVehicleContainer_t cpy_StationaryVehicleContainer(
        StationaryVehicleContainer_t s)
{
    StationaryVehicleContainer_t s1;

    memset(&s1, 0, sizeof s1);
    if(s1.stationarySince)
    {
        s1.stationarySince = (StationarySince_t*)calloc(1, sizeof *s1.stationarySince);
        *s1.stationarySince = cpy_StationarySince(*s.stationarySince);
    }
    if(s.stationaryCause)
    {
        s1.stationaryCause = (CauseCode_t*)calloc(1, sizeof *s1.stationaryCause);
        *s1.stationaryCause = cpy_CauseCode(*s.stationaryCause);
    }
    if(s.carryingDangerousGoods)
    {
        s1.carryingDangerousGoods = (DangerousGoodsExtended_t*)calloc(1,
                                                                      sizeof *s1.carryingDangerousGoods);
        *s1.carryingDangerousGoods = cpy_DangerousGoodsExtended(*s.carryingDangerousGoods);
    }
    if(s.numberOfOccupants)
    {
        s1.numberOfOccupants = (NumberOfOccupants_t*)calloc(1, sizeof *s1.numberOfOccupants);
        *s1.numberOfOccupants = cpy_NumberOfOccupants(*s.numberOfOccupants);
    }
    if(s.vehicleIdentification)
    {
        s1.vehicleIdentification = (VehicleIdentification_t*)calloc(1, sizeof *s1.vehicleIdentification);
        *s1.vehicleIdentification = cpy_VehicleIdentification(*s.vehicleIdentification);
    }
    if(s.energyStorageType)
    {
        s1.energyStorageType = (EnergyStorageType_t*)calloc(1, sizeof *s1.energyStorageType);
        *s1.energyStorageType = cpy_EnergyStorageType(*s.energyStorageType);
    }

    return s1;
}

/****************************
 * Equals
 ***************************/
/* DE */
bool isEqual_Termination(Termination_t a, Termination_t b){return a == b;}

/* DF */
bool isEqual_AlacarteContainer(AlacarteContainer_t a, AlacarteContainer_t b)
{
    if((!a.lanePosition && b.lanePosition) ||
       (a.lanePosition && !b.lanePosition ) ||
       (!a.impactReduction && b.impactReduction) ||
       (a.impactReduction && !b.impactReduction) ||
       (!a.externalTemperature && b.externalTemperature) ||
       (a.externalTemperature && !b.externalTemperature) ||
       (!a.roadWorks && b.roadWorks) ||
       (a.roadWorks && !b.roadWorks) ||
       (!a.positioningSolution && b.positioningSolution) ||
       (a.positioningSolution && !b.positioningSolution) ||
       (!a.stationaryVehicle && b.stationaryVehicle) ||
       (a.stationaryVehicle && !b.stationaryVehicle))
        return false;

    if(a.lanePosition)
        if(!isEqual_LanePosition(*a.lanePosition, *b.lanePosition))
            return false;
    if(a.impactReduction)
        if(!isEqual_ImpactReductionContainer(*a.impactReduction, *b.impactReduction))
            return false;
    if(a.externalTemperature)
        if(!isEqual_Temperature(*a.externalTemperature, *b.externalTemperature))
            return false;
    if(a.roadWorks)
        if(!isEqual_RoadWorksContainerExtended(*a.roadWorks, *b.roadWorks))
            return false;
    if(a.positioningSolution)
        if(!isEqual_PositioningSolutionType(*a.positioningSolution, *b.positioningSolution))
            return false;
    if(a.stationaryVehicle)
        if(!isEqual_StationaryVehicleContainer(*a.stationaryVehicle, *b.stationaryVehicle))
            return false;

    return true;
}

bool isEqual_DecentralizedEnvironmentalNotificationMessage(
        DecentralizedEnvironmentalNotificationMessage_t a,
        DecentralizedEnvironmentalNotificationMessage_t b)

{
    if((!a.situation && b.situation) ||
       (a.situation && !b.situation) ||
       ((!a.location && b.location) ||
       (a.location && !b.location)) ||
       ((!a.alacarte && b.alacarte) ||
       (a.alacarte && !b.alacarte)))
        return false;

    if(a.situation)
        if(!isEqual_SituationContainer(*a.situation, *b.situation))
            return false;
    if(a.location)
        if(!isEqual_LocationContainer(*a.location, *b.location))
            return false;
    if(a.alacarte)
        if(!isEqual_AlacarteContainer(*a.alacarte, *b.alacarte))
            return false;

    return isEqual_ManagementContainer(a.management, b.management);

}

bool isEqual_DENM(DENM_t a, DENM_t b)
{
    if(isEqual_ItsPduHeader(a.header, b.header))
        return isEqual_DecentralizedEnvironmentalNotificationMessage(a.denm, b.denm);

    return false;
}

bool isEqual_ImpactReductionContainer(ImpactReductionContainer_t a,
                                                        ImpactReductionContainer_t b)
{
    return isEqual_HeightLonCarr(a.heightLonCarrLeft, b.heightLonCarrLeft) &&
            isEqual_HeightLonCarr(a.heightLonCarrRight, b.heightLonCarrRight) &&
            isEqual_PosLonCarr(a.posLonCarrLeft, b.posLonCarrLeft) &&
            isEqual_PosLonCarr(a.posLonCarrRight, b.posLonCarrRight) &&
            isEqual_PositionOfPillars(a.positionOfPillars, b.positionOfPillars) &&
            isEqual_PosCentMass(a.posCentMass, b.posCentMass) &&
            isEqual_WheelBaseVehicle(a.wheelBaseVehicle, b.wheelBaseVehicle) &&
            isEqual_TurningRadius(a.turningRadius, b.turningRadius) &&
            isEqual_PosFrontAx(a.posFrontAx, b.posFrontAx) &&
            isEqual_PositionOfOccupants(a.positionOfOccupants, b.positionOfOccupants) &&
            isEqual_VehicleMass(a.vehicleMass, b.vehicleMass) &&
            isEqual_RequestResponseIndication(a.requestResponseIndication,
                                            b.requestResponseIndication);
}

bool isEqual_LocationContainer(LocationContainer_t a, LocationContainer_t b)
{
    if((!a.eventSpeed && b.eventSpeed) ||
       (a.eventSpeed && !b.eventSpeed) ||
       (!a.eventPositionHeading && b.eventPositionHeading) ||
       (a.eventPositionHeading && b.eventPositionHeading) ||
       (!a.roadType && b.roadType) ||
       (a.roadType && !b.roadType))
        return false;
    if(a.eventSpeed)
        if(!isEqual_Speed(*a.eventSpeed, *b.eventSpeed))
            return false;
    if(a.eventPositionHeading)
        if(!isEqual_Heading(*a.eventPositionHeading, *b.eventPositionHeading))
            return false;
    if(a.roadType)
        if(!isEqual_RoadType(*a.roadType, *b.roadType))
            return false;
    return isEqual_Traces(a.traces, b.traces);
}

bool isEqual_ManagementContainer(ManagementContainer_t a, ManagementContainer_t b)
{
    if((!a.termination && b.termination) ||
       (a.termination && !b.termination) ||
       (!a.relevanceDistance && b.relevanceDistance) ||
       (a.relevanceDistance && !b.relevanceDistance) ||
       (!a.relevanceTrafficDirection && b.relevanceTrafficDirection) ||
       (a.relevanceTrafficDirection && !b.relevanceTrafficDirection) ||
       (!a.validityDuration && b.validityDuration) ||
       (a.validityDuration && !b.validityDuration) ||
       (!a.transmissionInterval && b.transmissionInterval) ||
       (a.transmissionInterval && !b.transmissionInterval))
        return false;
    if(a.termination)
        if(!isEqual_Termination(*a.termination, *b.termination))
            return false;
    if(a.relevanceDistance)
        if(!isEqual_RelevanceDistance(*a.relevanceDistance, *b.relevanceDistance))
            return false;
    if(a.relevanceTrafficDirection)
        if(!isEqual_RelevanceTrafficDirection(*a.relevanceTrafficDirection,
                                            *b.relevanceTrafficDirection))
            return false;
    if(a.validityDuration)
        if(!isEqual_ValidityDuration(*a.validityDuration, *b.validityDuration))
            return false;
    if(a.transmissionInterval)
        if(!isEqual_TransmissionInterval(*a.transmissionInterval, *b.transmissionInterval))
            return false;
    return isEqual_ActionID(a.actionID, b.actionID) &&
            isEqual_TimestampIts(a.detectionTime, b.detectionTime) &&
            isEqual_TimestampIts(a.referenceTime, b.referenceTime) &&
            isEqual_ReferencePosition(a.eventPosition, b.eventPosition) &&
            isEqual_StationType(a.stationType, b.stationType);
}

bool isEqual_ReferenceDenms(ReferenceDenms_t a, ReferenceDenms_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_ActionID(*a.list.array[i], *b.list.array[i]) ; i++);

    return i == a.list.count;
}

bool isEqual_RoadWorksContainerExtended(RoadWorksContainerExtended_t a,
                                                          RoadWorksContainerExtended_t b)
{
    if((!a.lightBarSirenInUse && b.lightBarSirenInUse) ||
       (a.lightBarSirenInUse && !b.lightBarSirenInUse) ||
       (!a.closedLanes && b.closedLanes) ||
       (a.closedLanes && !b.closedLanes) ||
       (!a.restriction && b.restriction) ||
       (a.restriction && !b.restriction) ||
       (!a.speedLimit && b.speedLimit) ||
       (a.speedLimit && !b.speedLimit) ||
       (!a.incidentIndication && b.incidentIndication) ||
       (a.incidentIndication && !b.incidentIndication) ||
       (!a.recommendedPath && b.recommendedPath) ||
       (a.recommendedPath && !b.recommendedPath) ||
       (!a.startingPointSpeedLimit && b.startingPointSpeedLimit) ||
       (a.startingPointSpeedLimit && !b.startingPointSpeedLimit) ||
       (!a.trafficFlowRule && b.trafficFlowRule) ||
       (a.trafficFlowRule && !b.trafficFlowRule) ||
       (!a.referenceDenms && b.referenceDenms) ||
       (a.referenceDenms && !b.referenceDenms))
        return false;
    if(a.lightBarSirenInUse)
        if(!isEqual_LightBarSirenInUse(*a.lightBarSirenInUse, *b.lightBarSirenInUse))
            return false;
    if(a.closedLanes)
        if(!isEqual_ClosedLanes(*a.closedLanes, *b.closedLanes))
            return false;
    if(a.restriction)
        if(!isEqual_RestrictedTypes(*a.restriction, *b.restriction))
            return false;
    if(a.speedLimit)
        if(!isEqual_SpeedLimit(*a.speedLimit, *b.speedLimit))
            return false;
    if(a.incidentIndication)
        if(!isEqual_CauseCode(*a.incidentIndication, *b.incidentIndication))
            return false;
    if(a.recommendedPath)
        if(!isEqual_ItineraryPath(*a.recommendedPath, *b.recommendedPath))
            return false;
    if(a.startingPointSpeedLimit)
        if(!isEqual_DeltaReferencePosition(*a.startingPointSpeedLimit, *b.startingPointSpeedLimit))
            return false;
    if(a.trafficFlowRule)
        if(!isEqual_TrafficRule(*a.trafficFlowRule, *b.trafficFlowRule))
            return false;
    if(a.referenceDenms)
        if(!isEqual_ReferenceDenms(*a.referenceDenms, *b.referenceDenms))
            return false;
    return true;
}

bool isEqual_SituationContainer(SituationContainer_t a, SituationContainer_t b)
{
    if((!a.linkedCause && b.linkedCause) ||
       (a.linkedCause && !b.linkedCause) ||
       (!a.eventHistory && b.eventHistory) ||
       (a.eventHistory && !b.eventHistory))
        return false;
    if(a.linkedCause)
        if(!isEqual_CauseCode(*a.linkedCause, *b.linkedCause))
            return false;
    if(a.eventHistory)
        if(!isEqual_EventHistory(*a.eventHistory, *b.eventHistory))
            return false;
    return isEqual_InformationQuality(a.informationQuality, b.informationQuality) &&
            isEqual_CauseCode(a.eventType, b.eventType);
}

bool isEqual_StationaryVehicleContainer(StationaryVehicleContainer_t a,
                                                          StationaryVehicleContainer_t b)
{
    if((!a.stationarySince && b.stationarySince) ||
       (a.stationarySince && !b.stationarySince) ||
       (!a.stationaryCause && b.stationaryCause) ||
       (a.stationaryCause && !b.stationaryCause) ||
       (!a.carryingDangerousGoods && b.carryingDangerousGoods) ||
       (a.carryingDangerousGoods && !b.carryingDangerousGoods) ||
       (!a.numberOfOccupants && b.numberOfOccupants) ||
       (a.numberOfOccupants && !b.numberOfOccupants) ||
       (!a.vehicleIdentification && b.vehicleIdentification) ||
       (a.vehicleIdentification && !b.vehicleIdentification) ||
       (!a.energyStorageType && b.energyStorageType) ||
       (a.energyStorageType && !b.energyStorageType))
        return false;
    if(a.stationarySince)
        if(!isEqual_StationarySince(*a.stationarySince, *b.stationarySince))
            return false;
    if(a.stationaryCause)
        if(!isEqual_CauseCode(*a.stationaryCause, *b.stationaryCause))
            return false;
    if(a.carryingDangerousGoods)
        if(!isEqual_DangerousGoodsExtended(*a.carryingDangerousGoods, *b.carryingDangerousGoods))
            return false;
    if(a.numberOfOccupants)
        if(!isEqual_NumberOfOccupants(*a.numberOfOccupants, *b.numberOfOccupants))
            return false;
    if(a.vehicleIdentification)
        if(!isEqual_VehicleIdentification(*a.vehicleIdentification, *b.vehicleIdentification))
            return false;
    if(a.energyStorageType)
        if(!isEqual_EnergyStorageType(*a.energyStorageType, *b.energyStorageType))
            return false;
    return true;
}

/****************************
 * Maker
 ***************************/
/* DE */
Termination_t make_Termination()
{
    Termination_t t = Termination_isCancellation;

    return t;
}

/* DF */
AlacarteContainer_t make_AlacarteContainer()
{
    AlacarteContainer_t a;

    memset(&a, 0, sizeof a);
    a.lanePosition = 0;
    a.impactReduction = 0;
    a.externalTemperature = 0;
    a.roadWorks = 0;
    a.positioningSolution = 0;
    a.stationaryVehicle = 0;

    return a;
}

DecentralizedEnvironmentalNotificationMessage_t
make_DecentralizedEnvironmentalNotificationMessage(StationID_t s)
{
    DecentralizedEnvironmentalNotificationMessage_t d;

    memset(&d, 0, sizeof d);
    d.management = make_ManagementContainer(s);
    d.situation = 0;
    d.location = 0;
    d.alacarte = 0;

    return d;
}

DENM_t make_DENM()
{
    DENM_t d;

    memset(&d, 0, sizeof d);
    d.header = make_ItsPduHeader(messageID_denm);
    d.denm = make_DecentralizedEnvironmentalNotificationMessage(d.header.stationID);

    return d;
}

ImpactReductionContainer_t make_ImpactReductionContainer()
{
    ImpactReductionContainer_t i;

    memset(&i, 0, sizeof i);
    i.heightLonCarrLeft = make_HeightLonCarr();
    i.heightLonCarrRight = make_HeightLonCarr();
    i.posLonCarrLeft = make_PosLonCarr();
    i.posLonCarrRight = make_PosLonCarr();
    i.positionOfPillars = make_PositionOfPillars();
    i.posCentMass = make_PosCentMass();
    i.wheelBaseVehicle = make_WheelBaseVehicle();
    i.turningRadius = make_TurningRadius();
    i.posFrontAx = make_PosFrontAx();
    i.positionOfOccupants = make_PositionOfOccupants();
    i.vehicleMass = make_VehicleMass();
    i.requestResponseIndication = make_RequestResponseIndication();

    return i;
}

LocationContainer_t make_LocationContainer()
{
    LocationContainer_t l;

    memset(&l, 0, sizeof l);
    l.eventSpeed = 0;
    l.eventPositionHeading = 0;
    l.traces = make_Traces();
    l.roadType = 0;

    return l;
}

ManagementContainer_t make_ManagementContainer(StationID_t s)
{
    ManagementContainer_t m;
    long int l;

    memset(&m, 0, sizeof m);
    m.actionID = make_ActionID(s);
    m.detectionTime = make_TimestampIts();
    asn_INTEGER2long((INTEGER_t*)&m.detectionTime, &l);
    asn_long2INTEGER((INTEGER_t*)&m.referenceTime, l + 5);
    m.termination = 0;
    m.eventPosition = make_ReferencePosition();
    m.relevanceDistance = 0;
    m.relevanceTrafficDirection = 0;
    m.validityDuration = 0;
    m.transmissionInterval = 0;
    m.stationType = make_StationType();

    return m;
}

ReferenceDenms_t make_ReferenceDenms(StationID_t s)
{
    ReferenceDenms_t r;
    ActionID_t a = make_ActionID(s);

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

    return r;
}

RoadWorksContainerExtended_t make_RoadWorksContainerExtended()
{
    RoadWorksContainerExtended_t r;

    memset(&r, 0, sizeof r);
    r.lightBarSirenInUse = 0;
    r.closedLanes = 0;
    r.restriction = 0;
    r.speedLimit = 0;
    r.incidentIndication = 0;
    r.recommendedPath = 0;
    r.startingPointSpeedLimit = 0;
    r.trafficFlowRule = 0;
    r.referenceDenms = 0;

    return r;
}

SituationContainer_t make_SituationContainer()
{
    SituationContainer_t s;

    memset(&s, 0, sizeof s);
    s.informationQuality = make_InformationQuality();
    s.eventType = make_CauseCode();
    s.linkedCause = 0;
    s.eventHistory = 0;

    return s;
}

StationaryVehicleContainer_t make_StationaryVehicleContainer()
{
    StationaryVehicleContainer_t s;

    memset(&s, 0, sizeof s);
    s.stationarySince = 0;
    s.stationaryCause = 0;
    s.carryingDangerousGoods = 0;
    s.numberOfOccupants = 0;
    s.vehicleIdentification = 0;
    s.energyStorageType = 0;

    return s;
}