RTFXClient.h

Go to the documentation of this file.

#ifndef __RTFX_CLIENT__
#define __RTFX_CLIENT__

#include <cstdlib>
#include <deque>
#include <iostream>
#include <vector>

#include "RTFXBoostIncludes.h"
#include "RTFXParcel.h"
#include "RTFXMailbox.h"
#include "RTFXPostOffice.h"
#include "RTFX_API.h"


using boost::asio::ip::tcp;
using namespace std;

namespace RTFX
{
    typedef std::deque<RTFXParcel> RTFXParcelQueue;
    class RTFXAPI RTFXClient
    {
        public:

            RTFXClient( boost::asio::io_service &_ioService, tcp::resolver::iterator _endpointIterator, char * _mailboxName ) : ioService( _ioService ), socket( _ioService )
            {
                compressionType = NONE;
                
                areYouKeepingDataAtServer = true;

                isBeingDeleted = false;
                isConnected = false;
                hasMailboxNameBeenSent = false;
                wasIDReceived = false;
                isNewDataAvailable = false;
                isBinaryData = true;

                mailboxName = new char[16];
                memcpy( mailboxName, _mailboxName, 16 * sizeof( char ) );

                tcp::endpoint endpoint_ = *_endpointIterator;

                socket.async_connect( endpoint_,
                    boost::bind( &RTFXClient::HandleConnect, this,
                    boost::asio::placeholders::error, ++_endpointIterator ) );
            }

            ~RTFXClient()
            {
                isBeingDeleted = true;
                delete [] mailboxName;
            };

            void Reconnect()
            {
                // TODO
            }

            void SetArchiveType( bool _isBinaryData )
            {
                isBinaryData = _isBinaryData;
            }

            bool GetArchiveType()
            {
                return isBinaryData;
            }

            void Close();

            void Send( RTFXData * _dataToSend );

            void Send( string &_dataToSend, bool _isDataRTFX );

            void SendUpdates();

            RTFXMailbox * GetMailbox() { return &mailbox; }

            RTFXData * GetData() 
            { 
                boost::lock_guard<boost::mutex> lock( clientLock );
                return mailbox.GetPointerToMailbox(); 
            }

            void SetID( boost::uuids::uuid _id ) { id = _id; }

            boost::uuids::uuid GetID() { return id; }

            void SetMailboxName( string _mailboxName )
            {
                MakeMailboxIDFromString( _mailboxName, mailboxName );
            }

        
            char * GetMailboxName() { return mailboxName; }

            void SetFrame( AXISFRAME _frame )
            {
                localFrame = _frame;
            }

            AXISFRAME GetFrame() { return localFrame; }

            void SetConnected( bool _connected ) { isConnected = _connected; }

            bool GetConnected() { return isConnected; }

            void Write( const RTFXParcel& _msg );

            bool HasNewDataArrived() { return isNewDataAvailable; }

            void SetNewDataArrived( bool _value ) { isNewDataAvailable = _value; }

            void SetDefaultCompressionType( COMPRESSIONTYPE _tmp )
            {
                compressionType = _tmp;
                mailbox.SetDefaultCompressionType( _tmp );
            }

            COMPRESSIONTYPE GetDefaultCompressionType() { return compressionType; }

            void SetServerKeepData( bool _keepData )
            {
                areYouKeepingDataAtServer = _keepData;
            }

            bool GetServerKeepData()
            {
                return areYouKeepingDataAtServer;
            }

        private:
            string dataThatWillBeSent;

            bool areYouKeepingDataAtServer;

            COMPRESSIONTYPE compressionType;

            boost::mutex clientLock;

            void HandleConnect( const boost::system::error_code &_error, tcp::resolver::iterator _endpointIterator );

            void HandleReadHeader( const boost::system::error_code &_error );

            void HandleReadBody( const boost::system::error_code &_error );

            void DoWrite( RTFXParcel _msg );

            void HandleWrite( const boost::system::error_code &_error );

            void DoClose();

            std::map<boost::uuids::uuid, vector<RTFXParcel> > parcelCollection;

            boost::asio::io_service  &ioService;

            tcp::socket socket;

            RTFXParcel readParcel;

            RTFXParcelQueue writeParcels;

            RTFXMailbox mailbox;

            boost::uuids::uuid id;

            char * mailboxName;

            AXISFRAME localFrame;

            bool isConnected;

            bool hasMailboxNameBeenSent;

            bool wasIDReceived;

            bool isNewDataAvailable;

            bool isBeingDeleted;

            bool isBinaryData;
    };
}

#endif