PacketBuffersEntry.cpp

Go to the documentation of this file.

#include "PacketBuffersEntry.h"

PacketBuffersEntry::PacketBuffersEntry()
{
}

PacketBuffersEntry::PacketBuffersEntry(BasicHeader bh, CommonHeader ch, BeaconPacket packet)
{
    m_bh = bh;
    m_ch = ch;
    m_payload = QByteArray();
    m_beac = packet;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = 0;
        m_forwarder[i] = 0;
    }
}

PacketBuffersEntry::PacketBuffersEntry(BasicHeader bh, CommonHeader ch, LSRequestPacket packet)
{
    m_bh = bh;
    m_ch = ch;
    m_payload = QByteArray();
    m_lsRequest = packet;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = 0;
        m_forwarder[i] = 0;
    }
}

PacketBuffersEntry::PacketBuffersEntry(BasicHeader bh, CommonHeader ch, LSReplyPacket packet)
{
    m_bh = bh;
    m_ch = ch;
    m_payload = QByteArray();
    m_lsReply = packet;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = 0;
        m_forwarder[i] = 0;
    }
}

PacketBuffersEntry::PacketBuffersEntry(BasicHeader bh, CommonHeader ch, GACPacket packet, QByteArray payload, uchar* destination, uchar* forwarder)
{
    m_bh = bh;
    m_ch = ch;
    m_payload = payload;
    m_gac = packet;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = destination[i];
        m_forwarder[i] = forwarder[i];
    }
}

PacketBuffersEntry::PacketBuffersEntry(BasicHeader bh, CommonHeader ch, GBCPacket packet, QByteArray payload, uchar* destination, uchar* forwarder)
{
    m_bh = bh;
    m_ch = ch;
    m_payload = payload;
    m_gbc = packet;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = destination[i];
        m_forwarder[i] = forwarder[i];
    }
}

PacketBuffersEntry::PacketBuffersEntry(BasicHeader bh, CommonHeader ch, GUCPacket packet, QByteArray payload)
{
    m_bh = bh;
    m_ch = ch;
    m_payload = payload;
    m_guc = packet;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = 0;
        m_forwarder[i] = 0;
    }
}

PacketBuffersEntry::PacketBuffersEntry(BasicHeader bh, CommonHeader ch, TSBPacket packet, QByteArray payload)
{
    m_bh = bh;
    m_ch = ch;
    m_payload = payload;
    m_tsb = packet;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = 0;
        m_forwarder[i] = 0;
    }
}

PacketBuffersEntry::PacketBuffersEntry(BasicHeader bh, CommonHeader ch, SHBPacket packet, QByteArray payload)
{
    m_bh = bh;
    m_ch = ch;
    m_payload = payload;
    m_shb = packet;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = 0;
        m_forwarder[i] = 0;
    }
}


PacketBuffersEntry::PacketBuffersEntry(const PacketBuffersEntry& other) : QObject()
{
    m_bh = other.m_bh;
    m_ch = other.m_ch;
    m_payload = other.m_payload;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = other.m_destination[i];
        m_forwarder[i] = other.m_forwarder[i];
    }
    switch(other.m_ch.headerType())
    {
    case CommonHeader::headerType_beacon:
        m_beac = other.m_beac;
        break;
    case CommonHeader::headerType_geoAnycast:
        m_gac = other.m_gac;
        break;
    case CommonHeader::headerType_geoBroadcast:
        m_gbc = other.m_gbc;
        break;
    case CommonHeader::headerType_geoUnicast:
        m_guc = other.m_guc;
        break;
    case CommonHeader::headerType_topologicallyScopedBroadcast:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_singleHop:
            m_shb = other.m_shb;
            break;
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_multiHop:
            m_tsb= other.m_tsb;
            break;
        default:
            break;
        }
        break;
    case CommonHeader::headerType_locationService:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeLocationService_Request:
            m_lsRequest = other.m_lsRequest;
            break;
        case CommonHeader::headerSubTypeLocationService_Reply:
            m_lsReply= other.m_lsReply;
            break;
        default:
            break;
        }
        break;
    case CommonHeader::headerType_any:
    default:
        break;
    }

    for(int i=0; i<6; i++)
    {
        m_destination[i] = other.m_destination[i];
        m_forwarder[i] = other.m_forwarder[i];
    }
}

bool PacketBuffersEntry::operator==(const PacketBuffersEntry &other)
{
    if(m_ch.headerType() != other.m_ch.headerType() || m_ch.headerSubType() != other.m_ch.headerSubType())
        return false;

    switch(other.m_ch.headerType())
    {
    case CommonHeader::headerType_beacon:
        return !isDuplicatePacketDetectionTimestamp(other.m_beac.soPv().timestamp(), m_beac.soPv().timestamp());
        break;
    case CommonHeader::headerType_geoAnycast:
        return !isDuplicatePacketDetectionTimestampSN(other.m_gac.soPv().timestamp(), m_gac.soPv().timestamp(), other.m_gac.sequenceNumber(), m_gac.sequenceNumber());
        break;
    case CommonHeader::headerType_geoBroadcast:
        return !isDuplicatePacketDetectionTimestampSN(other.m_gbc.soPv().timestamp(), m_gbc.soPv().timestamp(), other.m_gbc.sequenceNumber(), m_gbc.sequenceNumber());
        break;
    case CommonHeader::headerType_geoUnicast:
        return !isDuplicatePacketDetectionTimestampSN(other.m_guc.soPv().timestamp(), m_guc.soPv().timestamp(), other.m_guc.sequenceNumber(), m_guc.sequenceNumber());
        break;
    case CommonHeader::headerType_topologicallyScopedBroadcast:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_singleHop:
            return !isDuplicatePacketDetectionTimestamp(other.m_shb.soPv().timestamp(), m_shb.soPv().timestamp());
            break;
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_multiHop:
            return !isDuplicatePacketDetectionTimestampSN(other.m_tsb.soPv().timestamp(), m_tsb.soPv().timestamp(), other.m_tsb.sequenceNumber(), m_tsb.sequenceNumber());
            break;
        default:
            return false;
        }
        break;
    case CommonHeader::headerType_locationService:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeLocationService_Request:
            return !isDuplicatePacketDetectionTimestampSN(other.m_lsRequest.soPv().timestamp(), m_lsRequest.soPv().timestamp(), other.m_lsRequest.sequenceNumber(), m_lsRequest.sequenceNumber());
            break;
        case CommonHeader::headerSubTypeLocationService_Reply:
            m_lsReply= other.m_lsReply;
            break;
        default:
            break;
        }
        break;
    case CommonHeader::headerType_any:
    default:
        return false;
        break;
    }

    return true;
}

PacketBuffersEntry& PacketBuffersEntry::operator=(const PacketBuffersEntry &other)
{
    m_bh = other.m_bh;
    m_ch = other.m_ch;
    m_payload = other.m_payload;
    for(int i=0; i<6; i++)
    {
        m_destination[i] = other.m_destination[i];
        m_forwarder[i] = other.m_forwarder[i];
    }
    switch(other.m_ch.headerType())
    {
    case CommonHeader::headerType_beacon:
        m_beac = other.m_beac;
        break;
    case CommonHeader::headerType_geoAnycast:
        m_gac = other.m_gac;
        break;
    case CommonHeader::headerType_geoBroadcast:
        m_gbc = other.m_gbc;
        break;
    case CommonHeader::headerType_geoUnicast:
        m_guc = other.m_guc;
        break;
    case CommonHeader::headerType_topologicallyScopedBroadcast:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_singleHop:
            m_shb = other.m_shb;
            break;
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_multiHop:
            m_tsb= other.m_tsb;
            break;
        default:
            break;
        }
        break;
    case CommonHeader::headerType_locationService:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeLocationService_Request:
            m_lsRequest = other.m_lsRequest;
            break;
        case CommonHeader::headerSubTypeLocationService_Reply:
            m_lsReply= other.m_lsReply;
            break;
        default:
            break;
        }
        break;
    case CommonHeader::headerType_any:
    default:
        break;
    }

    return *this;
}

BeaconPacket PacketBuffersEntry::beaconPacket()
{
    if(m_ch.headerType() == CommonHeader::headerType_beacon)
    {
        return m_beac;
    }
    else
        return BeaconPacket();
}

LSRequestPacket PacketBuffersEntry::lsRequestPacket()
{
    if(m_ch.headerType() == CommonHeader::headerType_locationService && m_ch.headerSubType() == CommonHeader::headerSubTypeLocationService_Request)
    {
        return m_lsRequest;
    }
    else
        return LSRequestPacket();
}

LSReplyPacket PacketBuffersEntry::lsReplyPacket()
{
    if(m_ch.headerType() == CommonHeader::headerType_locationService && m_ch.headerSubType() == CommonHeader::headerSubTypeLocationService_Reply)
    {
        return m_lsReply;
    }
    else
        return LSReplyPacket();
}

GACPacket PacketBuffersEntry::gacPacket()
{
    if(m_ch.headerType() == CommonHeader::headerType_geoAnycast)
    {
        return m_gac;
    }
    else
        return GACPacket();
}

GBCPacket PacketBuffersEntry::gbcPacket()
{
    if(m_ch.headerType() == CommonHeader::headerType_geoBroadcast)
    {
        return m_gbc;
    }
    else
        return GBCPacket();
}

GUCPacket PacketBuffersEntry::gucPacket()
{
    if(m_ch.headerType() == CommonHeader::headerType_geoUnicast)
    {
        return m_guc;
    }
    else
        return GUCPacket();
}

SHBPacket PacketBuffersEntry::shbPacket()
{
    if(m_ch.headerType() == CommonHeader::headerType_topologicallyScopedBroadcast && m_ch.headerSubType() == CommonHeader::headerSubTypeTopologicallyScopedBroadcast_singleHop)
    {
        return m_shb;
    }
    else
        return SHBPacket();
}

TSBPacket PacketBuffersEntry::tsbPacket()
{
    if(m_ch.headerType() == CommonHeader::headerType_topologicallyScopedBroadcast && m_ch.headerSubType() == CommonHeader::headerSubTypeTopologicallyScopedBroadcast_multiHop)
    {
        return m_tsb;
    }
    else
        return TSBPacket();
}