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/module.h"
  26 #include "wx/timer.h"
  27 #include "wx/unix/private.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/hash.h"
  31     #include "wx/log.h"
  32     #include "wx/intl.h"
  33 #endif
  34
  35 #ifdef HAVE_SYS_SELECT_H
  36     #include <sys/select.h>
  37 #endif
  38
  39 #include <errno.h>
  40
  41 #define wxSelectDispatcher_Trace wxT("selectdispatcher")
  42
  43 // ============================================================================
  44 // implementation
  45 // ============================================================================
  46
  47 // ----------------------------------------------------------------------------
  48 // wxSelectSets
  49 // ----------------------------------------------------------------------------
  50
  51 int wxSelectSets::ms_flags[wxSelectSets::Max] =
  52 {
  53     wxFDIO_INPUT,
  54     wxFDIO_OUTPUT,
  55     wxFDIO_EXCEPTION,
  56 };
  57
  58 const char *wxSelectSets::ms_names[wxSelectSets::Max] =
  59 {
  60     "input",
  61     "output",
  62     "exceptional",
  63 };
  64
  65 wxSelectSets::Callback wxSelectSets::ms_handlers[wxSelectSets::Max] =
  66 {
  67     &wxFDIOHandler::OnReadWaiting,
  68     &wxFDIOHandler::OnWriteWaiting,
  69     &wxFDIOHandler::OnExceptionWaiting,
  70 };
  71
  72 wxSelectSets::wxSelectSets()
  73 {
  74     for ( int n = 0; n < Max; n++ )
  75     {
  76         wxFD_ZERO(&m_fds[n]);
  77     }
  78 }
  79
  80 bool wxSelectSets::HasFD(int fd) const
  81 {
  82     for ( int n = 0; n < Max; n++ )
  83     {
  84         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
  85             return true;
  86     }
  87
  88     return false;
  89 }
  90
  91 bool wxSelectSets::SetFD(int fd, int flags)
  92 {
  93     wxCHECK_MSG( fd >= 0, false, _T("invalid descriptor") );
  94
  95     for ( int n = 0; n < Max; n++ )
  96     {
  97         if ( flags & ms_flags[n] )
  98         {
  99             wxFD_SET(fd, &m_fds[n]);
 100             wxLogTrace(wxSelectDispatcher_Trace,
 101                        _T("Registered fd %d for %s events"), fd, ms_names[n]);
 102         }
 103         else if ( wxFD_ISSET(fd,  (fd_set*) &m_fds[n]) )
 104         {
 105             wxFD_CLR(fd, &m_fds[n]);
 106             wxLogTrace(wxSelectDispatcher_Trace,
 107                        _T("Unregistered fd %d from %s events"), fd, ms_names[n]);
 108         }
 109     }
 110
 111     return true;
 112 }
 113
 114 int wxSelectSets::Select(int nfds, struct timeval *tv)
 115 {
 116     return select(nfds, &m_fds[Read], &m_fds[Write], &m_fds[Except], tv);
 117 }
 118
 119 void wxSelectSets::Handle(int fd, wxFDIOHandler& handler) const
 120 {
 121     for ( int n = 0; n < Max; n++ )
 122     {
 123         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
 124         {
 125             wxLogTrace(wxSelectDispatcher_Trace,
 126                        _T("Got %s event on fd %d"), ms_names[n], fd);
 127             (handler.*ms_handlers[n])();
 128         }
 129     }
 130 }
 131
 132 // ----------------------------------------------------------------------------
 133 // wxSelectDispatcher
 134 // ----------------------------------------------------------------------------
 135
 136 static wxSelectDispatcher *gs_selectDispatcher = NULL;
 137
 138 /* static */
 139 wxSelectDispatcher *wxSelectDispatcher::Get()
 140 {
 141     if ( !gs_selectDispatcher )
 142     {
 143         // the dispatcher should be only created from one thread so it should
 144         // be ok to use a global without any protection here
 145         gs_selectDispatcher = new wxSelectDispatcher;
 146     }
 147
 148     return gs_selectDispatcher;
 149 }
 150
 151 /* static */
 152 void wxSelectDispatcher::DispatchPending()
 153 {
 154     if ( gs_selectDispatcher )
 155         gs_selectDispatcher->RunLoop(0);
 156 }
 157
 158 wxSelectDispatcher::wxSelectDispatcher()
 159 {
 160     m_maxFD = -1;
 161 }
 162
 163 bool wxSelectDispatcher::RegisterFD(int fd, wxFDIOHandler *handler, int flags)
 164 {
 165     if ( !wxMappedFDIODispatcher::RegisterFD(fd, handler, flags) )
 166         return false;
 167
 168     if ( !m_sets.SetFD(fd, flags) )
 169        return false;
 170
 171     if ( fd > m_maxFD )
 172       m_maxFD = fd;
 173
 174     return true;
 175 }
 176
 177 bool wxSelectDispatcher::ModifyFD(int fd, wxFDIOHandler *handler, int flags)
 178 {
 179     if ( !wxMappedFDIODispatcher::ModifyFD(fd, handler, flags) )
 180         return false;
 181
 182     wxASSERT_MSG( fd <= m_maxFD, _T("logic error: registered fd > m_maxFD?") );
 183
 184     return m_sets.SetFD(fd, flags);
 185 }
 186
 187 bool wxSelectDispatcher::UnregisterFD(int fd, int flags)
 188 {
 189     m_sets.ClearFD(fd, flags);
 190
 191     // remove the handler if we don't need it any more
 192     if ( !m_sets.HasFD(fd) )
 193     {
 194         if ( fd == m_maxFD )
 195         {
 196             // need to find new max fd
 197             m_maxFD = -1;
 198             for ( wxFDIOHandlerMap::const_iterator it = m_handlers.begin();
 199                   it != m_handlers.end();
 200                   ++it )
 201             {
 202                 if ( it->first > m_maxFD )
 203                     m_maxFD = it->first;
 204             }
 205         }
 206     }
 207
 208     return true;
 209 }
 210
 211 void wxSelectDispatcher::ProcessSets(const wxSelectSets& sets)
 212 {
 213     for ( int fd = 0; fd <= m_maxFD; fd++ )
 214     {
 215         if ( !sets.HasFD(fd) )
 216             continue;
 217
 218         wxFDIOHandler * const handler = FindHandler(fd);
 219         if ( !handler )
 220         {
 221             wxFAIL_MSG( _T("NULL handler in wxSelectDispatcher?") );
 222             continue;
 223         }
 224
 225         sets.Handle(fd, *handler);
 226     }
 227 }
 228
 229 void wxSelectDispatcher::RunLoop(int timeout)
 230 {
 231     struct timeval tv,
 232                   *ptv = NULL;
 233     if ( timeout != TIMEOUT_INFINITE )
 234     {
 235         ptv = &tv;
 236         tv.tv_sec = 0;
 237         tv.tv_usec = timeout*1000;
 238     }
 239
 240     for ( ;; )
 241     {
 242         wxSelectSets sets = m_sets;
 243
 244         wxStopWatch sw;
 245         if ( ptv && timeout )
 246           sw.Start(ptv->tv_usec/10);
 247
 248         const int ret = sets.Select(m_maxFD + 1, ptv);
 249         switch ( ret )
 250         {
 251             case -1:
 252                 // continue if we were interrupted by a signal, else bail out
 253                 if ( errno != EINTR )
 254                 {
 255                     wxLogSysError(_("Failed to monitor I/O channels"));
 256                     return;
 257                 }
 258                 break;
 259
 260             case 0:
 261                 // timeout expired without anything happening
 262                 return;
 263
 264             default:
 265                 ProcessSets(sets);
 266         }
 267
 268         if ( ptv )
 269         {
 270             timeout -= sw.Time();
 271             if ( timeout <= 0 )
 272                 break;
 273
 274             ptv->tv_usec = timeout*1000;
 275         }
 276     }
 277 }
 278
 279 // ----------------------------------------------------------------------------
 280 // wxSelectDispatcherModule
 281 // ----------------------------------------------------------------------------
 282
 283 class wxSelectDispatcherModule : public wxModule
 284 {
 285 public:
 286     virtual bool OnInit() { return true; }
 287     virtual void OnExit() { wxDELETE(gs_selectDispatcher); }
 288
 289 private:
 290     DECLARE_DYNAMIC_CLASS(wxSelectDispatcherModule)
 291 };
 292
 293 IMPLEMENT_DYNAMIC_CLASS(wxSelectDispatcherModule, wxModule)
 294
 295 #endif // wxUSE_SELECT_DISPATCHER