zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_SELECTOR_H
 #define ICE_SELECTOR_H
@@ -17,6 +12,7 @@
 #include <Ice/Network.h>
 #include <Ice/InstanceF.h>
 #include <Ice/EventHandlerF.h>
+#include <Ice/UniqueRef.h>
 
 #if defined(ICE_USE_EPOLL)
 #   include <sys/epoll.h>
@@ -43,7 +39,7 @@ struct __CFSocket;
 typedef struct __CFSocket * CFSocketRef;
 #endif
 
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
 #    include <deque>
 #endif
 
@@ -57,67 +53,58 @@ class SelectorTimeoutException
 {
 };
 
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 
-struct SelectEvent
+class Selector
 {
-    SelectEvent(const EventHandlerPtr& handler, SocketOperation status) : handler(handler), status(status)
+#if defined(ICE_OS_UWP)
+    struct SelectEvent
     {
-    }
-
-    EventHandlerPtr handler;
-    SocketOperation status;
-};
-
-class Selector : IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
-
-    Selector(const InstancePtr&);
-
-    void destroy();
-
-    void initialize(EventHandler*);
-    void update(EventHandler*, SocketOperation, SocketOperation);    
-    void finish(EventHandler*);
-
-    EventHandlerPtr getNextHandler(SocketOperation&, int);
-    
-    void completed(const EventHandlerPtr&, SocketOperation);
-
-private:
-
-    const InstancePtr _instance;
-    std::deque<SelectEvent> _events;
-};
+        SelectEvent(const EventHandlerPtr& handler, SocketOperation status) : handler(handler), status(status)
+        {
+        }
 
-#elif defined(ICE_USE_IOCP)
+        EventHandlerPtr handler;
+        SocketOperation status;
+    };
+#endif
 
-class Selector
-{
 public:
 
     Selector(const InstancePtr&);
     ~Selector();
 
+#ifdef ICE_USE_IOCP
     void setup(int);
-    void destroy();    
+#endif
+    void destroy();
 
     void initialize(EventHandler*);
     void update(EventHandler*, SocketOperation, SocketOperation);
     void finish(EventHandler*);
 
+    void ready(EventHandler*, SocketOperation, bool);
+
+#ifdef ICE_USE_IOCP
     EventHandler* getNextHandler(SocketOperation&, DWORD&, int&, int);
+#else
+    EventHandler* getNextHandler(SocketOperation&, int);
+#endif
+
+    void completed(EventHandler*, SocketOperation);
 
-    HANDLE getIOCPHandle() { return _handle; } 
-    
 private:
 
     const InstancePtr _instance;
+#ifdef ICE_USE_IOCP
     HANDLE _handle;
+#else
+    IceUtil::Monitor<IceUtil::Mutex> _monitor;
+    std::deque<SelectEvent> _events;
+#endif
 };
 
-#elif defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL)
+#elif defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL) || defined(ICE_USE_SELECT) || defined(ICE_USE_POLL)
 
 class Selector
 {
@@ -126,7 +113,7 @@ public:
     Selector(const InstancePtr&);
     ~Selector();
 
-    void destroy();    
+    void destroy();
 
     void initialize(EventHandler*)
     {
@@ -137,43 +124,63 @@ public:
     void disable(EventHandler*, SocketOperation);
     bool finish(EventHandler*, bool);
 
-#if defined(ICE_USE_KQUEUE)
-    void updateSelector();
-#endif
+    void ready(EventHandler*, SocketOperation, bool);
 
-    void
-    startSelect()
-    {
-#ifdef ICE_USE_KQUEUE
-        _selecting = true;
-        if(!_changes.empty())
-        {
-            updateSelector();
-        }
-#endif
-    }
-
-    void
-    finishSelect()
-    {
-#ifdef ICE_USE_KQUEUE
-        _selecting = false;
-#endif
-    }
-
-    void select(std::vector<std::pair<EventHandler*, SocketOperation> >&, int);
+    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);
+
     const InstancePtr _instance;
+
+    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;
-#else
+    int _queueFd;
+#elif defined(ICE_USE_KQUEUE)
     std::vector<struct kevent> _events;
     std::vector<struct kevent> _changes;
-    bool _selecting;
-#endif
     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)
+        {
+            dest.fd_count = src.fd_count;
+            memcpy(dest.fd_array, src.fd_array, sizeof(SOCKET) * src.fd_count);
+            return &dest;
+        }
+        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
 };
 
 #elif defined(ICE_USE_CFSTREAM)
@@ -182,7 +189,7 @@ class Selector;
 
 class SelectorReadyCallback : public IceUtil::Shared
 {
-public: 
+public:
 
     virtual ~SelectorReadyCallback() { }
     virtual void readyCallback(SocketOperation, int = 0) = 0;
@@ -201,9 +208,9 @@ public:
     virtual SocketOperation unregisterFromRunLoop(SocketOperation, bool) = 0;
     virtual void closeStreams() = 0;
 
-    void setConnectError(int error) 
+    void setConnectError(int error)
     {
-        _connectError = error; 
+        _connectError = error;
     }
 
 private:
@@ -216,20 +223,19 @@ class EventHandlerWrapper : public SelectorReadyCallback
 {
 public:
 
-    EventHandlerWrapper(const EventHandlerPtr&, Selector&);
+    EventHandlerWrapper(EventHandler*, Selector&);
     ~EventHandlerWrapper();
 
     void updateRunLoop();
 
     virtual void readyCallback(SocketOperation, int = 0);
-
     void ready(SocketOperation, int);
 
     SocketOperation readyOp();
-    void checkReady();
+    bool checkReady();
 
     bool update(SocketOperation, SocketOperation);
-    void finish();
+    bool finish();
 
     bool operator<(const EventHandlerWrapper& o)
     {
@@ -241,12 +247,12 @@ private:
     friend class Selector;
 
     EventHandlerPtr _handler;
-    StreamNativeInfoPtr _nativeInfo;
+    StreamNativeInfoPtr _streamNativeInfo;
     Selector& _selector;
     SocketOperation _ready;
     bool _finish;
-    CFSocketRef _socket;
-    CFRunLoopSourceRef _source;
+    IceInternal::UniqueRef<CFSocketRef> _socket;
+    IceInternal::UniqueRef<CFRunLoopSourceRef> _source;
 };
 typedef IceUtil::Handle<EventHandlerWrapper> EventHandlerWrapperPtr;
 
@@ -266,93 +272,35 @@ public:
     void disable(EventHandler*, SocketOperation);
     bool finish(EventHandler*, bool);
 
-    void startSelect() { }
-    void finishSelect() { }
-    void select(std::vector<std::pair<EventHandler*, SocketOperation> >&, int); 
+    void ready(EventHandler*, SocketOperation, bool);
+
+    void startSelect();
+    void finishSelect(std::vector<std::pair<EventHandler*, SocketOperation> >&);
+    void select(int);
 
     void processInterrupt();
-    void ready(EventHandlerWrapper*, SocketOperation, int = 0);
-    void addReadyHandler(EventHandlerWrapper*);
     void run();
 
 private:
 
+    void ready(EventHandlerWrapper*, SocketOperation, int = 0);
+    void addReadyHandler(EventHandlerWrapper*);
+
+    friend class EventHandlerWrapper;
+
     InstancePtr _instance;
     IceUtil::ThreadPtr _thread;
     CFRunLoopRef _runLoop;
-    CFRunLoopSourceRef _source;
+    IceInternal::UniqueRef<CFRunLoopSourceRef> _source;
     bool _destroyed;
 
     std::set<EventHandlerWrapperPtr> _changes;
 
-    std::vector<EventHandlerWrapperPtr> _readyHandlers;
+    std::set<EventHandlerWrapperPtr> _readyHandlers;
     std::vector<std::pair<EventHandlerWrapperPtr, SocketOperation> > _selectedHandlers;
     std::map<EventHandler*, EventHandlerWrapperPtr> _wrappers;
 };
 
-#elif defined(ICE_USE_SELECT) || defined(ICE_USE_POLL)
-
-class Selector
-{
-public:
-
-    Selector(const InstancePtr&);
-    ~Selector();
-
-    void destroy();    
-
-    void initialize(EventHandler*)
-    {
-        // Nothing to do
-    }
-    void update(EventHandler*, SocketOperation, SocketOperation);
-    void enable(EventHandler*, SocketOperation);
-    void disable(EventHandler*, SocketOperation);
-    bool finish(EventHandler*, bool);
-
-    void startSelect();
-    void finishSelect();
-    void select(std::vector<std::pair<EventHandler*, SocketOperation> >&, int);
-
-private:
-
-    void updateSelector();
-    void updateImpl(EventHandler*);
-
-    const InstancePtr _instance;
-
-    SOCKET _fdIntrRead;
-    SOCKET _fdIntrWrite;
-    bool _selecting;
-    bool _interrupted;
-
-    std::vector<std::pair<EventHandler*, SocketOperation> > _changes;
-    std::map<SOCKET, EventHandler*> _handlers;
-
-#if defined(ICE_USE_SELECT)
-    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)
-        {
-            dest.fd_count = src.fd_count;
-            memcpy(dest.fd_array, src.fd_array, sizeof(SOCKET) * src.fd_count);
-            return &dest;
-        }
-        return 0;
-    }
-#else
-    std::vector<struct pollfd> _pollFdSet;
-#endif
-};
-
 #endif
 
 }

data/ext/ice/cpp/src/Ice/ServantLocator.cpp

@@ -1,13 +1,8 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
 //
-// **********************************************************************
-//
-// Ice version 3.6.5
+// Ice version 3.7.4
 //
 // <auto-generated>
 //
@@ -23,25 +18,58 @@
 #endif
 #include <Ice/ServantLocator.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
-#   if ICE_INT_VERSION % 100 > 50
+#   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 4
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
 namespace
 {
 
 }
 
-ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::ServantLocator* p) { return p; }
+Ice::ServantLocator::~ServantLocator()
+{
+}
+
+#else // C++98 mapping
+
+namespace
+{
+
+}
+
+Ice::ServantLocator::~ServantLocator()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::LocalObject* Ice::upCast(ServantLocator* p) { return p; }
+/// \endcond
+
+namespace Ice
+{
+}
+
+#endif