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         }
 100         else if ( wxFD_ISSET(fd,  (fd_set*) &m_fds[n]) )
 101         {
 102             wxFD_CLR(fd, &m_fds[n]);
 103         }
 104     }
 105
 106     return true;
 107 }
 108
 109 int wxSelectSets::Select(int nfds, struct timeval *tv)
 110 {
 111     return select(nfds, &m_fds[Read], &m_fds[Write], &m_fds[Except], tv);
 112 }
 113
 114 void wxSelectSets::Handle(int fd, wxFDIOHandler& handler) const
 115 {
 116     for ( int n = 0; n < Max; n++ )
 117     {
 118         if ( wxFD_ISSET(fd, (fd_set*) &m_fds[n]) )
 119         {
 120             wxLogTrace(wxSelectDispatcher_Trace,
 121                        _T("Got %s event on fd %d"), ms_names[n], fd);
 122             (handler.*ms_handlers[n])();
 123             // callback can modify sets and destroy handler
 124             // this forces that one event can be processed at one time
 125             return;
 126         }
 127     }
 128 }
 129
 130 // ----------------------------------------------------------------------------
 131 // wxSelectDispatcher
 132 // ----------------------------------------------------------------------------
 133
 134 /* static */
 135 wxSelectDispatcher *wxSelectDispatcher::Create()
 136 {
 137     return new wxSelectDispatcher;
 138 }
 139
 140 wxSelectDispatcher::wxSelectDispatcher()
 141 {
 142     m_maxFD = -1;
 143 }
 144
 145 bool wxSelectDispatcher::RegisterFD(int fd, wxFDIOHandler *handler, int flags)
 146 {
 147     if ( !wxMappedFDIODispatcher::RegisterFD(fd, handler, flags) )
 148         return false;
 149
 150     if ( !m_sets.SetFD(fd, flags) )
 151        return false;
 152
 153     if ( fd > m_maxFD )
 154       m_maxFD = fd;
 155
 156     wxLogTrace(wxSelectDispatcher_Trace,
 157                 _T("Registered fd %d: input:%d, output:%d, exceptional:%d"), fd, (flags & wxFDIO_INPUT) == wxFDIO_INPUT, (flags & wxFDIO_OUTPUT), (flags & wxFDIO_EXCEPTION) == wxFDIO_EXCEPTION);
 158     return true;
 159 }
 160
 161 bool wxSelectDispatcher::ModifyFD(int fd, wxFDIOHandler *handler, int flags)
 162 {
 163     if ( !wxMappedFDIODispatcher::ModifyFD(fd, handler, flags) )
 164         return false;
 165
 166     wxASSERT_MSG( fd <= m_maxFD, _T("logic error: registered fd > m_maxFD?") );
 167
 168     wxLogTrace(wxSelectDispatcher_Trace,
 169                 _T("Modified fd %d: input:%d, output:%d, exceptional:%d"), fd, (flags & wxFDIO_INPUT) == wxFDIO_INPUT, (flags & wxFDIO_OUTPUT) == wxFDIO_OUTPUT, (flags & wxFDIO_EXCEPTION) == wxFDIO_EXCEPTION);
 170     return m_sets.SetFD(fd, flags);
 171 }
 172
 173 bool wxSelectDispatcher::UnregisterFD(int fd)
 174 {
 175     m_sets.ClearFD(fd);
 176
 177     if ( !wxMappedFDIODispatcher::UnregisterFD(fd) )
 178         return false;
 179
 180     // remove the handler if we don't need it any more
 181     if ( !m_sets.HasFD(fd) )
 182     {
 183         if ( fd == m_maxFD )
 184         {
 185             // need to find new max fd
 186             m_maxFD = -1;
 187             for ( wxFDIOHandlerMap::const_iterator it = m_handlers.begin();
 188                   it != m_handlers.end();
 189                   ++it )
 190             {
 191                 if ( it->first > m_maxFD )
 192                 {
 193                     m_maxFD = it->first;
 194                 }
 195             }
 196         }
 197     }
 198
 199     wxLogTrace(wxSelectDispatcher_Trace,
 200                 _T("Removed fd %d, current max: %d"), fd, m_maxFD);
 201     return true;
 202 }
 203
 204 void wxSelectDispatcher::ProcessSets(const wxSelectSets& sets)
 205 {
 206     for ( int fd = 0; fd <= m_maxFD; fd++ )
 207     {
 208         if ( !sets.HasFD(fd) )
 209             continue;
 210
 211         wxFDIOHandler * const handler = FindHandler(fd);
 212         if ( !handler )
 213         {
 214             wxFAIL_MSG( _T("NULL handler in wxSelectDispatcher?") );
 215             continue;
 216         }
 217
 218         sets.Handle(fd, *handler);
 219     }
 220 }
 221
 222 void wxSelectDispatcher::Dispatch(int timeout)
 223 {
 224     struct timeval tv,
 225                   *ptv;
 226     if ( timeout != TIMEOUT_INFINITE )
 227     {
 228         ptv = &tv;
 229         tv.tv_sec = 0;
 230         tv.tv_usec = timeout*1000;
 231     }
 232     else // no timeout
 233     {
 234         ptv = NULL;
 235     }
 236
 237     wxSelectSets sets = m_sets;
 238
 239     const int ret = sets.Select(m_maxFD + 1, ptv);
 240     switch ( ret )
 241     {
 242         case -1:
 243             if ( errno != EINTR )
 244             {
 245                 wxLogSysError(_("Failed to monitor I/O channels"));
 246             }
 247             break;
 248
 249         case 0:
 250             // timeout expired without anything happening
 251             break;
 252
 253         default:
 254             ProcessSets(sets);
 255     }
 256 }
 257
 258 #endif // wxUSE_SELECT_DISPATCHER