//////////////////////////////////////////////////////////////////////////////////// /// /// \brief If the IsLargeDataSet method returns true, then this method is used /// to convert message payload data into a multi-packet stream /// according to rules defined by the JAUS standards documents. /// /// This method should only be overloaded if your message contains data /// larger than Header::MaxSize - Header::MinSize (e.g. image data) and you wish /// to optimize how data is written. By default, this method calls the /// WriteMessageBody method to generate a single large byte array, which is then /// broken up into a Packet::List for the transport layer. /// /// \param[out] stream Multi-packet stream containing serialized message /// following rules of large data sets. /// \param[out] streamHeaders Headers for packet in the stream. /// \param[in] maxPayloadSize This is the maximum packet size including /// payload, does not include transport, General /// Transport Header, or Message Code (USHORT). /// \param[in] transportHeader Additional transport header data to precede /// the general transport header of each packet. /// \param[in] startingSequenceNumber Sequence number to use for packets. /// \param[in] broadcastFlags Values to use to signify if message should be /// sent using any broadcast options (e.g. /// multicast). 0 = no options, 1 = local broadcast, /// 2 = global broadcast. /// /// \return FAILURE on error, otherwise number of packets written. /// //////////////////////////////////////////////////////////////////////////////////// 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; }
//////////////////////////////////////////////////////////////////////////////////// /// /// \brief Converts the message data into JUDP packets for transmission. /// /// \param[in] message Message to convert/serialize. /// \param[out] stream Packets to send. /// \param[out] streamHeaders Header info for packets. /// \param[in] startingSequenceNumber Sequence number to use for packets. /// \param[in] broadcastFlags Values to use to signify if message should be /// sent using any broadcast options (e.g. /// multicast). 0 = no options, 1 = local broadcast, /// 2 = global broadcast. /// /// \return True on success, false on failure. /// //////////////////////////////////////////////////////////////////////////////////// bool JUDP::SerializeMessage(const Message* message, Packet::List& stream, Header::List& streamHeaders, const UShort startingSequenceNumber, const int broadcastFlags) const { Packet packet; Header header; // Pre-allocate memory. packet.Reserve(mMaxPayloadSize + OverheadSizeBytes); // Clear stream/headers. stream.clear(); streamHeaders.clear(); // If the message is a large data set, create a multi-packet stream. if(message->IsLargeDataSet(mMaxPayloadSize)) { return message->WriteLargeDataSet(stream, streamHeaders, mMaxPayloadSize, &mTransportHeader, startingSequenceNumber) > 0; } // Single packet. else if(message->Write(packet, header, &mTransportHeader, true, startingSequenceNumber) > 0) { stream.push_back(packet); streamHeaders.push_back(header); return true; } return false; }