jaus++/2.0/src/jaus/core/message.cpp

Go to the documentation of this file.

#include "jaus/core/message.h"
#include "jaus/core/transport/largedataset.h"
#include <iostream>

using namespace JAUS;


Message::Message(const UShort messageCode,
                 const Address& dest,
                 const Address& src) :  mPriority(Priority::Standard),
                                        mMessageCode(messageCode),
                                        mSourceID(src),
                                        mDestinationID(dest)
{
}


Message::~Message()
{
}


int Message::SetPriority(const Byte priority)
{
    if(priority <= Priority::SafetyCritical)
    {
         mPriority = priority;
         return OK;
    }
    return FAILURE;
}


int Message::SetSourceID(const Address& src)
{
    if(src.IsValid() && !src.IsBroadcast())
    {
        mSourceID = src;
        return OK;
    }
    return FAILURE;
}


int Message::SetDestinationID(const Address& dest)
{
    if(dest.IsValid())
    {
        mDestinationID = dest;
        return OK;
    }
    return FAILURE;
}


int Message::SwapSourceAndDestination()
{
    if(mDestinationID.IsBroadcast() == false)
    {
        Address temp = mDestinationID;
        mDestinationID = mSourceID;
        mSourceID = temp;
        return OK;
    }
    return FAILURE;
}


void Message::CopyHeaderData(const Message* msg)
{
    if(this != msg)
    {
        mSourceID = msg->mSourceID;
        mDestinationID = msg->mDestinationID;
        mPriority = msg->mPriority;
    }
}


void Message::ClearMessageHeader()
{
    mSourceID.Clear();
    mDestinationID.Clear();
    mPriority = Priority::Standard;
}


void Message::ClearMessage()
{
    mSourceID.Clear();
    mDestinationID.Clear();
    mPriority = Priority::Standard;
    ClearMessageBody();
}


void Message::Print() const
{
    std::cout << GetMessageName() << " - SRC[" << mSourceID.ToString() << "] DEST[" << mDestinationID.ToString() << "]" << std::endl;
    PrintMessageBody();
}


bool Message::IsResponseToMessage(const Message *requestingMessage) const
{
    if(mMessageCode == requestingMessage->GetMessageCodeOfResponse() &&
       mSourceID == requestingMessage->mDestinationID)
    {
        return true;
    }
    return false;
}


int Message::Write(Packet& packet, 
                   Header& header,
                   const Packet* transportHeader, 
                   const bool clearPacket,
                   const UShort startingSequenceNumber,
                   const Byte broadcastFlag) const
{
    int total = 0;
    //  Build JAUS header data.
    header.mSourceID = mSourceID;
    header.mDestinationID = mDestinationID;
    header.mPriorityFlag = mPriority;
    header.mControlFlag = Header::DataControl::Single;
    header.mCompressionFlag = Header::Compression::None;
    header.mSequenceNumber = startingSequenceNumber;
    header.mBroadcastFlag = broadcastFlag;

    //  Clear out any previous message data.
    if(clearPacket)
    {
        packet.Clear();
        packet.Reserve(Header::MinSize + USHORT_SIZE + 1);
    }
    unsigned int writePos = packet.GetWritePos();
    
    if(transportHeader && transportHeader->Length() > 0)
    {
        writePos += (unsigned int)packet.Write(*transportHeader);
    }
    //  The first thing we must do is advance
    //  the write position to after the JAUS Header
    //  data.  The header is not written first because
    //  we do not know how large the message body will
    //  be yet.
    packet.SetLength(writePos + Header::PayloadOffset);
    packet.SetWritePos(writePos + Header::PayloadOffset);
    total += packet.Write(mMessageCode);
    int payloadSize = 0;
    if( (payloadSize = WriteMessageBody(packet)) >= 0)
    {
        total += payloadSize;
        // Check for large data set.
        if(total + Header::MinSize > Header::MaxPacketSize)
        {
            return FAILURE;
        }
        else
        {
            header.mSize = total + Header::MinSize;
            packet.SetWritePos(writePos);
            // Go back, and re-write the header since 
            // we now know the size of the message.
            if(header.Write(packet))
            {
                // Set the write position to the end of message we just wrote.
                packet.SetWritePos(writePos + header.mSize);
                //  Return the number of bytes written.
                if(transportHeader)
                {
                    return header.mSize + transportHeader->Length();
                }
                else
                {
                    return header.mSize;
                }
            }
        }
    }

    return FAILURE;
}


int Message::WriteLargeDataSet(Packet::List& stream,
                               Header::List& streamHeaders,
                               const UShort maxPayloadSize,
                               const Packet* transportHeader,
                               const UShort startingSequenceNumber,
                               const Byte broadcastFlags) const
{
    Header header;
    header.mDestinationID = mDestinationID;
    header.mSourceID = mSourceID;
    header.mPriorityFlag = mPriority;
    header.mBroadcastFlag = broadcastFlags;

    stream.clear();
    streamHeaders.clear();
    Packet* temp = ((Packet *)(&mStreamPayload));
    temp->Clear();
    if(IsLargeDataSet() && WriteMessageBody(*temp) >= 0)
    {
        LargeDataSet::CreateLargeDataSet(header, 
                                         mMessageCode, 
                                         *temp, 
                                         stream, 
                                         streamHeaders, 
                                         transportHeader, 
                                         maxPayloadSize,
                                         startingSequenceNumber);
        return (int)stream.size();
    }
    return FAILURE;
}


int Message::Read(const Packet& packet,
                  const Packet* transportHeader)
{
    unsigned int readPos = packet.GetReadPos();
    
    Header header;
    int total = 0;
    
    if(transportHeader && transportHeader->Length() > 0)
    {
        packet.SetReadPos(readPos + transportHeader->Length());
        total = transportHeader->Length();
    }
    
    // Try read message transport header data
    if(header.Read(packet) > 0)
    {
        UShort messageCode;
        total += Header::MinSize;
        total += packet.Read(messageCode);
        // Verify this is a message we can actually read.
        if(messageCode == mMessageCode)
        {
            int payloadSize = 0;
            if( (payloadSize = ReadMessageBody(packet)) >= 0)
            {
                total += payloadSize;
                mSourceID = header.mSourceID;
                mDestinationID = header.mDestinationID;
                mPriority = header.mPriorityFlag;
                return total;
            }
        }
    }
    
    // Reset read position on failure.
    packet.SetReadPos(readPos);
    
    return FAILURE;
}


int Message::ReadLargeDataSet(const Packet::List& stream,
                              const Packet* transportHeader)
{
    Header header;
    UShort messageCode;
    if(LargeDataSet::MergeLargeDataSet(header, messageCode, mStreamPayload, stream, transportHeader))
    {
        if(ReadMessageBody(mStreamPayload))
        {
            mSourceID = header.mSourceID;
            mDestinationID = header.mDestinationID;
            mPriority = header.mPriorityFlag;
            return (int)stream.size();
        }
    }
    return FAILURE;
}


int Message::ReadLargeDataSet(const std::map<UShort, Packet>& stream,
                              const Packet* transportHeader)
{
    Header header;
    UShort messageCode;
    if(LargeDataSet::MergeLargeDataSet(header, messageCode, mStreamPayload, stream, transportHeader))
    {
        if(ReadMessageBody(mStreamPayload))
        {
            mSourceID = header.mSourceID;
            mDestinationID = header.mDestinationID;
            mPriority = header.mPriorityFlag;
            return (int)stream.size();
        }
    }
    return FAILURE;
}

/*  End of File */