connectionSet.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_SET_H
#define CO_CONNECTION_SET_H

#include <co/connectionListener.h> // base class

#include <co/base/buffer.h> // member
#include <co/base/refPtr.h> // member
#include <co/base/thread.h> // for EQ_TS_VAR

#ifndef _WIN32
#  include <poll.h>
#endif

namespace co
{
    class EventConnection;
    class ConnectionSetThread;

    class ConnectionSet : public ConnectionListener
    {
    public:
        enum Event
        {
            EVENT_NONE = 0,        
            EVENT_CONNECT,         
            EVENT_DISCONNECT,      
            EVENT_DATA,            
            EVENT_TIMEOUT,         
            EVENT_INTERRUPT,       
            EVENT_ERROR,           
            EVENT_SELECT_ERROR,    
            EVENT_INVALID_HANDLE,  
            EVENT_ALL
        };

        CO_API ConnectionSet();
        CO_API ~ConnectionSet();

        CO_API void addConnection( ConnectionPtr connection );
        CO_API bool removeConnection( ConnectionPtr connection );
        CO_API void clear();
        size_t getSize()  const { return _connections.size(); }
        bool   isEmpty() const { return _connections.empty(); }

        const Connections& getConnections() const{ return _allConnections; }

        CO_API Event select( const int timeout = -1 );

        CO_API void interrupt();

        void setDirty();

        int           getError()     { return _error; }
        ConnectionPtr getConnection(){ return _connection; }

    private:
 
#ifdef _WIN32
        typedef ConnectionSetThread Thread;
        typedef std::vector< ConnectionSetThread* > Threads;
        Threads _threads;

        Thread* _thread;

        union Result
        {
            Connection* connection;
            Thread* thread;
        };

#else
        union Result
        {
            Connection* connection;
        };
#endif

        base::Lock _mutex;

        Connections _allConnections;

        Connections _connections;

        // Note: std::vector had to much overhead here
#ifdef _WIN32
        base::Buffer< HANDLE > _fdSet;
#else
        base::Buffer< pollfd > _fdSetCopy; // 'const' set
        base::Buffer< pollfd > _fdSet;     // copy of _fdSetCopy used to poll
#endif
        base::Buffer< Result > _fdSetResult;

        base::RefPtr< EventConnection > _selfConnection;

        // result values
        ConnectionPtr _connection;
        int           _error;

        bool _dirty;

        bool _setupFDSet();
        bool _buildFDSet();
        virtual void notifyStateChanged( Connection* ) { _dirty = true; }

        Event _getSelectResult( const uint32_t index );
        EQ_TS_VAR( _selectThread );
    };

    CO_API std::ostream& operator << ( std::ostream& os, 
                                          const ConnectionSet* set );
    CO_API std::ostream& operator << ( std::ostream& os, 
                                          const ConnectionSet::Event event );
}

#endif // CO_CONNECTION_SET_H