AppDenmTriggerData.cpp

Go to the documentation of this file.

#include "AppDenmTriggerData.h"

#include <QDataStream>
#include <QDebug>

AppDenmTriggerData::AppDenmTriggerData(ParameterDENM *paramDENM)
{
    m_eventDetectionTime = 0;
    m_eventPosition = ReferencePositionData();
    m_validityDuration = 0;
    m_repetitionDuration = 0;
    m_transmissionInterval = 0;
    m_repetitionInterval = 0;
    m_situation = 0;
    m_location = 0;
    m_alacarte = 0;
    m_relevanceDistance = 0;
    m_relevanceTrafficDirection = 0;
    m_lifeTime = 0;
    m_maximumHopLimit = 0;
    m_destinationArea = DestinationAreaData();
    m_trafficClass = TrafficClassData();
    m_paramDENM = paramDENM;
}

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

    m_eventDetectionTime = 0;
    m_eventPosition = ReferencePositionData();
    m_validityDuration = 0;
    m_repetitionDuration = 0;
    m_transmissionInterval = 0;
    m_repetitionInterval = 0;
    m_situation = 0;
    m_location = 0;
    m_alacarte = 0;
    m_relevanceDistance = 0;
    m_relevanceTrafficDirection = 0;
    m_lifeTime = 0;
    m_maximumHopLimit = 0;
    m_destinationArea = DestinationAreaData();
    m_trafficClass = TrafficClassData();

    if(options & (1 << (15 - AppDenmTriggerData_validityDuration)))
        m_validityDuration = (quint32*)calloc(1, sizeof *m_validityDuration);
    if(options & (1 << (15 - AppDenmTriggerData_repetitionDuration)))
        m_repetitionDuration = (quint32*)calloc(1, sizeof *m_repetitionDuration);
    if(options & (1 << (15 - AppDenmTriggerData_transmissionInterval)))
        m_transmissionInterval = (quint16*)calloc(1, sizeof *m_transmissionInterval);
    if(options & (1 << (15 - AppDenmTriggerData_repetitionInterval)))
        m_repetitionInterval = (quint16*)calloc(1, sizeof *m_repetitionInterval);
    if(options & (1 << (15 - AppDenmTriggerData_relevanceDistance)))
        m_relevanceDistance = (quint8*)calloc(1, sizeof *m_relevanceDistance);
    if(options & (1 << (15 - AppDenmTriggerData_relevanceTrafficDirection)))
        m_relevanceTrafficDirection = (quint8*)calloc(1, sizeof *m_relevanceTrafficDirection);

    m_eventDetectionTime = 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_transmissionInterval)
        *m_transmissionInterval = extractUInt(data, 2, &offset);
    else
        passBytes(&offset, 2);
    if(m_repetitionInterval)
        *m_repetitionInterval = extractUInt(data, 2, &offset);
    else
        passBytes(&offset, 2);
    if(options & (1 << (15 - AppDenmTriggerData_situation)))
    {
        m_situation = new QByteArray(data + offset + 1, *(data + offset));
        passBytes(&offset, *(data + offset) + 1);
    }
    else
        passBytes(&offset, 1);
    if(options & (1 << (15 - AppDenmTriggerData_location)))
    {
        m_location = new QByteArray(data + offset + 1, *(data + offset));
        passBytes(&offset, *(data + offset) + 1);
    }
    else
        passBytes(&offset, 1);
    if(options & (1 << (15 - AppDenmTriggerData_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);
    m_trafficClass = TrafficClassData(data, &offset);

    qInfo() << "AppDENMTrigger created:\n" << this->toString();
}

AppDenmTriggerData::AppDenmTriggerData(DENM_t denm, DestinationAreaData destination)
{
    char tmp[MSG_LENGTH] = {'\0'};
    asn_enc_rval_t rval;

    asn_INTEGER2ulong((INTEGER_t*)&denm.denm.management.detectionTime, (long unsigned int*)&m_eventDetectionTime);
    m_eventPosition = ReferencePositionData(denm.denm.management.eventPosition);
    if(denm.denm.management.validityDuration)
    {
        m_validityDuration = (quint32*)calloc(1, sizeof *m_validityDuration);
        *m_validityDuration = *denm.denm.management.validityDuration;
        m_repetitionDuration = (quint32*)calloc(1, sizeof *m_repetitionDuration);
        *m_repetitionDuration = *denm.denm.management.validityDuration;
        m_lifeTime = new LifeTimeData(*denm.denm.management.validityDuration);
    }
    else
    {
        m_validityDuration = 0;
        m_repetitionDuration = 0;
        m_lifeTime = 0;
    }
    m_transmissionInterval = 0;
    m_repetitionInterval = 0;
    if(denm.denm.situation)
    {
        rval = uper_encode_to_buffer(&asn_DEF_SituationContainer, denm.denm.situation, tmp, MSG_LENGTH);
        if(rval.encoded > 0)
            m_situation = new QByteArray(tmp, (rval.encoded + 7) / 8);
        else
            m_situation = 0;
        memset(tmp, '\0', MSG_LENGTH);
    }
    else
        m_situation = 0;
    if(denm.denm.location)
    {
        rval = uper_encode_to_buffer(&asn_DEF_LocationContainer, denm.denm.location, tmp, MSG_LENGTH);
        if(rval.encoded > 0)
            m_location = new QByteArray(tmp, (rval.encoded + 7) / 8);
        else
            m_location = 0;
        memset(tmp, '\0', MSG_LENGTH);
    }
    else
        m_location = 0;
    if(denm.denm.alacarte)
    {
        rval = uper_encode_to_buffer(&asn_DEF_AlacarteContainer, denm.denm.alacarte, tmp, MSG_LENGTH);
        if(rval.encoded > 0)
            m_alacarte = new QByteArray(tmp, (rval.encoded + 7) / 8);
        else
            m_alacarte = 0;
        memset(tmp, '\0', MSG_LENGTH);
    }
    else
        m_alacarte = 0;
    if(denm.denm.management.relevanceDistance)
    {
        m_relevanceDistance = (quint8*)calloc(1, sizeof *m_relevanceDistance);
        *m_relevanceDistance = *denm.denm.management.relevanceDistance;
    }
    else
        m_relevanceDistance = 0;
    if(denm.denm.management.relevanceTrafficDirection)
    {
        m_relevanceTrafficDirection = (quint8*)calloc(1, sizeof *m_relevanceTrafficDirection);
        *m_relevanceTrafficDirection = *denm.denm.management.relevanceTrafficDirection;
    }
    else
        m_relevanceTrafficDirection = 0;
    m_maximumHopLimit = (quint8*)calloc(1, sizeof *m_maximumHopLimit);
    *m_maximumHopLimit = 10;
    m_destinationArea = destination;
    m_trafficClass = TrafficClassData();
}

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

    if(m_validityDuration)
        options |= 1 << (15 - AppDenmTriggerData_validityDuration);
    if(m_repetitionDuration)
        options |= 1 << (15 - AppDenmTriggerData_repetitionDuration);
    if(m_transmissionInterval)
        options |= 1 << (15 - AppDenmTriggerData_transmissionInterval);
    if(m_repetitionInterval)
        options |= 1 << (15 - AppDenmTriggerData_repetitionInterval);
    if(m_situation)
        options |= 1 << (15 - AppDenmTriggerData_situation);
    if(m_location)
        options |= 1 << (15 - AppDenmTriggerData_location);
    if(m_alacarte)
        options |= 1 << (15 - AppDenmTriggerData_alacarte);
    if(m_relevanceDistance)
        options |= 1 << (15 - AppDenmTriggerData_relevanceDistance);
    if(m_relevanceTrafficDirection)
        options |= 1 << (15 - AppDenmTriggerData_relevanceTrafficDirection);

    return options;
}

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

    ds << messageType << options << m_eventDetectionTime;

    ds.writeRawData(m_eventPosition.toBin().toStdString().c_str(), 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_repetitionInterval)
        ds << *m_repetitionInterval;
    else
        ds << zero16;
    if(m_situation)
    {
        ds << (quint8)m_situation->length();
        ds.writeRawData(m_situation->toStdString().c_str(), m_situation->length());
    }
    else
        ds << zero8;
    if(m_location)
    {
        ds << (quint8)m_location->length();
        ds.writeRawData(m_location->toStdString().c_str(), m_location->length());
    }
    else
        ds << zero8;
    if(m_alacarte)
    {
        ds << (quint8)m_alacarte->length();
        ds.writeRawData(m_alacarte->toStdString().c_str(), m_alacarte->length());
    }
    else
        ds << zero8;
    if(m_relevanceDistance)
        ds << *m_relevanceDistance;
    else
        ds << zero8;
    if(m_relevanceTrafficDirection)
        ds << *m_relevanceTrafficDirection;
    else
        ds << zero8;
    ds.writeRawData(m_destinationArea.toBin().toStdString().c_str(), m_destinationArea.toBin().length());
    ds.writeRawData(m_trafficClass.toBin().toStdString().c_str(), m_trafficClass.toBin().length());


    return bin;
}

QString AppDenmTriggerData::toString()
{
    return QString("AppDenmTriggerData ::= {\n"
                   "\tEventDetectionTime ::= %1\n"
                   "\tEventPosition ::= {\n"
                   "\t%2\n"
                   "\t}\n"
                   "\tValidityDuration ::= %3\n"
                   "\tRepetitionDuration ::= %4\n"
                   "\tTransmissionInterval ::= %5\n"
                   "\tRepetitionInterval ::= %6\n"
                   "\tSituationLength ::= %7\n"
                   "\tSituation ::= %8\n"
                   "\tLocationLength ::= %9\n"
                   "\tLocation ::= %10\n"
                   "\tAlacarteLength ::= %11\n"
                   "\tAlacarte ::= %12\n"
                   "\tRelevanceDistance ::= %13\n"
                   "\tRelevanceTrafficDirection ::= %14\n"
                   "\tDestinationArea ::= {\n"
                   "\t%15\n"
                   "\t}\n"
                   "\tTrafficClass ::= {\n"
                   "\t%16\n"
                   "\t}\n"
                   "}\n")
            .arg(m_eventDetectionTime)
            .arg(m_eventPosition.toString())
            .arg(m_validityDuration ? QString::number(*m_validityDuration) : QString("omit"))
            .arg(m_repetitionDuration ? QString::number(*m_repetitionDuration) : QString("omit"))
            .arg(m_transmissionInterval ? QString::number(*m_transmissionInterval) : QString("omit"))
            .arg(m_repetitionInterval ? QString::number(*m_repetitionInterval) : QString("omit"))
            .arg(m_situation ? m_situation->length() : 0)
            .arg(m_situation ? m_situation->toHex() : QString("omit"))
            .arg(m_location ? m_location->length() : 0)
            .arg(m_location ? m_location->toHex() : QString("omit"))
            .arg(m_alacarte ? m_alacarte->length() : 0)
            .arg(m_alacarte ? m_alacarte->toHex() : QString("omit"))
            .arg(m_relevanceDistance ? QString::number(*m_relevanceDistance) : QString("omit"))
            .arg(m_relevanceTrafficDirection ? QString::number(*m_relevanceTrafficDirection) : QString("omit"))
            .arg(m_destinationArea.toString())
            .arg(m_trafficClass.toString());
}