AppDenmUpdateData.cpp

Go to the documentation of this file.

#include "AppDenmUpdateData.h"

#include <QDataStream>

AppDenmUpdateData::AppDenmUpdateData(ParameterDENM *paramDENM)
{
    m_eventUpdateDetectionTime = 0;
    m_validityDuration = 0;
    m_repetitionDuration = 0;
    m_transmissionInterval = 0;
    m_transmissionDuration = 0;
    m_relevanceDistance = 0;
    m_relevanceTrafficDirection = 0;
    m_location = 0;
    m_situation = 0;
    m_alacarte = 0;
    m_trafficClass = 0;
    m_paramDENM = paramDENM;
}

AppDenmUpdateData::AppDenmUpdateData(QByteArray datagram)
{
    char *data = datagram.data();
    int offset = 1;
    quint16 options = extractUInt(data, 2, &offset);

    m_eventUpdateDetectionTime = 0;
    m_validityDuration = 0;
    m_repetitionDuration = 0;
    m_transmissionInterval = 0;
    m_transmissionDuration = 0;
    m_relevanceDistance = 0;
    m_relevanceTrafficDirection = 0;
    m_location = 0;
    m_situation = 0;
    m_alacarte = 0;
    m_trafficClass = 0;

    if(options & (1 << (15 - AppDenmUpdateData_validityDuration)))
        m_validityDuration = (quint32*)calloc(1, sizeof *m_validityDuration);
    if(options & (1 << (15 - AppDenmUpdateData_repetitionDuration)))
        m_repetitionDuration = (quint32*)calloc(1, sizeof *m_repetitionDuration);
    if(options & (1 << (15 - AppDenmUpdateData_transmissionDuration)))
        m_transmissionDuration = (quint16*)calloc(1, sizeof *m_transmissionDuration);
    if(options & (1 << (15 - AppDenmUpdateData_transmissionInterval)))
        m_transmissionInterval = (quint16*)calloc(1, sizeof *m_transmissionInterval);
    if(options & (1 << (15 - AppDenmUpdateData_relevanceDistance)))
        m_relevanceDistance = (quint8*)calloc(1, sizeof *m_relevanceDistance);
    if(options & (1 << (15 - AppDenmUpdateData_relevanceTrafficDirection)))
        m_relevanceTrafficDirection = (quint8*)calloc(1, sizeof *m_relevanceTrafficDirection);
    if(options & (1 << (15 - AppDenmUpdateData_trafficClass)))
        m_trafficClass = (TrafficClassData*)calloc(1, sizeof *m_trafficClass);

    m_actionID = ActionIDData(data, &offset);
    m_eventUpdateDetectionTime = extractUInt(data, 8, &offset);
    m_eventPosition = ReferencePositionData(data, &offset);
    if(m_validityDuration)
        *m_validityDuration = extractUInt(data, 4, &offset);
    else
        passBytes(&offset, 4);
    if(m_repetitionDuration)
        *m_repetitionDuration = extractUInt(data, 4, &offset);
    else
        passBytes(&offset, 4);
    if(m_transmissionDuration)
        *m_transmissionDuration = extractUInt(data, 2, &offset);
    else
        passBytes(&offset, 2);
    if(m_transmissionInterval)
        *m_transmissionInterval = extractUInt(data, 2, &offset);
    else
        passBytes(&offset, 2);
    if(options & (1 << (15 - AppDenmUpdateData_situation)))
    {
        m_situation = new QByteArray(data + offset + 1, *(data + offset));
        passBytes(&offset, *(data + offset) + 1);
    }
    else
        passBytes(&offset, 1);
    if(options & (1 << (15 - AppDenmUpdateData_location)))
    {
        m_location = new QByteArray(data + offset + 1, *(data + offset));
        passBytes(&offset, *(data + offset) + 1);
    }
    else
        passBytes(&offset, 1);
    if(options & (1 << (15 - AppDenmUpdateData_alacarte)))
    {
        m_alacarte = new QByteArray(data + offset + 1, *(data + offset));
        passBytes(&offset, *(data + offset) + 1);
    }
    else
        passBytes(&offset, 1);
    if(m_relevanceDistance)
        *m_relevanceDistance = extractUInt(data, 1, &offset);
    else
        passBytes(&offset, 1);
    if(m_relevanceTrafficDirection)
        *m_relevanceTrafficDirection = extractUInt(data, 1, &offset);
    else
        passBytes(&offset, 1);
    m_destinationArea = DestinationAreaData(data, &offset);
    if(m_trafficClass)
        m_trafficClass = new TrafficClassData(data, &offset);
    else
        passBytes(&offset, 1);
}

quint16 AppDenmUpdateData::getOptions()
{
    quint16 options = 0;

    if(m_validityDuration)
        options |= 1 << (15 - AppDenmUpdateData_validityDuration);
    if(m_repetitionDuration)
        options |= 1 << (15 - AppDenmUpdateData_repetitionDuration);
    if(m_transmissionDuration)
        options |= 1 << (15 - AppDenmUpdateData_transmissionDuration);
    if(m_transmissionInterval)
        options |= 1 << (15 - AppDenmUpdateData_transmissionInterval);
    if(m_situation)
        options |= 1 << (15 - AppDenmUpdateData_situation);
    if(m_location)
        options |= 1 << (15 - AppDenmUpdateData_location);
    if(m_alacarte)
        options |= 1 << (15 - AppDenmUpdateData_alacarte);
    if(m_relevanceDistance)
        options |= 1 << (15 - AppDenmUpdateData_relevanceDistance);
    if(m_relevanceTrafficDirection)
        options |= 1 << (15 - AppDenmUpdateData_relevanceTrafficDirection);

    return options;
}

QByteArray AppDenmUpdateData::toBin()
{
    QByteArray bin;
    QDataStream ds(&bin, QIODevice::WriteOnly);
    quint8 messageType = m_paramDENM->mtAppDENMUpdate();
    quint16 options = getOptions();
    quint8 zero8 = 0;
    quint16 zero16 = 0;
    quint32 zero32 = 0;

    ds << messageType << options;
    ds.writeRawData(m_actionID.toBin().data(), m_actionID.toBin().length());
    ds << m_eventUpdateDetectionTime;
    ds.writeRawData(m_eventPosition.toBin().data(), m_eventPosition.toBin().length());
    if(m_validityDuration)
        ds << *m_validityDuration;
    else
        ds << zero32;
    if(m_repetitionDuration)
        ds << *m_repetitionDuration;
    else
        ds << zero32;
    if(m_transmissionInterval)
        ds << *m_transmissionInterval;
    else
        ds << zero16;
    if(m_transmissionDuration)
        ds << *m_transmissionDuration;
    else
        ds << zero16;
    if(m_situation)
    {
        ds << (quint8)m_situation->length();
        ds.writeRawData(m_situation->data(), m_situation->length());
    }
    if(m_location)
    {
        ds << (quint8)m_location->length();
        ds.writeRawData(m_location->data(), m_location->length());
    }
    if(m_alacarte)
    {
        ds << (quint8)m_alacarte->length();
        ds.writeRawData(m_alacarte->data(), m_alacarte->length());
    }
    if(m_relevanceDistance)
        ds << *m_relevanceDistance;
    else
        ds << zero8;
    if(m_relevanceTrafficDirection)
        ds << *m_relevanceTrafficDirection;
    else
        ds << zero8;
    ds.writeRawData(m_destinationArea.toBin().data(), m_destinationArea.toBin().length());
    if(m_trafficClass)
        ds.writeRawData(m_trafficClass->toBin().data(), m_trafficClass->toBin().length());
    else
        ds << zero8;

    return bin;
}