connection.h

/* Copyright (c) 2005-2011, 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 CO_CONNECTION_H
#define CO_CONNECTION_H

#include <co/connectionType.h>        // enum
#include <co/packets.h>               // used in inline method
#include <co/types.h>                 // Connections type
#include <co/api.h>

#include <co/base/refPtr.h>
#include <co/base/referenced.h>   // base class
#include <co/base/lock.h>

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

#ifdef _WIN32
#  define EQ_DEFAULT_PORT (4242)
#  include <malloc.h>
#else
#  define EQ_DEFAULT_PORT (4242 + getuid())
#endif

namespace co
{
    class ConnectionDescription;
    class ConnectionListener;

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

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

        CO_API void setDescription( ConnectionDescriptionPtr description );

        CO_API ConnectionDescriptionPtr getDescription() const;

        bool operator == ( const Connection& rhs ) 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; }


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

        CO_API bool recvSync( void** buffer, uint64_t* bytes,
                                 const bool block = true );

        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,
                                  const bool block ) = 0;

        CO_API 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 );

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

        static CO_API bool send( const Connections& connections,
                                 const Packet& packet,
                                 const bool isLocked = false );
        static CO_API bool send( const Connections& connections,
                                 Packet& packet, const void* data,
                                 const uint64_t size,
                                 const bool isLocked = false );
        static bool CO_API send( const Connections& connections, 
                                 Packet& packet, const void* const* items, 
                                 const uint64_t* itemSizes,
                                 const size_t nItems );

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

        virtual void finish() { EQUNIMPLEMENTED; }

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

        virtual Notifier getNotifier() const = 0;

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

        void _fireStateChanged();

        State                    _state; 
        ConnectionDescriptionPtr _description; 

        mutable base::Lock _sendLock;

        enum ReadStatus
        {
            READ_TIMEOUT = -2,
            READ_ERROR   = -1
            // >= 0: nBytes read
        };

    private:
        void*         _aioBuffer;
        uint64_t      _aioBytes;

        std::vector< ConnectionListener* > _listeners;
    };

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

#   include "connection.ipp" // template implementation

}
#endif //CO_CONNECTION_H