connection.h

/* Copyright (c) 2005-2008, Stefan Eilemann <eile@equalizergraphics.com> 
   All rights reserved. */

#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/spinLock.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 EQ_EXPORT Connection : public base::Referenced
    {
    public:
        enum State
        {
            STATE_CLOSED,
            STATE_CONNECTING,
            STATE_CONNECTED,
            STATE_LISTENING
        };

        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; }

        void setDescription( ConnectionDescriptionPtr description );

        ConnectionDescriptionPtr getDescription() const;
        //*}

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

        virtual ConnectionPtr accept() { return 0; }

        virtual ConnectionPtr accept( const int timeout );

        virtual void close(){};

        //*{
        void addListener( ConnectionListener* listener );

        void removeListener( ConnectionListener* listener );
        //*}


        //*{
        bool recv( void* buffer, const uint64_t bytes );

        void lockSend() const   { _sendLock.set(); }
        void unlockSend() const { _sendLock.unset(); }
            
        bool send( const void* buffer, const uint64_t bytes, 
                   const bool isLocked = false ) const;

        bool send( const Packet& packet ) const
            { return send( &packet, packet.size); }

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

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

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

        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 ReadNotifier;
        enum SelectResult
        {
            SELECT_TIMEOUT = WAIT_TIMEOUT,
            SELECT_ERROR   = WAIT_FAILED,
        };
#else
        typedef int ReadNotifier;
        enum SelectResult
        {
            SELECT_TIMEOUT = 0,
            SELECT_ERROR   = -1,
        };
#endif
        virtual ReadNotifier getReadNotifier() const { return 0; }

    protected:
        State                    _state; 
        ConnectionDescriptionPtr _description;

        mutable base::SpinLock _sendLock;

        std::vector< ConnectionListener* > _listeners;

        friend class PairConnection; // for access to read/write


        Connection();
        Connection(const Connection& conn);
        virtual ~Connection();

        void _fireStateChanged();

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

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

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

#   include "connection.ipp" // template implementation

}
}
#endif //EQNET_CONNECTION_H