socklistener.h

Go to the documentation of this file.

/*
    socklibpp library
    Copyright (C) 2005  Daniel K. O. <danielosmari at users.sf.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    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 St, Fifth Floor, Boston, MA  02110-1301  USA
*/



#ifndef SOCKLISTENER_H
#define SOCKLISTENER_H

#include <list>
#include <utility>
#include <functional>

#include "sockbase.h"

namespace socklibpp {

template<class T=int>
class listener {
        typedef std::list< std::pair<sock, T> > _sock_list;
        _sock_list _sockets;

        struct Compare {
                bool operator()(const std::pair<sock, T>& a,
                                const std::pair<sock, T>& b)
                {       return a.fd == b.fd;    }
        };

public:

        void add(sock sb_, const T& data_ = T())
        {
                _sockets.push_back(std::make_pair(sb_, data_));
        }

        bool remove(sock sb_)
        {
                return _sockets.remove_if(std::bind2nd(Compare(), sb_));
        }
        
        
        unsigned size() const throw() { return _sockets.size(); }


        bool empty() const throw() { return _sockets.empty(); }


        void readable(std::list<std::pair<sock, T> >& readlist, int usec=0, int sec=0)
        {
                int i;
                typename _sock_list::const_iterator it = _sockets.begin(), first;
                fd_set readset;

                while (it!=_sockets.end()) {
                        FD_ZERO(&readset);
                        first = it;
                        // put all the sockets until FD_SETSIZE in the fd_set struct
                        for (i=0; i<FD_SETSIZE && it!=_sockets.end(); i++, ++it)
                                FD_SET(it->first.fd, &readset);

                        struct timeval tv = { sec, usec };

                        int r = ::select(FD_SETSIZE, &readset, 0, 0, &tv);

                        if (r==sock::socket_error)
                                return;

                        if (r>0)
                                for (; first!=it; ++first)
                                        if (FD_ISSET(first->first.fd, &readset))
                                                readlist.push_back(*first);
                }
        }


        template<class Op>
        void for_each_read(Op op, int usec=0, int sec=0)
        {
                int _i;
                typename _sock_list::iterator
                        _it = _sockets.begin(),
                        _first;
                fd_set readset;

                while (_it!=_sockets.end()) {
                        FD_ZERO(&readset);
                        _first = _it;
                        // put all the sockets until FD_SETSIZE in the fd_set struct
                        for (_i=0; _i<FD_SETSIZE && _it!=_sockets.end(); _i++, ++_it)
                                FD_SET(_it->first.fd, &readset);

                        struct timeval tv = { sec, usec };

                        int _r = ::select(FD_SETSIZE, &readset, 0, 0, &tv);

                        if (_r==sock::socket_error)
                                return;

                        if (_r>0)
                                for (; _first!=_it; ++_first)
                                        if (FD_ISSET(_first->first.fd, &readset))
                                                if (op(_first->first, _first->second))
                                                        _sockets.erase(_first--);
                }
        }


        void writeable(std::list<std::pair<sock, T> >& writelist, int usec=0, int sec=0)
        {
                int i;
                typename _sock_list::const_iterator it = _sockets.begin(), first;
                fd_set writeset;

                while (it!=_sockets.end()) {
                        FD_ZERO(&writeset);
                        first = it;
                        // put all the sockets until FD_SETSIZE in the fd_set struct
                        for (i=0; i<FD_SETSIZE && it!=_sockets.end(); i++, ++it)
                                FD_SET(it->first.fd, &writeset);

                        struct timeval tv = { sec, usec };
                        int r = ::select(FD_SETSIZE, 0, &writeset, 0, &tv);

                        if (r==sock::socket_error)
                                return;

                        if (r>0)
                                for (; first!=it; ++first)
                                        if (FD_ISSET(first->first.fd, &writeset))
                                                writelist.push_back(*first);
                }
        }


        template<class Op>
        void for_each_write(Op op, int usec=0, int sec=0)
        {
                int _i;
                typename _sock_list::iterator
                        _it = _sockets.begin(),
                        _first;
                fd_set writeset;

                while (_it!=_sockets.end()) {
                        FD_ZERO(&writeset);
                        _first = _it;
                        // put all the sockets until FD_SETSIZE in the fd_set struct
                        for (_i=0; _i<FD_SETSIZE && _it!=_sockets.end(); _i++, ++_it)
                                FD_SET(_it->first.fd, &writeset);

                        struct timeval tv = { sec, usec };

                        int _r = ::select(FD_SETSIZE, 0, &writeset, 0, &tv);

                        if (_r==sock::socket_error)
                                return;

                        if (_r>0)
                                for (; _first!=_it; ++_first)
                                        if (FD_ISSET(_first->first.fd, &writeset))
                                                if (op(_first->first, _first->second))
                                                        _sockets.erase(_first--);
                }
        }


};


}


#endif

---