connection.h

/* Copyright (c) 2005-2009, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQNET_CONNECTION_H
#define EQNET_CONNECTION_H

#include <eq/net/connectionDescription.h> // member
#include <eq/net/packets.h>               // used in inline method
#include <eq/net/types.h>                 // ConnectionVector type

#include <eq/base/base.h>
#include <eq/base/refPtr.h>
#include <eq/base/referenced.h>
#include <eq/base/scopedMutex.h>
#include <eq/base/lock.h>

#include <sys/types.h>
#include <string.h>
#include <vector>

#ifdef WIN32_API
#  include <malloc.h>     // for alloca()
#endif

#ifdef WIN32
#  define EQ_DEFAULT_PORT (4242)
#else
#  define EQ_DEFAULT_PORT (4242 + getuid())
#endif

namespace eq
{
namespace net
{
    class ConnectionListener;
    enum ConnectionType;

    class Connection : public base::Referenced, public base::NonCopyable
    {
    public:
        enum State 
        {
            STATE_CLOSED,     
            STATE_CONNECTING, 
            STATE_CONNECTED,  
            STATE_LISTENING   
        };

        EQ_EXPORT static ConnectionPtr create( ConnectionDescriptionPtr 
                                                   description );

        State getState() const { return _state; }

        bool isClosed() const { return _state == STATE_CLOSED; }

        bool isConnected() const { return _state == STATE_CONNECTED; }

        bool isListening() const { return _state == STATE_LISTENING; }

        EQ_EXPORT void setDescription( ConnectionDescriptionPtr description );

        EQ_EXPORT ConnectionDescriptionPtr getDescription() const;


        virtual bool connect() { return false; }
        
        virtual bool listen() { return false; }

        virtual void close(){};

        void addListener( ConnectionListener* listener );

        void removeListener( ConnectionListener* listener );

        virtual void acceptNB() { EQUNIMPLEMENTED; }

        virtual ConnectionPtr acceptSync()
            { EQUNIMPLEMENTED; return 0; }


        EQ_EXPORT void recvNB( void* buffer, const uint64_t bytes );

        EQ_EXPORT bool recvSync( void** buffer, uint64_t* bytes );

        void getRecvData( void** buffer, uint64_t* bytes )
            { *buffer = _aioBuffer; *bytes = _aioBytes; }

        virtual void readNB( void* buffer, const uint64_t bytes ) = 0;

        virtual int64_t readSync( void* buffer, const uint64_t bytes ) = 0;

        EQ_EXPORT bool send( const void* buffer, const uint64_t bytes, 
                             const bool isLocked = false );

        void lockSend() const   { _sendLock.set(); }
        void unlockSend() const { _sendLock.unset(); }
            
        bool send( const Packet& packet )
            { return send( &packet, packet.size); }

        bool send( Packet& packet, const std::string& string )
            { return send( packet, string.c_str(), string.size()+1 ); }

        template< typename T >
        bool send( Packet& packet, const std::vector<T>& data );

        EQ_EXPORT bool send( Packet& packet, const void* data,
                             const uint64_t size );

        static bool send( const ConnectionVector& connections,
                          const Packet& packet, const bool isLocked = false );
        static bool send( const ConnectionVector& connections, Packet& packet,
                          const void* data, const uint64_t size,
                          const bool isLocked = false );

#ifdef WIN32
        typedef HANDLE Notifier;
#else
        typedef int Notifier;
#endif

        virtual Notifier getNotifier() const { return 0; }

    protected:
        Connection();
        virtual ~Connection();

        void _fireStateChanged();

        virtual int64_t write( const void* buffer, const uint64_t bytes ) = 0;

        State                    _state; 
        ConnectionDescriptionPtr _description; 

        mutable base::Lock _sendLock;

    private:
        void*         _aioBuffer;
        uint64_t      _aioBytes;

        std::vector< ConnectionListener* > _listeners;

        friend class PairConnection; 
    };

    std::ostream& operator << ( std::ostream&, const Connection* );

#   include "connection.ipp" // template implementation

}
}
#endif //EQNET_CONNECTION_H