Rename delegates to try and stop name clashes, probably with wxWebKitCtrl.

[wxWidgets.git] / src / unix / epolldispatcher.cpp

diff --git a/src/unix/epolldispatcher.cpp b/src/unix/epolldispatcher.cpp
index 336506016ca8f258ce5f4693506d1f1baf3cd023..47f4dd4f56944803e274c466c480f437e55c577c 100644 (file)
--- a/src/unix/epolldispatcher.cpp
+++ b/src/unix/epolldispatcher.cpp
@@ -1,11 +1,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        src/common/epolldispatcher.cpp
+// Name:        src/unix/epolldispatcher.cpp

 // Purpose:     implements dispatcher for epoll_wait() call
 // Author:      Lukasz Michalski
 // Created:     April 2007
 // RCS-ID:      $Id$
 // Copyright:   (c) 2007 Lukasz Michalski
 // Purpose:     implements dispatcher for epoll_wait() call
 // Author:      Lukasz Michalski
 // Created:     April 2007
 // RCS-ID:      $Id$
 // Copyright:   (c) 2007 Lukasz Michalski

-// License:     wxWindows licence
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -42,29 +42,31 @@
 
 // helper: return EPOLLxxx mask corresponding to the given flags (and also log
 // debugging messages about it)
 
 // helper: return EPOLLxxx mask corresponding to the given flags (and also log
 // debugging messages about it)

-static uint32_t GetEpollMask(int flags, int WXUNUSED_UNLESS_DEBUG(fd))
+static uint32_t GetEpollMask(int flags, int fd)

 {
 {

+    wxUnusedVar(fd); // unused if wxLogTrace() disabled
+

     uint32_t ep = 0;
 
     if ( flags & wxFDIO_INPUT )
     {
         ep |= EPOLLIN;
         wxLogTrace(wxEpollDispatcher_Trace,
     uint32_t ep = 0;
 
     if ( flags & wxFDIO_INPUT )
     {
         ep |= EPOLLIN;
         wxLogTrace(wxEpollDispatcher_Trace,

-                   _T("Registered fd %d for input events"), fd);
+                   wxT("Registered fd %d for input events"), fd);

     }
 
     if ( flags & wxFDIO_OUTPUT )
     {
         ep |= EPOLLOUT;
         wxLogTrace(wxEpollDispatcher_Trace,
     }
 
     if ( flags & wxFDIO_OUTPUT )
     {
         ep |= EPOLLOUT;
         wxLogTrace(wxEpollDispatcher_Trace,

-                   _T("Registered fd %d for output events"), fd);
+                   wxT("Registered fd %d for output events"), fd);

     }
 
     if ( flags & wxFDIO_EXCEPTION )
     {
         ep |= EPOLLERR | EPOLLHUP;
         wxLogTrace(wxEpollDispatcher_Trace,
     }
 
     if ( flags & wxFDIO_EXCEPTION )
     {
         ep |= EPOLLERR | EPOLLHUP;
         wxLogTrace(wxEpollDispatcher_Trace,

-                   _T("Registered fd %d for exceptional events"), fd);
+                   wxT("Registered fd %d for exceptional events"), fd);

     }
 
     return ep;
     }
 
     return ep;


@@ -84,13 +86,13 @@ wxEpollDispatcher *wxEpollDispatcher::Create()
         return NULL;
     }
     wxLogTrace(wxEpollDispatcher_Trace,
         return NULL;
     }
     wxLogTrace(wxEpollDispatcher_Trace,

-                   _T("Epoll fd %d created"), epollDescriptor);
+                   wxT("Epoll fd %d created"), epollDescriptor);

     return new wxEpollDispatcher(epollDescriptor);
 }
 
 wxEpollDispatcher::wxEpollDispatcher(int epollDescriptor)
 {
     return new wxEpollDispatcher(epollDescriptor);
 }
 
 wxEpollDispatcher::wxEpollDispatcher(int epollDescriptor)
 {

-    wxASSERT_MSG( epollDescriptor != -1, _T("invalid descriptor") );
+    wxASSERT_MSG( epollDescriptor != -1, wxT("invalid descriptor") );

 
     m_epollDescriptor = epollDescriptor;
 }
 
     m_epollDescriptor = epollDescriptor;
 }


@@ -118,7 +120,7 @@ bool wxEpollDispatcher::RegisterFD(int fd, wxFDIOHandler* handler, int flags)
         return false;
     }
     wxLogTrace(wxEpollDispatcher_Trace,
         return false;
     }
     wxLogTrace(wxEpollDispatcher_Trace,

-               _T("Added fd %d (handler %p) to epoll %d"), fd, handler, m_epollDescriptor);
+               wxT("Added fd %d (handler %p) to epoll %d"), fd, handler, m_epollDescriptor);

 
     return true;
 }
 
     return true;
 }


@@ -139,7 +141,7 @@ bool wxEpollDispatcher::ModifyFD(int fd, wxFDIOHandler* handler, int flags)
     }
 
     wxLogTrace(wxEpollDispatcher_Trace,
     }
 
     wxLogTrace(wxEpollDispatcher_Trace,

-                _T("Modified fd %d (handler: %p) on epoll %d"), fd, handler, m_epollDescriptor);
+                wxT("Modified fd %d (handler: %p) on epoll %d"), fd, handler, m_epollDescriptor);

     return true;
 }
 
     return true;
 }
 


@@ -155,14 +157,13 @@ bool wxEpollDispatcher::UnregisterFD(int fd)
                       fd, m_epollDescriptor);
     }
     wxLogTrace(wxEpollDispatcher_Trace,
                       fd, m_epollDescriptor);
     }
     wxLogTrace(wxEpollDispatcher_Trace,

-                _T("removed fd %d from %d"), fd, m_epollDescriptor);
+                wxT("removed fd %d from %d"), fd, m_epollDescriptor);

     return true;
 }
 
     return true;
 }
 

-bool wxEpollDispatcher::Dispatch(int timeout)
+int
+wxEpollDispatcher::DoPoll(epoll_event *events, int numEvents, int timeout) const

 {
 {

-    epoll_event events[16];
-

     // the code below relies on TIMEOUT_INFINITE being -1 so that we can pass
     // timeout value directly to epoll_wait() which interprets -1 as meaning to
     // wait forever and would need to be changed if the value of
     // the code below relies on TIMEOUT_INFINITE being -1 so that we can pass
     // timeout value directly to epoll_wait() which interprets -1 as meaning to
     // wait forever and would need to be changed if the value of


@@ -170,39 +171,58 @@ bool wxEpollDispatcher::Dispatch(int timeout)
     wxCOMPILE_TIME_ASSERT( TIMEOUT_INFINITE == -1, UpdateThisCode );
 
     wxMilliClock_t timeEnd;
     wxCOMPILE_TIME_ASSERT( TIMEOUT_INFINITE == -1, UpdateThisCode );
 
     wxMilliClock_t timeEnd;

-    if ( timeout != -1 )
+    if ( timeout > 0 )

         timeEnd = wxGetLocalTimeMillis();
 
     int rc;
     for ( ;; )
     {
         timeEnd = wxGetLocalTimeMillis();
 
     int rc;
     for ( ;; )
     {

-        rc = epoll_wait(m_epollDescriptor, events, WXSIZEOF(events), timeout);
+        rc = epoll_wait(m_epollDescriptor, events, numEvents, timeout);

         if ( rc != -1 || errno != EINTR )
             break;
 
         // we got interrupted, update the timeout and restart
         if ( rc != -1 || errno != EINTR )
             break;
 
         // we got interrupted, update the timeout and restart

-        if ( timeout == -1 )
-            continue;
-
-        timeout = wxMilliClockToLong(timeEnd - wxGetLocalTimeMillis());
-        if ( timeout < 0 )
-            return false;
+        if ( timeout > 0 )
+        {
+            timeout = wxMilliClockToLong(timeEnd - wxGetLocalTimeMillis());
+            if ( timeout < 0 )
+                return 0;
+        }

     }
 
     }
 

+    return rc;
+}
+
+bool wxEpollDispatcher::HasPending() const
+{
+    epoll_event event;
+
+    // NB: it's not really clear if epoll_wait() can return a number greater
+    //     than the number of events passed to it but just in case it can, use
+    //     >= instead of == here, see #10397
+    return DoPoll(&event, 1, 0) >= 1;
+}
+
+int wxEpollDispatcher::Dispatch(int timeout)
+{
+    epoll_event events[16];
+
+    const int rc = DoPoll(events, WXSIZEOF(events), timeout);
+

     if ( rc == -1 )
     {
         wxLogSysError(_("Waiting for IO on epoll descriptor %d failed"),
                       m_epollDescriptor);
     if ( rc == -1 )
     {
         wxLogSysError(_("Waiting for IO on epoll descriptor %d failed"),
                       m_epollDescriptor);

-        return false;
+        return -1;

     }
 
     }
 

-    bool gotEvents = false;
+    int numEvents = 0;

     for ( epoll_event *p = events; p < events + rc; p++ )
     {
         wxFDIOHandler * const handler = (wxFDIOHandler *)(p->data.ptr);
         if ( !handler )
         {
     for ( epoll_event *p = events; p < events + rc; p++ )
     {
         wxFDIOHandler * const handler = (wxFDIOHandler *)(p->data.ptr);
         if ( !handler )
         {

-            wxFAIL_MSG( _T("NULL handler in epoll_event?") );
+            wxFAIL_MSG( wxT("NULL handler in epoll_event?") );

             continue;
         }
 
             continue;
         }
 


@@ -219,10 +239,10 @@ bool wxEpollDispatcher::Dispatch(int timeout)
         else
             continue;
 
         else
             continue;
 

-        gotEvents = true;
+        numEvents++;

     }
 
     }
 

-    return gotEvents;
+    return numEvents;

 }
 
 #endif // wxUSE_EPOLL_DISPATCHER
 }
 
 #endif // wxUSE_EPOLL_DISPATCHER