RTFXParcel.h

#ifndef __RTFX_PARCEL__
#define __RTFX_PARCEL__

#include <iostream>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <time.h>
#include <vector>

#include "RTFXDebug.h"
#include "RTFXHelpers.h"


using namespace std;

namespace RTFX
{
    /*  PLANNING:
        Format of the message header:
            [16] boost::uuids::uuid of the message SENDER
            [16] boost::uuids::uuid id of message?
            [16] a string name of the mailbox (chatroom) where the data will be deposited
            [1]  a flag indicating if the data is or is not compressed, 0=no, 1=yes
            [7]  empty bits for now

        When the stream has been received, it is assigned a timestamp (the arrival time).
        If there are no messages currently being sent:
            Take out a lock on the mailbox access:
                - the message is forwarded to the other clients
                - then, the message is decoded and the contents merged with the mailbox's copy
                  of the scene data [this could have significant memory requirements, keeping 
                  a copy of the scene at the server, but, it allows re-connections, new connections
                  etc. to acquire a complete copy without bugging the sourcing clients]
            Release the lock on the mailbox.

        If there is a message currently being sent:
            Take out a lock on the waiting message structure
                - decode the current message and merge it with the "waiting" message structure
            Release the lock

        When the message is sent:
            - wait for the waiting message to become available
            Take out a lock on the waiting message structure
                - encode it into a message stream
                - delete the data
            Release lock
            Send message
    */

    class RTFXAPI RTFXParcel
    {
        public:

            RTFXParcel() { isHeaderDecoded = false; }

            ~RTFXParcel()
            {
            }

            void CreateHeader( boost::uuids::uuid _messageID, boost::uuids::uuid _senderID, char * _mailboxID, 
                               unsigned int _messageSize, RTFXBIGINT _packetNumber, RTFXBIGINT _packetCount,
                               bool _isCompressed, unsigned int _compressionType, bool _keepData, bool _isRTFX, bool _isBinary )
            {
                SetMessageID( _messageID );
                SetSenderID( _senderID );
                SetMailboxID( _mailboxID );
                SetMessageSize( _messageSize );
                SetPacketNumber( _packetNumber );
                SetNumberOfPackets( _packetCount );
                SetCompressed( _isCompressed );
                SetCompressionType( _compressionType );
                SetKeepData( _keepData );
                SetRTFXData( _isRTFX );
                SetIsBinary( _isBinary );

                EncodeHeader();
                isHeaderDecoded = false;
            }
                
            void EncodeUUID( boost::uuids::uuid _encodeMe, unsigned int _startingAt )
            {
                for ( unsigned int i = 0; i < 16; i ++ )
                {
                    data[ _startingAt + i ] = _encodeMe.data[i];
                }
            }

            void EncodeString( char * _encodeMe, unsigned int _startingAt, unsigned int _length )
            {
                for ( unsigned int i = 0; i < _length; i ++ )
                {
                    data[ _startingAt + i ] = _encodeMe[i];
                }
            }

            void EncodeInteger( unsigned int _encodeMe, unsigned int _startingAt )
            {
                char * ptr_ = &data[_startingAt];
                memcpy( ptr_, &_encodeMe, sizeof( unsigned int ) );
            }

            void EncodeLong( RTFXBIGINT _encodeMe, RTFXBIGINT _startingAt )
            {
                char * ptr_ = &data[_startingAt];
                memcpy( ptr_, &_encodeMe, sizeof( RTFXBIGINT ) );
            }

            void EncodeBoolean( bool _encodeMe, unsigned int _startingAt )
            {
                if ( _encodeMe )
                    data[_startingAt] = 124;
                else
                    data[_startingAt] = 106;
            }

            void CreateParcel( boost::uuids::uuid _senderID, boost::uuids::uuid _msgID, char * _mailboxID,
                               unsigned int _msgSize, RTFXBIGINT _pNum, RTFXBIGINT _pCount, bool _compressed,
                               unsigned int _compressionType, bool _keepData, bool _isRTFX, bool _isBinary, const char * _msg )
            {
                SetSenderID( _senderID );
                SetMessageID( _msgID );
                SetMailboxID( _mailboxID );
                SetMessageSize( _msgSize );
                SetPacketNumber( _pNum );
                SetNumberOfPackets( _pCount );
                SetCompressed( _compressed );
                SetMessageData( _msg, _msgSize );
                SetCompressionType( _compressionType );
                SetKeepData( _keepData );
                SetRTFXData( _isRTFX );
                SetIsBinary( _isBinary );

                //debug( ostringstream().flush() << "RTFXParcel::CreateParcel: message data - " << _msg << endl );
                EncodeHeader();
            }

            void CreateParcel( boost::uuids::uuid _senderID, boost::uuids::uuid _msgID, char * _mailboxID,
                               unsigned int _msgSize, RTFXBIGINT _pNum, RTFXBIGINT _pCount, bool _compressed,
                               unsigned int _compressionType, bool _keepData, bool _isRTFX, bool _isBinary, char * _msg )
            {
                SetSenderID( _senderID );
                SetMessageID( _msgID );
                SetMailboxID( _mailboxID );
                SetMessageSize( _msgSize );
                SetPacketNumber( _pNum );
                SetNumberOfPackets( _pCount );
                SetCompressed( _compressed );
                SetMessageData( _msg, _msgSize );
                SetCompressionType( _compressionType );
                SetKeepData( _keepData );
                SetIsBinary( _isBinary );
                SetRTFXData( _isRTFX );

                //debug( ostringstream().flush() << "RTFXParcel::CreateParcel: message data - " << _msg << endl );
                EncodeHeader();
            }

            void EncodeHeader()
            {
                EncodeUUID( senderID, 0 );
                EncodeUUID( messageID, 16 );
                EncodeString( ( char * )mailboxID, 32, 16 );
                EncodeInteger( messageSize, 48 );
                EncodeLong( packetNumber, 52 );
                EncodeLong( numberOfPackets, 60 );
                EncodeBoolean( isCompressed, 68 );
                EncodeInteger( compressionType, 69 );
                EncodeBoolean( keepDataAtServer, 73 );
                EncodeBoolean( isDataRTFX, 74 );
                EncodeBoolean( isBinary, 75 );
            }

            void DecodeUUID( boost::uuids::uuid &_decodeTo, unsigned int _startingAt )
            {
                for ( unsigned int i = 0; i < 16; i ++ )
                {
                    _decodeTo.data[i] = data[ _startingAt + i ];
                }
            }

            void DecodeString( char * _decodeTo, unsigned int _startingAt, unsigned int _length )
            {
                for ( unsigned int i = 0; i < _length; i ++ )
                {
                    _decodeTo[i] = data[ _startingAt + i ];
                }
            }

            void DecodeLong( RTFXBIGINT &_decodeTo, RTFXBIGINT _startingAt )
            {
                char * ptr_ = &data[_startingAt];
                RTFXBIGINT ret_;
                memcpy( &ret_, ptr_, sizeof( RTFXBIGINT ) );
                _decodeTo = ret_;
            }

            void DecodeInteger( unsigned int &_decodeTo, unsigned int _startingAt )
            {
                char * ptr_ = &data[_startingAt];
                unsigned int ret_;
                memcpy( &ret_, ptr_, sizeof( unsigned int ) );
                _decodeTo = ret_;
            }

            void DecodeBoolean( bool &_decodeTo, unsigned int _startingAt )
            {
                if ( data[_startingAt] == 106 )
                    _decodeTo = false;
                else
                    _decodeTo = true;
            }

            void DecodeHeader()
            {
                DecodeUUID( senderID, 0 );
                DecodeUUID( messageID, 16 );
                DecodeString( ( char * )mailboxID, 32, 16 );
                DecodeInteger( messageSize, 48 );
                DecodeLong( packetNumber, 52 );
                DecodeLong( numberOfPackets, 60 );
                DecodeBoolean( isCompressed, 68 );
                DecodeInteger( compressionType, 69 );
                DecodeBoolean( keepDataAtServer, 73 );
                DecodeBoolean( isDataRTFX, 74 );
                DecodeBoolean( isBinary, 75 );

                verbose( ostringstream().flush() << "RTFXParcel::DecodeHeader: message size - " << messageSize << endl );
                isHeaderDecoded = false;
            }

            bool IsHeaderDecoded() { return isHeaderDecoded; }

            static unsigned int GetMaxBodyLength() { return maxBodyLength; }

            static unsigned int GetHeaderLength() { return headerLength; }

            static unsigned int GetMaximumLength() { return maximumLength; }

            void SetMessageID( boost::uuids::uuid _mid ) { messageID = _mid; }

            boost::uuids::uuid GetMessageID() { return messageID; }

            void SetSenderID( boost::uuids::uuid _sid ) { senderID = _sid; }

            boost::uuids::uuid GetSenderID() { return senderID; }

            void SetMailboxID( char * _mid )
            {
                memcpy( mailboxID, _mid, 16 * sizeof( char ) );
            }

            char * GetMailboxID() { return ( char * )mailboxID; }

            void SetMessageSize( unsigned int _ms ) { messageSize = _ms; }

            unsigned int GetMessageSize() { return messageSize; }

            void SetPacketNumber( RTFXBIGINT _pn ) { packetNumber = _pn; }

            RTFXBIGINT GetPacketNumber() { return packetNumber; }

            void SetNumberOfPackets( RTFXBIGINT _pc ) { numberOfPackets = _pc; }

            RTFXBIGINT GetNumberOfPackets() { return numberOfPackets; }

            void SetCompressed( bool _ic ) { isCompressed = _ic; }

            bool GetCompressed() { return isCompressed; }

            void SetMessageData( char * _data, unsigned int _length )
            {
                for ( unsigned int i = 0; i < _length; i ++ )
                {
                    data[ headerLength + i ] = _data[i];
                }
            }
            void SetMessageData( const char * _data, unsigned int _length )
            {
                for ( unsigned int i = 0; i < _length; i ++ )
                {
                    data[ headerLength + i ] = _data[i];
                }
            }

            char * GetMessageData()
            {
                return ( data + headerLength );
            }

            char * GetData()
            {
                return data;
            }

            void SetCompressionType( unsigned int _type )
            {
                // use default of ZLIB if specified type is invalid
                //if ( _type > 3 ) _type = 1;
                compressionType = _type;
            }

            unsigned int GetCompressionType()
            {
                return compressionType;
            }

            void SetKeepData( bool _store )
            {
                keepDataAtServer = _store;
            }

            bool GetKeepData()
            {
                return keepDataAtServer;
            }

            void SetRTFXData( bool _value )
            {
                isDataRTFX = _value;
            }

            bool GetRTFXData()
            {
                return isDataRTFX;
            }

            void SetIsBinary( bool _isBinary )
            {
                isBinary = _isBinary;
            }

            bool GetIsBinary()
            {
                return isBinary;
            }

        private:

            static const unsigned int maxBodyLength = 65458; //63872;

            static const unsigned int headerLength = 76;

            static const unsigned int maximumLength = 65534;

            boost::uuids::uuid senderID;    // 16

            boost::uuids::uuid messageID;   // 16

            char mailboxID[16]; // 16

            unsigned int messageSize;       // 4

            RTFXBIGINT packetNumber;        // 8

            RTFXBIGINT numberOfPackets; // 8

            bool isCompressed;              // 1

            unsigned int compressionType; // 4

            bool keepDataAtServer;  // 1

            bool isBinary; // 1

            bool isDataRTFX; // 1

            char data[maximumLength];

            clock_t arrivalTime;

            bool isHeaderDecoded;
    };

    void CreateParcelList( vector<RTFXParcel> &_parcelList, boost::uuids::uuid _senderID, char * _mailboxName, string &_data, bool _isCompressed, unsigned int _compressionType, bool _keepDataAtServer, bool _isDataRTFX, bool _isBinary );

    string ReAssembleParcelMessageFromList( vector<RTFXParcel> &_parcelList );
}

#endif