RTFXPeer.h

Go to the documentation of this file.

#ifndef __RTFX_PEER__
#define __RTFX_PEER__

#include "RTFXPeerPostOffice.h"
#include "RTFXPeerSession.h"
#include "RTFXBoostIncludes.h"

namespace RTFX
{

    typedef boost::shared_ptr<RTFXPeerSession> RTFXPeerSessionPtr;

    class RTFXAPI RTFXPeer
    {
        public:

            RTFXPeer();

            ~RTFXPeer();

            void Start( string _hostname, string _connectionHostname, unsigned int _port = 0 );

            bool HasBeenStarted() { return hasBeenStarted; }

            void ConnectToPeer( string _hostname );

            void ConnectToPeer( boost::asio::io_service &_ioService, tcp::resolver::iterator &_endpointIterator );

            void DisconnectFromPeers();

            void Close();

            void StartAccepting();

            void HandleAccept( RTFXPeerSessionPtr _session, const boost::system::error_code &_error );

            RTFXData * GetData() { return mailbox->GetPointerToMailbox(); };

            void SendUpdates();

            void Send( RTFXData * _ptr );

            void Send( string &_data, bool _isDataRTFX );

            bool IsConnected() { return isConnected; }

            bool CheckForUpdates();

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

            bool GetServerKeepData()
            {
                return keepDataAtServer;
            }

            void SetHostname( string _hostname )
            {
                hostname = _hostname;
            }

            string GetHostname()
            {
                return hostname;
            }

            void AddHostname( string _hostname )
            {
                debug( ostringstream().flush() << "RTFXPeer::AddHostname: adding hostname " << _hostname << endl );
                if ( connectionList.find( _hostname ) == connectionList.end() )
                    connectionList[ _hostname ] = 1;
                else
                    connectionList[ _hostname ] = connectionList[ _hostname ] + 1;
            }

            void DeleteHostname( string _hostname )
            {
                debug( ostringstream().flush() << "RTFXPeer::DeleteHostname: deleting hostname " << _hostname << endl );

                if ( connectionList.find( _hostname ) != connectionList.end() )
                    connectionList[ _hostname ] --;
            }

            void SetConnectionHostname( string _chostname )
            {
                connectionHostname = _chostname;
            }

            string GetConnectionHostname()
            {
                return connectionHostname;
            }

            string GetHostnameData()
            {
                string hostnameData_ = "";
                stringstream ss_( stringstream::in | stringstream:: out );

                map<string, int>::iterator iter_ = connectionList.begin();
                while ( iter_ != connectionList.end() )
                {
                    ss_ << (*iter_).first << "," << (*iter_).second << "\n";
                    iter_ ++;
                }

                hostnameData_ = ss_.str();
                return hostnameData_;
            }

            bool HasNewDataArrived() 
            { 
                return isNewDataAvailable;
            }

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

            void DeleteObjectEverywhere( RTFXObject * _obj );

            bool IsCustomDataAvailable()
            {
                if ( mailbox->GetCustomDataCount() > 0 ) return true;
                return false;
            }

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

            COMPRESSIONTYPE GetDefaultCompressionType() { return compressionType; }

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

            bool GetArchiveType()
            {
                return isBinaryData;
            }

        private:

            void StartServer( unsigned int _port );

            void ConnectToPeer( string _connectionHostname, string _port );

            int CountKnownConnections()
            {
                map<string, int>::iterator iter_ = connectionList.begin();
                int count_ = 0;

                while ( iter_ != connectionList.end() )
                {
                    count_ += (*iter_).second;
                    iter_ ++;
                }
                return count_;
            }

            void ResetKnownConnections()
            {
                connectionList.clear();
                {
                    map<string,int> tmp_;
                    tmp_.swap( connectionList );
                }
            }


            boost::thread * serverThread;
            boost::thread * clientThread;

            map<string, int> connectionList;

            bool isClosing;

            bool isDeletePeer;

            bool hasDisconnectedFromPeer;

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

            string hostname;

            string connectionHostname;

            bool keepDataAtServer;

            COMPRESSIONTYPE compressionType;

            boost::mutex peerLock;

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

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

            void DoWrite( RTFXParcel _msg );

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

            void DoClose();

            void Write( const RTFXParcel& _msg );

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

            boost::asio::io_service ioService;

            boost::asio::io_service clientIoService;

            tcp::acceptor * tcpAcceptor;

            RTFXPeerPostOffice postOffice;

            tcp::socket socket;

            RTFXParcel readParcel;

            RTFXParcelQueue writeParcels;

            RTFXMailbox * mailbox;

            boost::uuids::uuid id;

            char * mailboxName;

            AXISFRAME localFrame;

            bool isConnected;

            bool hasMailboxNameBeenSent;

            bool hasIdBeenReceived;

            bool isNewDataAvailable;

            bool isNewRawDataAvailable;

            bool isReconnecting;

            unsigned int port;
            string portString;

            bool hasBeenStarted;

            bool isBeginDeleted;

            bool isBinaryData;
    };
}

#endif