apiCAM.cpp

Go to the documentation of this file.

#include <apiCAM.h>

/*******************************
 * +++aints
 ******************************/
/* DE */
void constr_GenerationDeltaTime(GenerationDeltaTime_t *g){constr_int(g, 0, 65535);}

/* DF */
void constr_BasicContainer(BasicContainer_t *b)
{
    constr_StationType(&b->stationType);
    constr_ReferencePosition(&b->referencePosition);
}

void constr_BasicVehicleContainerHighFrequency(BasicVehicleContainerHighFrequency_t *b)
{
    constr_Heading(&b->heading);
    constr_Speed(&b->speed);
    constr_DriveDirection(&b->driveDirection);
    constr_VehicleLength(&b->vehicleLength);
    constr_VehicleWidth(&b->vehicleWidth);
    constr_LongitudinalAcceleration(&b->longitudinalAcceleration);
    constr_Curvature(&b->curvature);
    constr_CurvatureCalculationMode(&b->curvatureCalculationMode);
    constr_YawRate(&b->yawRate);
    if(b->accelerationControl)
        constr_AccelerationControl(b->accelerationControl);
    if(b->lanePosition)
        constr_LanePosition(b->lanePosition);
    if(b->steeringWheelAngle)
        constr_SteeringWheelAngle(b->steeringWheelAngle);
    if(b->lateralAcceleration)
        constr_LateralAcceleration(b->lateralAcceleration);
    if(b->verticalAcceleration)
        constr_VerticalAcceleration(b->verticalAcceleration);
    if(b->cenDsrcTollingZone)
        constr_CenDsrcTollingZone(b->cenDsrcTollingZone);
}

void constr_BasicVehicleContainerLowFrequency(BasicVehicleContainerLowFrequency_t *b)
{
    constr_VehicleRole(&b->vehicleRole);
    constr_ExteriorLights(&b->exteriorLights);
    constr_PathHistory(&b->pathHistory);
}

void constr_CAM(CAM_t *c)
{
    constr_ItsPduHeader(&c->header);
    constr_CoopAwareness(&c->cam);
}

void constr_CamParameters(CamParameters_t *c)
{
    constr_BasicContainer(&c->basicContainer);
    constr_HighFrequencyContainer(&c->highFrequencyContainer);
    if(c->lowFrequencyContainer)
        constr_LowFrequencyContainer(c->lowFrequencyContainer);
    if(c->specialVehicleContainer)
        constr_SpecialVehicleContainer(c->specialVehicleContainer);
}

void constr_CoopAwareness(CoopAwareness_t *c)
{
    constr_GenerationDeltaTime(&c->generationDeltaTime);
    constr_CamParameters(&c->camParameters);
}

void constr_DangerousGoodsContainer(DangerousGoodsContainer_t *d)
{
    constr_DangerousGoodsBasic(&d->dangerousGoodsBasic);
}

void constr_EmergencyContainer(EmergencyContainer_t *e)
{
    constr_LightBarSirenInUse(&e->lightBarSirenInUse);
    if(e->incidentIndication)
        constr_CauseCode(e->incidentIndication);
    if(e->emergencyPriority)
        constr_EmergencyPriority(e->emergencyPriority);
}

void constr_HighFrequencyContainer(HighFrequencyContainer_t *h)
{
    switch (h->present)
    {
    case HighFrequencyContainer_PR_basicVehicleContainerHighFrequency:
        constr_BasicVehicleContainerHighFrequency(&h->choice.basicVehicleContainerHighFrequency);
        break;
    case HighFrequencyContainer_PR_rsuContainerHighFrequency:
        constr_RSUContainerHighFrequency(&h->choice.rsuContainerHighFrequency);
        break;
    default:
        *h = make_HighFrequencyContainer(HighFrequencyContainer_PR_NOTHING);
        break;
    }
}

void constr_LowFrequencyContainer(LowFrequencyContainer_t *l)
{
    switch (l->present)
    {
    case LowFrequencyContainer_PR_basicVehicleContainerLowFrequency:
        constr_BasicVehicleContainerLowFrequency(&l->choice.basicVehicleContainerLowFrequency);
        break;
    default:
        *l = make_LowFrequencyContainer(LowFrequencyContainer_PR_NOTHING);
        break;
    }
}

void constr_PublicTransportContainer(PublicTransportContainer_t *p)
{
    constr_EmbarkationStatus(&p->embarkationStatus);
    if(p->ptActivation)
        constr_PtActivation(p->ptActivation);
}

void constr_RescueContainer(RescueContainer_t *r)
{
    constr_LightBarSirenInUse(&r->lightBarSirenInUse);
}

void constr_RoadWorksContainerBasic(RoadWorksContainerBasic_t *r)
{
    if(r->roadworksSubCauseCode)
        constr_SubCauseCodeType(r->roadworksSubCauseCode);
    constr_LightBarSirenInUse(&r->lightBarSirenInUse);
    if(r->closedLanes)
        constr_ClosedLanes(r->closedLanes);
}

void constr_RSUContainerHighFrequency(RSUContainerHighFrequency_t *r)
{
    if(r->protectedCommunicationZonesRSU)
        constr_ProtectedCommunicationZoneRSU(r->protectedCommunicationZonesRSU);
}

void constr_SafetyCarContainer(SafetyCarContainer_t *s)
{
    constr_LightBarSirenInUse(&s->lightBarSirenInUse);
    if(s->incidentIndication)
        constr_CauseCode(s->incidentIndication);
    if(s->trafficRule)
        constr_TrafficRule(s->trafficRule);
    if(s->speedLimit)
        constr_SpeedLimit(s->speedLimit);
}

void constr_SpecialTransportContainer(SpecialTransportContainer_t *s)
{
    constr_SpecialTransportType(&s->specialTransportType);
    constr_LightBarSirenInUse(&s->lightBarSirenInUse);
}

void constr_SpecialVehicleContainer(SpecialVehicleContainer_t *s)
{
    switch (s->present)
    {
    case SpecialVehicleContainer_PR_publicTransportContainer:
        constr_PublicTransportContainer(&s->choice.publicTransportContainer);
        break;
    case SpecialVehicleContainer_PR_specialTransportContainer:
        constr_SpecialTransportContainer(&s->choice.specialTransportContainer);
        break;
    case SpecialVehicleContainer_PR_dangerousGoodsContainer:
        constr_DangerousGoodsContainer(&s->choice.dangerousGoodsContainer);
        break;
    case SpecialVehicleContainer_PR_roadWorksContainerBasic:
        constr_RoadWorksContainerBasic(&s->choice.roadWorksContainerBasic);
        break;
    case SpecialVehicleContainer_PR_rescueContainer:
        constr_RescueContainer(&s->choice.rescueContainer);
        break;
    case SpecialVehicleContainer_PR_emergencyContainer:
        constr_EmergencyContainer(&s->choice.emergencyContainer);
        break;
    case SpecialVehicleContainer_PR_safetyCarContainer:
        constr_SafetyCarContainer(&s->choice.safetyCarContainer);
        break;
    default:
        *s = make_SpecialVehicleContainer(SpecialVehicleContainer_PR_NOTHING);
        break;
    }
}

/****************************
 * Copy
 ***************************/
/* DE */
GenerationDeltaTime_t cpy_GenerationDeltaTime(GenerationDeltaTime_t g)
{return g;}

/* DF */
BasicContainer_t cpy_BasicContainer(BasicContainer_t b)
{
    BasicContainer_t b1;

    memset(&b1, 0, sizeof b1);
    b1.stationType = cpy_StationType(b.stationType);
    b1.referencePosition = cpy_ReferencePosition(b.referencePosition);

    return b1;
}

BasicVehicleContainerHighFrequency_t cpy_BasicVehicleContainerHighFrequency(
        BasicVehicleContainerHighFrequency_t b)
{
    BasicVehicleContainerHighFrequency_t b1;

    memset(&b1, 0, sizeof b1);
    b1.heading = cpy_Heading(b.heading);
    b1.speed = cpy_Speed(b.speed);
    b1.driveDirection = cpy_DriveDirection(b.driveDirection);
    b1.vehicleLength = cpy_VehicleLength(b.vehicleLength);
    b1.vehicleWidth = cpy_VehicleWidth(b.vehicleWidth);
    b1.longitudinalAcceleration = cpy_LongitudinalAcceleration(b.longitudinalAcceleration);
    b1.curvature = cpy_Curvature(b.curvature);
    b1.curvatureCalculationMode = cpy_CurvatureCalculationMode(b.curvatureCalculationMode);
    b1.yawRate = cpy_YawRate(b.yawRate);
    if(b.accelerationControl)
    {
        b1.accelerationControl = (AccelerationControl_t*)calloc(1, sizeof *b1.accelerationControl);
        *b1.accelerationControl = cpy_AccelerationControl(*b.accelerationControl);
    }
    if(b.lanePosition)
    {
        b1.lanePosition = (LanePosition_t*)calloc(1, sizeof *b1.lanePosition);
        *b1.lanePosition = cpy_LanePosition(*b.lanePosition);
    }
    if(b.steeringWheelAngle)
    {
        b1.steeringWheelAngle = (SteeringWheelAngle_t*)calloc(1, sizeof *b1.steeringWheelAngle);
        *b1.steeringWheelAngle = cpy_SteeringWheelAngle(*b.steeringWheelAngle);
    }
    if(b.lateralAcceleration)
    {
        b1.lateralAcceleration = (LateralAcceleration_t*)calloc(1, sizeof *b1.lateralAcceleration);
        *b1.lateralAcceleration = cpy_LateralAcceleration(*b.lateralAcceleration);
    }
    if(b.verticalAcceleration)
    {
        b1.verticalAcceleration = (VerticalAcceleration_t*)calloc(1,
                                                                  sizeof *b1.verticalAcceleration);
        *b1.verticalAcceleration = cpy_VerticalAcceleration(*b.verticalAcceleration);
    }
    if(b.performanceClass)
    {
        b1.performanceClass = (PerformanceClass_t*)calloc(1, sizeof *b1.performanceClass);
        *b1.performanceClass = cpy_PerformanceClass(*b.performanceClass);
    }
    if(b.cenDsrcTollingZone)
    {
        b1.cenDsrcTollingZone = (CenDsrcTollingZone_t*)calloc(1, sizeof *b1.cenDsrcTollingZone);
        *b1.cenDsrcTollingZone = cpy_CenDsrcTollingZone(*b.cenDsrcTollingZone);
    }

    return b1;
}

BasicVehicleContainerLowFrequency_t cpy_BasicVehicleContainerLowFrequency(
        BasicVehicleContainerLowFrequency_t b)
{
    BasicVehicleContainerLowFrequency_t b1;

    memset(&b1, 0, sizeof b1);
    b1.vehicleRole = cpy_VehicleRole(b.vehicleRole);
    b1.exteriorLights = cpy_ExteriorLights(b.exteriorLights);
    b1.pathHistory = cpy_PathHistory(b.pathHistory);

    return b1;
}

CAM_t cpy_CAM(CAM_t c)
{
    CAM_t c1;

    memset(&c1, 0, sizeof c1);
    c1.header = cpy_ItsPduHeader(c.header);
    c1.cam = cpy_CoopAwareness(c.cam);

    return c1;
}

CamParameters_t cpy_CamParameters(CamParameters_t c)
{
    CamParameters_t c1;

    memset(&c1, 0, sizeof c1);
    c1.basicContainer = cpy_BasicContainer(c.basicContainer);
    c1.highFrequencyContainer = cpy_HighFrequencyContainer(c.highFrequencyContainer);
    if(c.lowFrequencyContainer)
    {
        c1.lowFrequencyContainer = (LowFrequencyContainer_t*)calloc(1, sizeof *c1.lowFrequencyContainer);
        *c1.lowFrequencyContainer = cpy_LowFrequencyContainer(*c.lowFrequencyContainer);
    }
    if(c.specialVehicleContainer)
    {
        c1.specialVehicleContainer = (SpecialVehicleContainer_t*)calloc(1, sizeof *c1.specialVehicleContainer);
        *c1.specialVehicleContainer = cpy_SpecialVehicleContainer(*c.specialVehicleContainer);
    }

    return c1;
}

CoopAwareness_t cpy_CoopAwareness(CoopAwareness_t c)
{
    CoopAwareness_t c1;

    memset(&c1, 0, sizeof c1);
    c1.generationDeltaTime = cpy_GenerationDeltaTime(c.generationDeltaTime);
    c1.camParameters = cpy_CamParameters(c.camParameters);

    return c1;
}

DangerousGoodsContainer_t cpy_DangerousGoodsContainer(
        DangerousGoodsContainer_t d)
{
    DangerousGoodsContainer_t d1;

    memset(&d1, 0, sizeof d1);
    d1.dangerousGoodsBasic = cpy_DangerousGoodsBasic(d.dangerousGoodsBasic);

    return d1;
}

EmergencyContainer_t cpy_EmergencyContainer(EmergencyContainer_t e)
{
    EmergencyContainer_t e1;

    memset(&e1, 0, sizeof e1);
    e1.lightBarSirenInUse = cpy_LightBarSirenInUse(e.lightBarSirenInUse);
    if(e.incidentIndication)
    {
        e1.incidentIndication = (CauseCode_t*)calloc(1, sizeof *e1.incidentIndication);
        *e1.incidentIndication = cpy_CauseCode(*e.incidentIndication);
    }
    if(e.emergencyPriority)
    {
        e1.emergencyPriority = (EmergencyPriority_t*)calloc(1, sizeof *e1.emergencyPriority);
        *e1.emergencyPriority = cpy_EmergencyPriority(*e.emergencyPriority);
    }

    return e1;
}

HighFrequencyContainer_t cpy_HighFrequencyContainer(HighFrequencyContainer_t h)
{
    HighFrequencyContainer_t h1;

    memset(&h1, 0, sizeof h1);
    h1.present = h.present;

    switch (h1.present) {
    case HighFrequencyContainer_PR_basicVehicleContainerHighFrequency:
        h1.choice.basicVehicleContainerHighFrequency = cpy_BasicVehicleContainerHighFrequency(
                    h.choice.basicVehicleContainerHighFrequency);
        break;
    case HighFrequencyContainer_PR_rsuContainerHighFrequency:
        h1.choice.rsuContainerHighFrequency = cpy_RSUContainerHighFrequency(
                    h.choice.rsuContainerHighFrequency);
        break;
    default:
        break;
    }

    return h1;
}

LowFrequencyContainer_t cpy_LowFrequencyContainer(LowFrequencyContainer_t l)
{
    LowFrequencyContainer_t l1;

    memset(&l1, 0, sizeof l1);
    l1.present = l.present;

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

    return l1;
}

PublicTransportContainer_t cpy_PublicTransportContainer(
        PublicTransportContainer_t p)
{
    PublicTransportContainer_t p1;

    memset(&p1, 0, sizeof p1);
    p1.embarkationStatus = cpy_EmbarkationStatus(p.embarkationStatus);
    if(p.ptActivation)
    {
        p1.ptActivation = (PtActivation_t*)calloc(1, sizeof *p1.ptActivation);
        *p1.ptActivation = cpy_PtActivation(*p.ptActivation);
    }

    return p1;
}

RescueContainer_t cpy_RescueContainer(RescueContainer_t r)
{
    RescueContainer_t r1;

    memset(&r1, 0, sizeof r1);
    r1.lightBarSirenInUse = cpy_LightBarSirenInUse(r.lightBarSirenInUse);

    return r1;
}

RoadWorksContainerBasic_t cpy_RoadWorksContainerBasic(
        RoadWorksContainerBasic_t r)
{
    RoadWorksContainerBasic_t r1;

    memset(&r1, 0, sizeof r1);
    if(r.roadworksSubCauseCode)
    {
        r1.roadworksSubCauseCode = (SubCauseCodeType_t*)calloc(1, sizeof r1.roadworksSubCauseCode);
        *r1.roadworksSubCauseCode = cpy_SubCauseCodeType(*r.roadworksSubCauseCode);
    }
    r1.lightBarSirenInUse = cpy_LightBarSirenInUse(r.lightBarSirenInUse);
    if(r.closedLanes)
    {
        r1.closedLanes = (ClosedLanes_t*)calloc(1, sizeof *r1.closedLanes);
        *r1.closedLanes = cpy_ClosedLanes(*r.closedLanes);
    }

    return r1;
}

RSUContainerHighFrequency_t cpy_RSUContainerHighFrequency(
        RSUContainerHighFrequency_t r)
{
    RSUContainerHighFrequency_t r1;

    memset(&r1, 0, sizeof r1);
    if(r.protectedCommunicationZonesRSU)
    {
        r1.protectedCommunicationZonesRSU = (ProtectedCommunicationZonesRSU_t*)calloc(1,
                                                         sizeof *r1.protectedCommunicationZonesRSU);
        *r1.protectedCommunicationZonesRSU = cpy_ProtectedCommunicationZoneRSU(
                    *r.protectedCommunicationZonesRSU);
    }

    return r1;
}

SafetyCarContainer_t cpy_SafetyCarContainer(SafetyCarContainer_t s)
{
    SafetyCarContainer_t s1;

    memset(&s1, 0, sizeof s1);
    s1.lightBarSirenInUse = cpy_LightBarSirenInUse(s.lightBarSirenInUse);
    if(s.incidentIndication)
    {
        s1.incidentIndication = (CauseCode_t*)calloc(1, sizeof *s1.incidentIndication);
        *s1.incidentIndication = cpy_CauseCode(*s.incidentIndication);
    }
    if(s.trafficRule)
    {
        s1.trafficRule = (TrafficRule_t*)calloc(1, sizeof *s1.trafficRule);
        *s1.trafficRule = cpy_TrafficRule(*s.trafficRule);
    }
    if(s.speedLimit)
    {
        s1.speedLimit = (SpeedLimit_t*)calloc(1, sizeof *s1.speedLimit);
        *s1.speedLimit = cpy_SpeedLimit(*s.speedLimit);
    }

    return s1;
}

SpecialVehicleContainer_t cpy_SpecialVehicleContainer(
        SpecialVehicleContainer_t s)
{
    SpecialVehicleContainer_t s1;

    memset(&s1, 0, sizeof s1);
    s1.present = s.present;

    switch (s1.present) {
    case SpecialVehicleContainer_PR_publicTransportContainer:
        s1.choice.publicTransportContainer = cpy_PublicTransportContainer(
                    s.choice.publicTransportContainer);
        break;
    case SpecialVehicleContainer_PR_specialTransportContainer:
        s1.choice.specialTransportContainer = cpy_SpecialTransportContainer(
                    s.choice.specialTransportContainer);
        break;
    case SpecialVehicleContainer_PR_dangerousGoodsContainer:
        s1.choice.dangerousGoodsContainer = cpy_DangerousGoodsContainer(
                    s.choice.dangerousGoodsContainer);
        break;
    case SpecialVehicleContainer_PR_roadWorksContainerBasic:
        s1.choice.roadWorksContainerBasic = cpy_RoadWorksContainerBasic(
                    s.choice.roadWorksContainerBasic);
        break;
    case SpecialVehicleContainer_PR_rescueContainer:
        s1.choice.rescueContainer = cpy_RescueContainer(s.choice.rescueContainer);
        break;
    case SpecialVehicleContainer_PR_emergencyContainer:
        s1.choice.emergencyContainer = cpy_EmergencyContainer(s.choice.emergencyContainer);
        break;
    case SpecialVehicleContainer_PR_safetyCarContainer:
        s1.choice.safetyCarContainer = cpy_SafetyCarContainer(s.choice.safetyCarContainer);
        break;
    default:
        break;
    }

    return s1;
}

SpecialTransportContainer_t cpy_SpecialTransportContainer(
        SpecialTransportContainer_t s)
{
    SpecialTransportContainer_t s1;

    memset(&s1, 0, sizeof s1);
    s1.specialTransportType = cpy_SpecialTransportType(s.specialTransportType);
    s1.lightBarSirenInUse = cpy_LightBarSirenInUse(s.lightBarSirenInUse);

    return s1;
}

/************************
 * Equals
 ***********************/
/* DE */
bool isEqual_GenerationDeltaTime(GenerationDeltaTime_t a,
                                                     GenerationDeltaTime_t b){return a == b;}

/* DF */
bool isEqual_BasicContainer(BasicContainer_t a, BasicContainer_t b)
{
    return isEqual_StationType(a.stationType, b.stationType) &&
            isEqual_ReferencePosition(a.referencePosition, b.referencePosition);
}

bool isEqual_BasicVehicleContainerHighFrequency(
        BasicVehicleContainerHighFrequency_t a, BasicVehicleContainerHighFrequency_t b)
{
    if((!a.accelerationControl && b.accelerationControl) ||
       (a.accelerationControl && !b.accelerationControl) ||
       (!a.lanePosition && b.lanePosition) ||
       (a.lanePosition && !b.lanePosition) ||
       (!a.steeringWheelAngle && b.steeringWheelAngle) ||
       (a.steeringWheelAngle && !b.steeringWheelAngle) ||
       (!a.lateralAcceleration && b.lateralAcceleration) ||
       (a.lateralAcceleration && !b.lateralAcceleration) ||
       (!a.verticalAcceleration && b.verticalAcceleration) ||
       (a.verticalAcceleration && !b.verticalAcceleration) ||
       (!a.performanceClass && b.performanceClass) ||
       (a.performanceClass && !b.performanceClass) ||
       (!a.cenDsrcTollingZone && b.cenDsrcTollingZone) ||
       (a.cenDsrcTollingZone && !b.cenDsrcTollingZone))
        return false;
    if(a.accelerationControl)
        if(!isEqual_AccelerationControl(*a.accelerationControl, *b.accelerationControl))
            return false;
    if(a.lanePosition)
        if(!isEqual_LanePosition(*a.lanePosition, *b.lanePosition))
            return false;
    if(a.steeringWheelAngle)
        if(!isEqual_SteeringWheelAngle(*a.steeringWheelAngle, *b.steeringWheelAngle))
            return false;
    if(a.lateralAcceleration)
        if(!isEqual_LateralAcceleration(*a.lateralAcceleration, *b.lateralAcceleration))
            return false;
    if(a.verticalAcceleration)
        if(!isEqual_VerticalAcceleration(*a.verticalAcceleration, *b.verticalAcceleration))
            return false;
    if(a.performanceClass)
        if(!isEqual_PerformanceClass(*a.performanceClass, *b.performanceClass))
            return false;
    if(a.cenDsrcTollingZone)
        if(!isEqual_CenDsrcTollingZone(*a.cenDsrcTollingZone, *b.cenDsrcTollingZone))
            return false;
    return isEqual_Heading(a.heading, b.heading) &&
            isEqual_Speed(a.speed, b.speed) &&
            isEqual_DriveDirection(a.driveDirection, b.driveDirection) &&
            isEqual_VehicleLength(a.vehicleLength, b.vehicleLength) &&
            isEqual_VehicleWidth(a.vehicleWidth, b.vehicleWidth) &&
            isEqual_LongitudinalAcceleration(a.longitudinalAcceleration,
                                           b.longitudinalAcceleration) &&
            isEqual_Curvature(a.curvature, b.curvature) &&
            isEqual_CurvatureCalculationMode(a.curvatureCalculationMode,
                                           b.curvatureCalculationMode) &&
            isEqual_YawRate(a.yawRate, b.yawRate);
}

bool isEqual_BasicVehicleContainerLowFrequency(
        BasicVehicleContainerLowFrequency_t a, BasicVehicleContainerLowFrequency_t b)
{
    return isEqual_VehicleRole(a.vehicleRole, b.vehicleRole) &&
            isEqual_ExteriorLights(a.exteriorLights, b.exteriorLights) &&
            isEqual_PathHistory(a.pathHistory, b.pathHistory);
}

bool isEqual_CAM(CAM_t a, CAM_t b)
{
    return isEqual_ItsPduHeader(a.header, b.header) &&
            isEqual_CoopAwareness(a.cam, b.cam);
}

bool isEqual_CamParameters(CamParameters_t a, CamParameters_t b)
{
    if((!a.lowFrequencyContainer && b.lowFrequencyContainer) ||
       (a.lowFrequencyContainer && !b.lowFrequencyContainer) ||
       (!a.specialVehicleContainer && b.specialVehicleContainer) ||
       (a.specialVehicleContainer && !b.specialVehicleContainer))
        return false;
    if(a.lowFrequencyContainer)
        if(!isEqual_LowFrequencyContainer(*a.lowFrequencyContainer, *b.lowFrequencyContainer))
            return false;
    if(a.specialVehicleContainer)
        if(!isEqual_SpecialVehicleContainer(*a.specialVehicleContainer, *b.specialVehicleContainer))
            return false;
    return isEqual_BasicContainer(a.basicContainer, b.basicContainer) &&
            isEqual_HighFrequencycontainer(a.highFrequencyContainer, b.highFrequencyContainer);
}

bool isEqual_CoopAwareness(CoopAwareness_t a, CoopAwareness_t b)
{
    return isEqual_GenerationDeltaTime(a.generationDeltaTime, b.generationDeltaTime) &&
            isEqual_CamParameters(a.camParameters, b.camParameters);
}

bool isEqual_DangerousGoodsContainer(DangerousGoodsContainer_t a,
                                                       DangerousGoodsContainer_t b)
{
    return isEqual_DangerousGoodsBasic(a.dangerousGoodsBasic, b.dangerousGoodsBasic);
}

bool isEqual_EmergencyContainer(EmergencyContainer_t a, EmergencyContainer_t b)
{
    if((!a.incidentIndication && b.incidentIndication) ||
       (a.incidentIndication && b.incidentIndication) ||
       (!a.emergencyPriority && b.emergencyPriority) ||
       (a.emergencyPriority && !b.emergencyPriority))
        return false;
    if(a.incidentIndication)
        if(!isEqual_CauseCode(*a.incidentIndication, *b.incidentIndication))
            return false;
    if(a.emergencyPriority)
        if(!isEqual_EmergencyPriority(*a.emergencyPriority, *b.emergencyPriority))
            return false;
    return isEqual_LightBarSirenInUse(a.lightBarSirenInUse, b.lightBarSirenInUse);
}

bool isEqual_HighFrequencycontainer(HighFrequencyContainer_t a,
                                                      HighFrequencyContainer_t b)
{
    if(a.present != b.present)
        return false;
    switch (a.present) {
    case HighFrequencyContainer_PR_basicVehicleContainerHighFrequency:
        return isEqual_BasicVehicleContainerHighFrequency(
                    a.choice.basicVehicleContainerHighFrequency,
                    b.choice.basicVehicleContainerHighFrequency);
        break;
    case HighFrequencyContainer_PR_rsuContainerHighFrequency:
        return isEqual_RSUContainerHighFrequency(a.choice.rsuContainerHighFrequency,
                                               b.choice.rsuContainerHighFrequency);
        break;
    default:
    case HighFrequencyContainer_PR_NOTHING:
        return true;
        break;
    }
}

bool isEqual_LowFrequencyContainer(LowFrequencyContainer_t a,
                                                     LowFrequencyContainer_t b)
{
    if(a.present != b.present)
        return false;
    switch (a.present) {
    case LowFrequencyContainer_PR_basicVehicleContainerLowFrequency:
        return isEqual_BasicVehicleContainerLowFrequency(a.choice.basicVehicleContainerLowFrequency,
                                                       b.choice.basicVehicleContainerLowFrequency);
        break;
    default:
    case LowFrequencyContainer_PR_NOTHING:
        return true;
        break;
    }
}

bool isEqual_PublicTransportContainer(PublicTransportContainer_t a,
                                                        PublicTransportContainer_t b)
{
    if((!a.ptActivation && b.ptActivation) ||
       (a.ptActivation && !b.ptActivation))
        return false;
    if(a.ptActivation)
        if(!isEqual_PtActivation(*a.ptActivation, *b.ptActivation))
            return false;
    return isEqual_EmbarkationStatus(a.embarkationStatus, b.embarkationStatus);
}

bool isEqual_RescueContainer(RescueContainer_t a, RescueContainer_t b)
{
    return isEqual_LightBarSirenInUse(a.lightBarSirenInUse, b.lightBarSirenInUse);
}

bool isEqual_RoadWorksContainerBasic(RoadWorksContainerBasic_t a,
                                                       RoadWorksContainerBasic_t b)
{
    if((!a.roadworksSubCauseCode && b.roadworksSubCauseCode) ||
       (a.roadworksSubCauseCode && !b.roadworksSubCauseCode) ||
       (!a.closedLanes && b.closedLanes) ||
       (a.closedLanes && b.closedLanes))
        return false;
    if(a.roadworksSubCauseCode)
        if(!isEqual_SubCauseCodeType(*a.roadworksSubCauseCode, *b.roadworksSubCauseCode))
            return false;
    if(a.closedLanes)
        if(!isEqual_ClosedLanes(*a.closedLanes, *b.closedLanes))
            return false;
    return isEqual_LightBarSirenInUse(a.lightBarSirenInUse, b.lightBarSirenInUse);
}

bool isEqual_RSUContainerHighFrequency(RSUContainerHighFrequency_t a,
                                                         RSUContainerHighFrequency_t b)
{
    if((!a.protectedCommunicationZonesRSU && b.protectedCommunicationZonesRSU) ||
       (a.protectedCommunicationZonesRSU && !b.protectedCommunicationZonesRSU))
        return false;
    if(a.protectedCommunicationZonesRSU)
        if(!isEqual_ProtectedCommunicationZonesRSU(*a.protectedCommunicationZonesRSU,
                                                 *b.protectedCommunicationZonesRSU))
            return false;
    return true;
}

bool isEqual_SafetyCarContainer(SafetyCarContainer_t a, SafetyCarContainer_t b)
{
    if((!a.incidentIndication && b.incidentIndication) ||
       (a.incidentIndication && !b.incidentIndication) ||
       (!a.trafficRule && b.trafficRule) ||
       (a.trafficRule && !b.trafficRule) ||
       (!a.speedLimit && b.speedLimit) ||
       (a.speedLimit && !b.speedLimit))
        return false;
    if(a.incidentIndication)
        if(!isEqual_CauseCode(*a.incidentIndication, *b.incidentIndication))
            return false;
    if(a.trafficRule)
        if(!isEqual_TrafficRule(*a.trafficRule, *b.trafficRule))
            return false;
    if(a.speedLimit)
        if(!isEqual_SpeedLimit(*a.speedLimit, *b.speedLimit))
            return false;
    return isEqual_LightBarSirenInUse(a.lightBarSirenInUse, b.lightBarSirenInUse);
}

bool isEqual_SpecialTransportContainer(SpecialTransportContainer_t a,
                                                         SpecialTransportContainer_t b)
{
    return isEqual_SpecialTransportType(a.specialTransportType, b.specialTransportType) &&
            isEqual_LightBarSirenInUse(a.lightBarSirenInUse, b.lightBarSirenInUse);
}

bool isEqual_SpecialVehicleContainer(SpecialVehicleContainer_t a,
                                                       SpecialVehicleContainer_t b)
{
    if(a.present != b.present)
        return false;
    switch (a.present) {
    case SpecialVehicleContainer_PR_publicTransportContainer:
        return isEqual_PublicTransportContainer(a.choice.publicTransportContainer,
                                              b.choice.publicTransportContainer);
        break;
    case SpecialVehicleContainer_PR_specialTransportContainer:
        return isEqual_SpecialTransportContainer(a.choice.specialTransportContainer,
                                               b.choice.specialTransportContainer);
        break;
    case SpecialVehicleContainer_PR_dangerousGoodsContainer:
        return isEqual_DangerousGoodsContainer(a.choice.dangerousGoodsContainer,
                                             b.choice.dangerousGoodsContainer);
        break;
    case SpecialVehicleContainer_PR_roadWorksContainerBasic:
        return isEqual_RoadWorksContainerBasic(a.choice.roadWorksContainerBasic,
                                             b.choice.roadWorksContainerBasic);
        break;
    case SpecialVehicleContainer_PR_rescueContainer:
        return isEqual_RescueContainer(a.choice.rescueContainer, b.choice.rescueContainer);
        break;
    case SpecialVehicleContainer_PR_emergencyContainer:
        return isEqual_EmergencyContainer(a.choice.emergencyContainer, b.choice.emergencyContainer);
        break;
    case SpecialVehicleContainer_PR_safetyCarContainer:
        return isEqual_SafetyCarContainer(a.choice.safetyCarContainer, b.choice.safetyCarContainer);
        break;
    default:
    case SpecialVehicleContainer_PR_NOTHING:
        return true;
        break;
    }
}

/************************
 * Maker
 ***********************/
/* DE */
GenerationDeltaTime_t make_GenerationDeltaTime()
{
    GenerationDeltaTime_t g = 0;

    return g;
}

/* DF */
BasicContainer_t make_BasicContainer()
{
    BasicContainer_t b;

    memset(&b, 0, sizeof b);
    b.stationType = make_StationType();
    b.referencePosition = make_ReferencePosition();

    return b;
}

BasicVehicleContainerHighFrequency_t make_BasicVehicleContainerHighFrequency()
{
    BasicVehicleContainerHighFrequency_t b;

    memset(&b, 0, sizeof b);
    b.heading = make_Heading();
    b.speed = make_Speed();
    b.driveDirection = make_DriveDirection();
    b.vehicleLength = make_VehicleLength();
    b.vehicleWidth = make_VehicleWidth();
    b.longitudinalAcceleration = make_LongitudinalAcceleration();
    b.curvature = make_Curvature();
    b.curvatureCalculationMode = make_CurvatureCalculationMode();
    b.yawRate = make_YawRate();
    b.accelerationControl = 0;
    b.lanePosition = 0;
    b.steeringWheelAngle = 0;
    b.lateralAcceleration = 0;
    b.verticalAcceleration = 0;
    b.performanceClass = 0;
    b.cenDsrcTollingZone = 0;

    return b;
}

BasicVehicleContainerLowFrequency_t make_BasicVehicleContainerLowFrequency()
{
    BasicVehicleContainerLowFrequency_t b;

    memset(&b, 0, sizeof b);
    b.exteriorLights = make_ExteriorLights();
    b.pathHistory = make_PathHistory();
    b.vehicleRole = make_VehicleRole();

    return b;
}

CAM_t make_CAM()
{
    CAM_t cam;

    memset(&cam, 0, sizeof cam);
    cam.header = make_ItsPduHeader(messageID_cam);
    cam.cam = make_CoopAwareness();

    return cam;
}

CamParameters_t make_CamParameters()
{
    CamParameters_t c;

    memset(&c, 0, sizeof c);
    c.basicContainer = make_BasicContainer();
    c.highFrequencyContainer = make_HighFrequencyContainer(HighFrequencyContainer_PR_NOTHING);
    c.lowFrequencyContainer = 0;
    c.specialVehicleContainer = 0;

    return c;
}

CoopAwareness_t make_CoopAwareness()
{
    CoopAwareness_t c;

    memset(&c, 0, sizeof c);
    c.generationDeltaTime = make_GenerationDeltaTime();
    c.camParameters = make_CamParameters();

    return c;
}

DangerousGoodsContainer_t make_DangerousGoodsContainer()
{
    DangerousGoodsContainer_t d;

    memset(&d, 0, sizeof d);
    d.dangerousGoodsBasic = make_DangerousGoodsBasic();

    return d;
}

EmergencyContainer_t make_EmergencyContainer()
{
    EmergencyContainer_t e;

    memset(&e, 0, sizeof e);
    e.lightBarSirenInUse = make_LightBarSirenInUse();
    e.incidentIndication = 0;
    e.emergencyPriority = 0;

    return e;
}

HighFrequencyContainer_t make_HighFrequencyContainer(HighFrequencyContainer_PR present)
{
    HighFrequencyContainer_t h;

    memset(&h, 0, sizeof h);
    switch(present){
    case(HighFrequencyContainer_PR_basicVehicleContainerHighFrequency):
        h.present = present;
        h.choice.basicVehicleContainerHighFrequency = make_BasicVehicleContainerHighFrequency();
        break;
    case(HighFrequencyContainer_PR_rsuContainerHighFrequency):
        h.present = present;
        h.choice.rsuContainerHighFrequency = make_RSUContainerHighFrequency();
        break;
    default:
        h.present = HighFrequencyContainer_PR_NOTHING;
        break;
    }

    return h;
}

LowFrequencyContainer_t make_LowFrequencyContainer(LowFrequencyContainer_PR present)
{
    LowFrequencyContainer_t l;

    memset(&l, 0, sizeof l);

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

    return l;
}

PublicTransportContainer_t make_PublicTransportContainer()
{
    PublicTransportContainer_t p;

    memset(&p, 0, sizeof p);
    p.embarkationStatus = make_EmbarkationStatus();
    p.ptActivation = 0;

    return p;
}

RescueContainer_t make_RescueContainer()
{
    RescueContainer_t r;

    memset(&r, 0, sizeof r);
    r.lightBarSirenInUse = make_LightBarSirenInUse();

    return r;
}

RoadWorksContainerBasic_t make_RoadWorksContainerBasic()
{
    RoadWorksContainerBasic_t r;

    memset(&r, 0, sizeof r);
    r.roadworksSubCauseCode = 0;
    r.lightBarSirenInUse = make_LightBarSirenInUse();
    r.closedLanes = 0;

    return r;
}

RSUContainerHighFrequency_t make_RSUContainerHighFrequency()
{
    RSUContainerHighFrequency_t r;

    memset(&r, 0, sizeof r);
    r.protectedCommunicationZonesRSU = 0;

    return r;
}

SafetyCarContainer_t make_SafetyCarContainer()
{
    SafetyCarContainer_t s;

    memset(&s, 0, sizeof s);
    s.lightBarSirenInUse = make_LightBarSirenInUse();
    s.incidentIndication = 0;
    s.trafficRule = 0;
    s.speedLimit = 0;

    return s;
}

SpecialTransportContainer_t make_SpecialTransportContainer()
{
    SpecialTransportContainer_t s;

    memset(&s, 0, sizeof s);
    s.specialTransportType = make_SpecialTransportType();
    s.lightBarSirenInUse = make_LightBarSirenInUse();

    return s;
}

SpecialVehicleContainer_t make_SpecialVehicleContainer(SpecialVehicleContainer_PR present)
{
    SpecialVehicleContainer_t s;

    memset(&s, 0, sizeof s);

    switch(present)
    {
    case SpecialVehicleContainer_PR_publicTransportContainer:
        s.present = present;
        s.choice.publicTransportContainer = make_PublicTransportContainer();
        break;
    case SpecialVehicleContainer_PR_specialTransportContainer:
        s.present = present;
        s.choice.specialTransportContainer = make_SpecialTransportContainer();
        break;
    case SpecialVehicleContainer_PR_dangerousGoodsContainer:
        s.present = present;
        s.choice.dangerousGoodsContainer = make_DangerousGoodsContainer();
        break;
    case SpecialVehicleContainer_PR_roadWorksContainerBasic:
        s.present = present;
        s.choice.roadWorksContainerBasic = make_RoadWorksContainerBasic();
        break;
    case SpecialVehicleContainer_PR_rescueContainer:
        s.present = present;
        s.choice.rescueContainer = make_RescueContainer();
        break;
    case SpecialVehicleContainer_PR_emergencyContainer:
        s.present = present;
        s.choice.emergencyContainer = make_EmergencyContainer();
        break;
    case SpecialVehicleContainer_PR_safetyCarContainer:
        s.present = present;
        s.choice.safetyCarContainer = make_SafetyCarContainer();
        break;
    default:
        s.present = SpecialVehicleContainer_PR_NOTHING;
        break;
    }

    return s;
}