zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/Selector.h

@@ -1,292 +1,235 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_SELECTOR_H
 #define ICE_SELECTOR_H
 
-#include <IceUtil/StringUtil.h>
-#include <IceUtil/Monitor.h>
-#include <IceUtil/Mutex.h>
+#include "EventHandlerF.h"
+#include "Ice/InstanceF.h"
+#include "Ice/StringUtil.h"
+#include "Network.h"
+#include "UniqueRef.h"
 
-#include <Ice/Network.h>
-#include <Ice/InstanceF.h>
-#include <Ice/EventHandlerF.h>
-#include <Ice/UniqueRef.h>
+#include <condition_variable>
+#include <map>
 
 #if defined(ICE_USE_EPOLL)
-#   include <sys/epoll.h>
+#    include <sys/epoll.h>
 #elif defined(ICE_USE_KQUEUE)
-#   include <sys/event.h>
-#elif defined(ICE_USE_IOCP)
-// Nothing to include
-#elif defined(ICE_USE_POLL)
-#   include <sys/poll.h>
-#endif
-
-#if defined(ICE_USE_CFSTREAM)
-#   include <IceUtil/RecMutex.h>
-#   include <IceUtil/Thread.h>
-#   include <set>
+#    include <sys/event.h>
+#elif defined(ICE_USE_CFSTREAM)
+#    include <set>
+#    include <thread>
 
 struct __CFRunLoop;
-typedef struct __CFRunLoop * CFRunLoopRef;
+typedef struct __CFRunLoop* CFRunLoopRef;
 
 struct __CFRunLoopSource;
-typedef struct __CFRunLoopSource * CFRunLoopSourceRef;
+typedef struct __CFRunLoopSource* CFRunLoopSourceRef;
 
 struct __CFSocket;
-typedef struct __CFSocket * CFSocketRef;
+typedef struct __CFSocket* CFSocketRef;
 #endif
 
-namespace IceInternal
-{
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
 
-//
-// Exception raised if select times out.
-//
-class SelectorTimeoutException
+namespace IceInternal
 {
-};
+    //
+    // Exception raised if select times out.
+    //
+    class SelectorTimeoutException
+    {
+    };
 
 #if defined(ICE_USE_IOCP)
 
-class Selector
-{
-public:
-
-    Selector(const InstancePtr&);
-    ~Selector();
-
-#ifdef ICE_USE_IOCP
-    void setup(int);
-#endif
-    void destroy();
-
-    void initialize(EventHandler*);
-    void update(EventHandler*, SocketOperation, SocketOperation);
-    void finish(EventHandler*);
-
-    void ready(EventHandler*, SocketOperation, bool);
+    class Selector final
+    {
+    public:
+        Selector(const InstancePtr&);
 
-#ifdef ICE_USE_IOCP
-    EventHandler* getNextHandler(SocketOperation&, DWORD&, int&, int);
-#else
-    EventHandler* getNextHandler(SocketOperation&, int);
-#endif
+        void setup(int);
+        void destroy();
 
-    void completed(EventHandler*, SocketOperation);
+        void initialize(EventHandler*);
+        void update(EventHandler*, SocketOperation, SocketOperation);
+        void finish(EventHandler*);
 
-private:
+        void ready(EventHandler*, SocketOperation, bool);
 
-    const InstancePtr _instance;
-#ifdef ICE_USE_IOCP
-    HANDLE _handle;
-#else
-    IceUtil::Monitor<IceUtil::Mutex> _monitor;
-    std::deque<SelectEvent> _events;
-#endif
-};
+        EventHandler* getNextHandler(SocketOperation&, DWORD&, int&, int);
 
-#elif defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL) || defined(ICE_USE_SELECT) || defined(ICE_USE_POLL)
+        void completed(EventHandler*, SocketOperation);
 
-class Selector
-{
-public:
+    private:
+        const InstancePtr _instance;
+        HANDLE _handle;
+    };
 
-    Selector(const InstancePtr&);
-    ~Selector();
+#elif defined(ICE_USE_EPOLL) || defined(ICE_USE_KQUEUE)
 
-    void destroy();
-
-    void initialize(EventHandler*)
+    class Selector final
     {
-        // Nothing to do
-    }
-    void update(EventHandler*, SocketOperation, SocketOperation);
-    void enable(EventHandler*, SocketOperation);
-    void disable(EventHandler*, SocketOperation);
-    bool finish(EventHandler*, bool);
-
-    void ready(EventHandler*, SocketOperation, bool);
-
-    void startSelect();
-    void finishSelect(std::vector<std::pair<EventHandler*, SocketOperation> >&);
-    void select(int);
-
-private:
-
-    void wakeup();
-    void checkReady(EventHandler*);
-    void updateSelector();
-    void updateSelectorForEventHandler(EventHandler*, SocketOperation, SocketOperation);
+    public:
+        Selector(InstancePtr);
 
-    const InstancePtr _instance;
+        void destroy();
 
-    SOCKET _fdIntrRead;
-    SOCKET _fdIntrWrite;
-    bool _interrupted;
-    bool _selectNow;
-    int _count;
-    bool _selecting;
-    std::map<EventHandlerPtr, SocketOperation> _readyHandlers;
-
-#if defined(ICE_USE_EPOLL)
-    std::vector<struct epoll_event> _events;
-    int _queueFd;
-#elif defined(ICE_USE_KQUEUE)
-    std::vector<struct kevent> _events;
-    std::vector<struct kevent> _changes;
-    int _queueFd;
-#elif defined(ICE_USE_SELECT)
-    std::vector<std::pair<EventHandler*, SocketOperation> > _changes;
-    std::map<SOCKET, EventHandler*> _handlers;
-
-    fd_set _readFdSet;
-    fd_set _writeFdSet;
-    fd_set _errorFdSet;
-    fd_set _selectedReadFdSet;
-    fd_set _selectedWriteFdSet;
-    fd_set _selectedErrorFdSet;
-
-    fd_set*
-    fdSetCopy(fd_set& dest, fd_set& src)
-    {
-        if(src.fd_count > 0)
+        void initialize(EventHandler*)
         {
-            dest.fd_count = src.fd_count;
-            memcpy(dest.fd_array, src.fd_array, sizeof(SOCKET) * src.fd_count);
-            return &dest;
+            // Nothing to do
         }
-        return 0;
-    }
-#elif defined(ICE_USE_POLL)
-    std::vector<std::pair<EventHandler*, SocketOperation> > _changes;
-    std::map<SOCKET, EventHandler*> _handlers;
-    std::vector<struct pollfd> _pollFdSet;
-#endif
-};
+        void update(EventHandler*, SocketOperation, SocketOperation);
+        void enable(EventHandler*, SocketOperation);
+        void disable(EventHandler*, SocketOperation);
+        bool finish(EventHandler*, bool);
+
+        void ready(EventHandler*, SocketOperation, bool);
+
+        void startSelect();
+        void finishSelect(std::vector<std::pair<EventHandler*, SocketOperation>>&);
+        void select(int);
+
+    private:
+        void wakeup();
+        void checkReady(EventHandler*);
+#    if defined(ICE_USE_KQUEUE)
+        void updateSelector();
+#    endif
+        void updateSelectorForEventHandler(EventHandler*, SocketOperation, SocketOperation);
+
+        const InstancePtr _instance;
+
+        SOCKET _fdIntrRead;
+        SOCKET _fdIntrWrite;
+        bool _interrupted{false};
+        bool _selectNow;
+        int _count;
+        bool _selecting;
+        std::map<EventHandlerPtr, SocketOperation> _readyHandlers;
+
+#    if defined(ICE_USE_EPOLL)
+        std::vector<struct epoll_event> _events;
+        int _queueFd;
+#    else // ICE_USE_KQUEUE
+        std::vector<struct kevent> _events;
+        std::vector<struct kevent> _changes;
+        int _queueFd;
+#    endif
+    };
 
 #elif defined(ICE_USE_CFSTREAM)
 
-class Selector;
-
-class SelectorReadyCallback : public IceUtil::Shared
-{
-public:
-
-    virtual ~SelectorReadyCallback() { }
-    virtual void readyCallback(SocketOperation, int = 0) = 0;
-};
-
-class StreamNativeInfo : public NativeInfo
-{
-public:
+    class Selector;
 
-    StreamNativeInfo(SOCKET fd) : NativeInfo(fd), _connectError(0)
+    class SelectorReadyCallback
     {
-    }
-
-    virtual void initStreams(SelectorReadyCallback*) = 0;
-    virtual SocketOperation registerWithRunLoop(SocketOperation) = 0;
-    virtual SocketOperation unregisterFromRunLoop(SocketOperation, bool) = 0;
-    virtual void closeStreams() = 0;
+    public:
+        virtual ~SelectorReadyCallback() = default;
+        virtual void readyCallback(SocketOperation, int = 0) = 0;
+    };
 
-    void setConnectError(int error)
+    class StreamNativeInfo : public NativeInfo
     {
-        _connectError = error;
-    }
+    public:
+        StreamNativeInfo(SOCKET fd) : NativeInfo(fd), _connectError(0) {}
 
-private:
+        virtual void initStreams(SelectorReadyCallback*) = 0;
+        virtual SocketOperation registerWithRunLoop(SocketOperation) = 0;
+        virtual SocketOperation unregisterFromRunLoop(SocketOperation, bool) = 0;
+        virtual void closeStreams() = 0;
 
-    int _connectError;
-};
-typedef IceUtil::Handle<StreamNativeInfo> StreamNativeInfoPtr;
+        void setConnectError(int error) { _connectError = error; }
 
-class EventHandlerWrapper : public SelectorReadyCallback
-{
-public:
+    private:
+        int _connectError;
+    };
+    using StreamNativeInfoPtr = std::shared_ptr<StreamNativeInfo>;
 
-    EventHandlerWrapper(EventHandler*, Selector&);
-    ~EventHandlerWrapper();
-
-    void updateRunLoop();
-
-    virtual void readyCallback(SocketOperation, int = 0);
-    void ready(SocketOperation, int);
-
-    SocketOperation readyOp();
-    bool checkReady();
-
-    bool update(SocketOperation, SocketOperation);
-    bool finish();
-
-    bool operator<(const EventHandlerWrapper& o)
+    class EventHandlerWrapper final : public SelectorReadyCallback,
+                                      public std::enable_shared_from_this<EventHandlerWrapper>
     {
-        return this < &o;
-    }
+    public:
+        EventHandlerWrapper(EventHandler*, Selector&);
+        ~EventHandlerWrapper();
 
-private:
+        void updateRunLoop();
 
-    friend class Selector;
+        void readyCallback(SocketOperation, int = 0) final;
+        void ready(SocketOperation, int);
 
-    EventHandlerPtr _handler;
-    StreamNativeInfoPtr _streamNativeInfo;
-    Selector& _selector;
-    SocketOperation _ready;
-    bool _finish;
-    IceInternal::UniqueRef<CFSocketRef> _socket;
-    IceInternal::UniqueRef<CFRunLoopSourceRef> _source;
-};
-typedef IceUtil::Handle<EventHandlerWrapper> EventHandlerWrapperPtr;
+        SocketOperation readyOp();
+        bool checkReady();
 
-class Selector : IceUtil::Monitor<IceUtil::RecMutex>
-{
+        bool update(SocketOperation, SocketOperation);
+        bool finish();
 
-public:
+        bool operator<(const EventHandlerWrapper& o) { return this < &o; }
 
-    Selector(const InstancePtr&);
-    virtual ~Selector();
+    private:
+        friend class Selector;
 
-    void destroy();
+        EventHandlerPtr _handler;
+        StreamNativeInfoPtr _streamNativeInfo;
+        Selector& _selector;
+        SocketOperation _ready;
+        bool _finish;
+        IceInternal::UniqueRef<CFSocketRef> _socket;
+        IceInternal::UniqueRef<CFRunLoopSourceRef> _source;
+    };
+    using EventHandlerWrapperPtr = std::shared_ptr<EventHandlerWrapper>;
 
-    void initialize(EventHandler*);
-    void update(EventHandler*, SocketOperation, SocketOperation);
-    void enable(EventHandler*, SocketOperation);
-    void disable(EventHandler*, SocketOperation);
-    bool finish(EventHandler*, bool);
+    class Selector final
+    {
+    public:
+        Selector(const InstancePtr&);
 
-    void ready(EventHandler*, SocketOperation, bool);
+        void destroy();
 
-    void startSelect();
-    void finishSelect(std::vector<std::pair<EventHandler*, SocketOperation> >&);
-    void select(int);
+        void initialize(EventHandler*);
+        void update(EventHandler*, SocketOperation, SocketOperation);
+        void enable(EventHandler*, SocketOperation);
+        void disable(EventHandler*, SocketOperation);
+        bool finish(EventHandler*, bool);
 
-    void processInterrupt();
-    void run();
+        void ready(EventHandler*, SocketOperation, bool);
 
-private:
+        void startSelect();
+        void finishSelect(std::vector<std::pair<EventHandler*, SocketOperation>>&);
+        void select(int);
 
-    void ready(EventHandlerWrapper*, SocketOperation, int = 0);
-    void addReadyHandler(EventHandlerWrapper*);
+        void processInterrupt();
+        void run();
 
-    friend class EventHandlerWrapper;
+    private:
+        void ready(EventHandlerWrapper*, SocketOperation, int = 0);
+        void addReadyHandler(EventHandlerWrapperPtr);
 
-    InstancePtr _instance;
-    IceUtil::ThreadPtr _thread;
-    CFRunLoopRef _runLoop;
-    IceInternal::UniqueRef<CFRunLoopSourceRef> _source;
-    bool _destroyed;
+        friend class EventHandlerWrapper;
 
-    std::set<EventHandlerWrapperPtr> _changes;
+        InstancePtr _instance;
+        std::thread _thread;
+        CFRunLoopRef _runLoop;
+        IceInternal::UniqueRef<CFRunLoopSourceRef> _source;
+        bool _destroyed;
 
-    std::set<EventHandlerWrapperPtr> _readyHandlers;
-    std::vector<std::pair<EventHandlerWrapperPtr, SocketOperation> > _selectedHandlers;
-    std::map<EventHandler*, EventHandlerWrapperPtr> _wrappers;
-};
+        std::set<EventHandlerWrapperPtr> _changes;
 
-#endif
+        std::set<EventHandlerWrapperPtr> _readyHandlers;
+        std::vector<std::pair<EventHandlerWrapperPtr, SocketOperation>> _selectedHandlers;
+        std::map<EventHandler*, EventHandlerWrapperPtr> _wrappers;
+        std::recursive_mutex _mutex;
+        std::condition_variable_any _conditionVariable;
+    };
 
+#endif
 }
 
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
 #endif