src/common/selectdispatcher.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/selectdispatcher.cpp
   3 // Purpose:     implements dispatcher for select() call
   4 // Author:      Lukasz Michalski and Vadim Zeitlin
   5 // Created:     December 2006
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2006 Lukasz Michalski
   8 // License:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 // for compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #if wxUSE_SELECT_DISPATCHER
  23
  24 #include "wx/private/selectdispatcher.h"
  25 #include "wx/unix/private.h"
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/hash.h"
  29     #include "wx/log.h"
  30     #include "wx/intl.h"
  31 #endif
  32
  33 #if defined(HAVE_SYS_SELECT_H) || defined(__WATCOMC__)
  34     #include <sys/time.h>
  35     #include <sys/select.h>
  36 #endif
  37
  38 #include <errno.h>
  39
  40 #define wxSelectDispatcher_Trace wxT("selectdispatcher")
  41
  42 // ============================================================================
  43 // implementation
  44 // ============================================================================
  45
  46 // ----------------------------------------------------------------------------
  47 // wxSelectSets
  48 // ----------------------------------------------------------------------------
  49
  50 int wxSelectSets::ms_flags[wxSelectSets::Max] =
  51 {
  52     wxFDIO_INPUT,
  53     wxFDIO_OUTPUT,
  54     wxFDIO_EXCEPTION,
  55 };
  56
  57 const char *wxSelectSets::ms_names[wxSelectSets::Max] =
  58 {
  59     "input",
  60     "output",
  61     "exceptional",
  62 };
  63
  64 wxSelectSets::Callback wxSelectSets::ms_handlers[wxSelectSets::Max] =
  65 {
  66     &wxFDIOHandler::OnReadWaiting,
  67     &wxFDIOHandler::OnWriteWaiting,
  68     &wxFDIOHandler::OnExceptionWaiting,
  69 };
  70
  71 wxSelectSets::wxSelectSets()
  72 {
  73     for ( int n = 0; n < Max; n++ )
  74     {
  75         wxFD_ZERO(&m_fds[n]);
  76     }
  77 }
  78
  79 bool wxSelectSets::HasFD(int fd) const
  80 {
  81     for ( int n = 0; n < Max; n++ )
  82     {
  83         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
  84             return true;
  85     }
  86
  87     return false;
  88 }
  89
  90 bool wxSelectSets::SetFD(int fd, int flags)
  91 {
  92     wxCHECK_MSG( fd >= 0, false, _T("invalid descriptor") );
  93
  94     for ( int n = 0; n < Max; n++ )
  95     {
  96         if ( flags & ms_flags[n] )
  97         {
  98             wxFD_SET(fd, &m_fds[n]);
  99             wxLogTrace(wxSelectDispatcher_Trace,
 100                        _T("Registered fd %d for %s events"), fd, ms_names[n]);
 101         }
 102         else if ( wxFD_ISSET(fd,  (fd_set*) &m_fds[n]) )
 103         {
 104             wxFD_CLR(fd, &m_fds[n]);
 105             wxLogTrace(wxSelectDispatcher_Trace,
 106                        _T("Unregistered fd %d from %s events"), fd, ms_names[n]);
 107         }
 108     }
 109
 110     return true;
 111 }
 112
 113 int wxSelectSets::Select(int nfds, struct timeval *tv)
 114 {
 115     return select(nfds, &m_fds[Read], &m_fds[Write], &m_fds[Except], tv);
 116 }
 117
 118 void wxSelectSets::Handle(int fd, wxFDIOHandler& handler) const
 119 {
 120     for ( int n = 0; n < Max; n++ )
 121     {
 122         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
 123         {
 124             wxLogTrace(wxSelectDispatcher_Trace,
 125                        _T("Got %s event on fd %d"), ms_names[n], fd);
 126             (handler.*ms_handlers[n])();
 127         }
 128     }
 129 }
 130
 131 // ----------------------------------------------------------------------------
 132 // wxSelectDispatcher
 133 // ----------------------------------------------------------------------------
 134
 135 /* static */
 136 wxSelectDispatcher *wxSelectDispatcher::Create()
 137 {
 138     return new wxSelectDispatcher;
 139 }
 140
 141 wxSelectDispatcher::wxSelectDispatcher()
 142 {
 143     m_maxFD = -1;
 144 }
 145
 146 bool wxSelectDispatcher::RegisterFD(int fd, wxFDIOHandler *handler, int flags)
 147 {
 148     if ( !wxMappedFDIODispatcher::RegisterFD(fd, handler, flags) )
 149         return false;
 150
 151     if ( !m_sets.SetFD(fd, flags) )
 152        return false;
 153
 154     if ( fd > m_maxFD )
 155       m_maxFD = fd;
 156
 157     return true;
 158 }
 159
 160 bool wxSelectDispatcher::ModifyFD(int fd, wxFDIOHandler *handler, int flags)
 161 {
 162     if ( !wxMappedFDIODispatcher::ModifyFD(fd, handler, flags) )
 163         return false;
 164
 165     wxASSERT_MSG( fd <= m_maxFD, _T("logic error: registered fd > m_maxFD?") );
 166
 167     return m_sets.SetFD(fd, flags);
 168 }
 169
 170 bool wxSelectDispatcher::UnregisterFD(int fd)
 171 {
 172     m_sets.ClearFD(fd);
 173
 174     if ( !wxMappedFDIODispatcher::UnregisterFD(fd) )
 175         return false;
 176
 177     // remove the handler if we don't need it any more
 178     if ( !m_sets.HasFD(fd) )
 179     {
 180         if ( fd == m_maxFD )
 181         {
 182             // need to find new max fd
 183             m_maxFD = -1;
 184             for ( wxFDIOHandlerMap::const_iterator it = m_handlers.begin();
 185                   it != m_handlers.end();
 186                   ++it )
 187             {
 188                 if ( it->first > m_maxFD )
 189                     m_maxFD = it->first;
 190             }
 191         }
 192     }
 193
 194     return true;
 195 }
 196
 197 void wxSelectDispatcher::ProcessSets(const wxSelectSets& sets)
 198 {
 199     for ( int fd = 0; fd <= m_maxFD; fd++ )
 200     {
 201         if ( !sets.HasFD(fd) )
 202             continue;
 203
 204         wxFDIOHandler * const handler = FindHandler(fd);
 205         if ( !handler )
 206         {
 207             wxFAIL_MSG( _T("NULL handler in wxSelectDispatcher?") );
 208             continue;
 209         }
 210
 211         sets.Handle(fd, *handler);
 212     }
 213 }
 214
 215 void wxSelectDispatcher::Dispatch(int timeout)
 216 {
 217     struct timeval tv,
 218                   *ptv;
 219     if ( timeout != TIMEOUT_INFINITE )
 220     {
 221         ptv = &tv;
 222         tv.tv_sec = 0;
 223         tv.tv_usec = timeout*1000;
 224     }
 225     else // no timeout
 226     {
 227         ptv = NULL;
 228     }
 229
 230     wxSelectSets sets = m_sets;
 231
 232     const int ret = sets.Select(m_maxFD + 1, ptv);
 233     switch ( ret )
 234     {
 235         case -1:
 236             if ( errno != EINTR )
 237             {
 238                 wxLogSysError(_("Failed to monitor I/O channels"));
 239             }
 240             break;
 241
 242         case 0:
 243             // timeout expired without anything happening
 244             break;
 245
 246         default:
 247             ProcessSets(sets);
 248     }
 249 }
 250
 251 #endif // wxUSE_SELECT_DISPATCHER