zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -23,7 +23,7 @@
 #include <Ice/PropertiesF.h>
 #include <Ice/EventHandler.h>
 #include <Ice/Selector.h>
-#include <Ice/BasicStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/ObserverHelper.h>
 
 #include <set>
@@ -35,12 +35,12 @@ namespace IceInternal
 class ThreadPoolCurrent;
 
 class ThreadPoolWorkQueue;
-typedef IceUtil::Handle<ThreadPoolWorkQueue> ThreadPoolWorkQueuePtr;
+ICE_DEFINE_PTR(ThreadPoolWorkQueuePtr, ThreadPoolWorkQueue);
 
-class ThreadPoolWorkItem : virtual public IceUtil::Shared
+class ThreadPoolWorkItem : public virtual IceUtil::Shared
 {
 public:
-    
+
     virtual void execute(ThreadPoolCurrent&) = 0;
 };
 typedef IceUtil::Handle<ThreadPoolWorkItem> ThreadPoolWorkItemPtr;
@@ -51,8 +51,8 @@ public:
 
     DispatchWorkItem();
     DispatchWorkItem(const Ice::ConnectionPtr& connection);
- 
-    const Ice::ConnectionPtr& 
+
+    const Ice::ConnectionPtr&
     getConnection()
     {
         return _connection;
@@ -66,18 +66,18 @@ private:
 };
 typedef IceUtil::Handle<DispatchWorkItem> DispatchWorkItemPtr;
 
-class ThreadPool : public IceUtil::Shared, public IceUtil::Monitor<IceUtil::Mutex>
+class ThreadPool : public IceUtil::Shared, private IceUtil::Monitor<IceUtil::Mutex>
 {
     class EventHandlerThread : public IceUtil::Thread
     {
     public:
-        
+
         EventHandlerThread(const ThreadPoolPtr&, const std::string&);
         virtual void run();
 
         void updateObserver();
         void setState(Ice::Instrumentation::ThreadState);
-        
+
     private:
 
         ThreadPoolPtr _pool;
@@ -106,6 +106,7 @@ public:
         update(handler, status, SocketOperationNone);
     }
     bool finish(const EventHandlerPtr&, bool);
+    void ready(const EventHandlerPtr&, SocketOperation, bool);
 
     void dispatchFromThisThread(const DispatchWorkItemPtr&);
     void dispatch(const DispatchWorkItemPtr&);
@@ -120,7 +121,7 @@ private:
 
     bool ioCompleted(ThreadPoolCurrent&);
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     bool startMessage(ThreadPoolCurrent&);
     void finishMessage(ThreadPoolCurrent&);
 #else
@@ -131,7 +132,11 @@ private:
     std::string nextThreadId();
 
     const InstancePtr _instance;
+#ifdef ICE_CPP11_MAPPING
+    std::function<void(std::function<void()>, const std::shared_ptr<Ice::Connection>&)> _dispatcher;
+#else
     const Ice::DispatcherPtr _dispatcher;
+#endif
     ThreadPoolWorkQueuePtr _workQueue;
     bool _destroyed;
     const std::string _prefix;
@@ -140,6 +145,7 @@ private:
 
     friend class EventHandlerThread;
     friend class ThreadPoolCurrent;
+    friend class ThreadPoolWorkQueue;
 
     const int _size; // Number of threads that are pre-created.
     const int _sizeIO; // Maximum number of threads that can concurrently perform IO.
@@ -154,11 +160,10 @@ private:
 
     std::set<EventHandlerThreadPtr> _threads; // All threads, running or not.
     int _inUse; // Number of threads that are currently in use.
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
     int _inUseIO; // Number of threads that are currently performing IO.
     std::vector<std::pair<EventHandler*, SocketOperation> > _handlers;
     std::vector<std::pair<EventHandler*, SocketOperation> >::const_iterator _nextHandler;
-    std::set<EventHandler*> _pendingHandlers;
 #endif
 
     bool _promote;
@@ -171,14 +176,14 @@ public:
     ThreadPoolCurrent(const InstancePtr&, const ThreadPoolPtr&, const ThreadPool::EventHandlerThreadPtr&);
 
     SocketOperation operation;
-    BasicStream stream; // A per-thread stream to be used by event handlers for optimization.
+    Ice::InputStream stream; // A per-thread stream to be used by event handlers for optimization.
 
     bool ioCompleted() const
     {
         return _threadPool->ioCompleted(const_cast<ThreadPoolCurrent&>(*this));
     }
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     bool startMessage()
     {
         return _threadPool->startMessage(const_cast<ThreadPoolCurrent&>(*this));
@@ -206,7 +211,7 @@ private:
     ThreadPool::EventHandlerThreadPtr _thread;
     EventHandlerPtr _handler;
     bool _ioCompleted;
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
     bool _leader;
 #else
     DWORD _count;
@@ -215,17 +220,16 @@ private:
     friend class ThreadPool;
 };
 
-class ThreadPoolWorkQueue : public EventHandler, public IceUtil::Mutex
+class ThreadPoolWorkQueue : public EventHandler
 {
 public:
 
-    ThreadPoolWorkQueue(const InstancePtr&, Selector&);
-    ~ThreadPoolWorkQueue();
+    ThreadPoolWorkQueue(ThreadPool&);
 
     void destroy();
     void queue(const ThreadPoolWorkItemPtr&);
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     bool startAsync(SocketOperation);
     bool finishAsync(SocketOperation);
 #endif
@@ -234,19 +238,11 @@ public:
     virtual void finished(ThreadPoolCurrent&, bool);
     virtual std::string toString() const;
     virtual NativeInfoPtr getNativeInfo();
-    virtual void postMessage();
 
 private:
 
-    const InstancePtr _instance;
-    Selector& _selector;
+    ThreadPool& _threadPool;
     bool _destroyed;
-#ifdef ICE_USE_IOCP
-    AsyncInfo _info;
-#elif !defined(ICE_OS_WINRT)
-    SOCKET _fdIntrRead;
-    SOCKET _fdIntrWrite;
-#endif
     std::list<ThreadPoolWorkItemPtr> _workItems;
 };
 
@@ -257,10 +253,10 @@ private:
 //
 // An instance of the IOScope subclass must be created within the synchronization
 // of the event handler. It takes care of calling startMessage/finishMessage for
-// the IOCP implementation and ensures that finishMessage isn't called multiple 
+// the IOCP implementation and ensures that finishMessage isn't called multiple
 // times.
 //
-#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
 template<class T> class ThreadPoolMessage
 {
 public:
@@ -290,7 +286,7 @@ public:
         }
 
     private:
-        
+
         ThreadPoolMessage<T>& _message;
     };
     friend class IOScope;
@@ -309,7 +305,7 @@ private:
     ThreadPoolCurrent& _current;
 };
 
-#else 
+#else
 
 template<class T> class ThreadPoolMessage
 {
@@ -321,7 +317,7 @@ public:
 
         IOScope(ThreadPoolMessage& message) : _message(message)
         {
-            // This must be called with the handler locked. 
+            // This must be called with the handler locked.
             _finish = _message._current.startMessage();
         }
 
@@ -329,7 +325,7 @@ public:
         {
             if(_finish)
             {
-                // This must be called with the handler locked. 
+                // This must be called with the handler locked.
                 _message._current.finishMessage();
             }
         }
@@ -344,7 +340,7 @@ public:
         {
             //
             // Call finishMessage once IO is completed only if serialization is not enabled.
-            // Otherwise, finishMessage will be called when the event handler is done with 
+            // Otherwise, finishMessage will be called when the event handler is done with
             // the message (it will be called from ~ThreadPoolMessage below).
             //
             assert(_finish);
@@ -358,22 +354,22 @@ public:
     private:
 
         ThreadPoolMessage& _message;
-        bool _finish;        
+        bool _finish;
     };
     friend class IOScope;
-    
-    ThreadPoolMessage(ThreadPoolCurrent& current, const T& mutex) : 
+
+    ThreadPoolMessage(ThreadPoolCurrent& current, const T& mutex) :
         _current(current), _mutex(mutex), _finish(false)
     {
     }
-            
+
     ~ThreadPoolMessage()
     {
         if(_finish)
         {
             //
             // A ThreadPoolMessage instance must be created outside the synchronization
-            // of the event handler. We need to lock the event handler here to call 
+            // of the event handler. We need to lock the event handler here to call
             // finishMessage.
             //
 #if defined(__MINGW32__)
@@ -386,7 +382,7 @@ public:
     }
 
 private:
-    
+
     ThreadPoolCurrent& _current;
     const T& _mutex;
     bool _finish;
@@ -395,5 +391,4 @@ private:
 
 };
 
-
 #endif

data/ext/ice/cpp/src/{IceUtil → Ice}/Timer.cpp

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -9,9 +9,16 @@
 
 #include <IceUtil/Timer.h>
 #include <IceUtil/Exception.h>
+#include <Ice/ConsoleUtil.h>
 
 using namespace std;
 using namespace IceUtil;
+using namespace IceInternal;
+
+TimerTask::~TimerTask()
+{
+    // Out of line to avoid weak vtable
+}
 
 Timer::Timer() :
     Thread("IceUtil timer thread"),
@@ -75,7 +82,7 @@ Timer::schedule(const TimerTaskPtr& task, const IceUtil::Time& delay)
     bool inserted = _tasks.insert(make_pair(task, time)).second;
     if(!inserted)
     {
-        throw IllegalArgumentException(__FILE__, __LINE__, "task is already schedulded");
+        throw IllegalArgumentException(__FILE__, __LINE__, "task is already scheduled");
     }
     _tokens.insert(Token(time, IceUtil::Time(), task));
 
@@ -96,7 +103,7 @@ Timer::scheduleRepeated(const TimerTaskPtr& task, const IceUtil::Time& delay)
 
     IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
     const Token token(now + delay, delay, task);
-    if(delay > IceUtil::Time() && token.scheduledTime < now) 
+    if(delay > IceUtil::Time() && token.scheduledTime < now)
     {
         throw IllegalArgumentException(__FILE__, __LINE__, "invalid delay");
     }
@@ -104,10 +111,10 @@ Timer::scheduleRepeated(const TimerTaskPtr& task, const IceUtil::Time& delay)
     bool inserted = _tasks.insert(make_pair(task, token.scheduledTime)).second;
     if(!inserted)
     {
-        throw IllegalArgumentException(__FILE__, __LINE__, "task is already schedulded");
+        throw IllegalArgumentException(__FILE__, __LINE__, "task is already scheduled");
     }
-    _tokens.insert(token); 
-   
+    _tokens.insert(token);
+
     if(_wakeUpTime == IceUtil::Time() || token.scheduledTime < _wakeUpTime)
     {
         _monitor.notify();
@@ -168,12 +175,12 @@ Timer::run()
                     _monitor.wait();
                 }
             }
-            
+
             if(_destroyed)
             {
                 break;
             }
-            
+
             while(!_tokens.empty() && !_destroyed)
             {
                 const IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
@@ -188,22 +195,22 @@ Timer::run()
                     }
                     break;
                 }
-                
+
                 _wakeUpTime = first.scheduledTime;
-                try 
+                try
                 {
                     _monitor.timedWait(first.scheduledTime - now);
-                } 
+                }
                 catch(const IceUtil::InvalidTimeoutException&)
                 {
                     IceUtil::Time timeout = (first.scheduledTime - now) / 2;
                     while(timeout > IceUtil::Time())
                     {
-                        try 
+                        try
                         {
                             _monitor.timedWait(timeout);
                             break;
-                        } 
+                        }
                         catch(const IceUtil::InvalidTimeoutException&)
                         {
                             timeout = timeout / 2;
@@ -216,7 +223,7 @@ Timer::run()
             {
                 break;
             }
-        }     
+        }
 
         if(token.task)
         {
@@ -226,19 +233,19 @@ Timer::run()
             }
             catch(const IceUtil::Exception& e)
             {
-                cerr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what();
+                consoleErr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what();
 #ifdef __GNUC__
-                cerr << "\n" << e.ice_stackTrace();
+                consoleErr << "\n" << e.ice_stackTrace();
 #endif
-                cerr << endl;
-            } 
+                consoleErr << endl;
+            }
             catch(const std::exception& e)
             {
-                cerr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what() << endl;
-            } 
+                consoleErr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what() << endl;
+            }
             catch(...)
             {
-                cerr << "IceUtil::Timer::run(): uncaught exception" << endl;
+                consoleErr << "IceUtil::Timer::run(): uncaught exception" << endl;
             }
         }
     }

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -14,7 +14,7 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-ICE_API IceUtil::Shared* IceInternal::upCast(TraceLevels* p) { return p; }
+IceUtil::Shared* IceInternal::upCast(TraceLevels* p) { return p; }
 
 IceInternal::TraceLevels::TraceLevels(const PropertiesPtr& properties) :
     network(0),

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -18,7 +18,7 @@ namespace IceInternal
 {
 
 class TraceLevels;
-ICE_API IceUtil::Shared* upCast(TraceLevels*);
+IceUtil::Shared* upCast(TraceLevels*);
 typedef Handle<TraceLevels> TraceLevelsPtr;
 
 }

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -9,14 +9,15 @@
 
 #include <IceUtil/Mutex.h>
 #include <IceUtil/MutexPtrLock.h>
-#include <IceUtil/StringUtil.h>
+#include <Ice/StringUtil.h>
 #include <Ice/TraceUtil.h>
 #include <Ice/Instance.h>
 #include <Ice/Object.h>
 #include <Ice/Proxy.h>
 #include <Ice/TraceLevels.h>
 #include <Ice/Logger.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/Protocol.h>
 #include <Ice/ReplyStatus.h>
 #include <set>
@@ -26,18 +27,24 @@ using namespace Ice;
 using namespace IceInternal;
 
 static void
-printIdentityFacetOperation(ostream& s, BasicStream& stream)
+printIdentityFacetOperation(ostream& s, InputStream& stream)
 {
+    ToStringMode toStringMode = ICE_ENUM(ToStringMode, Unicode);
+    if(stream.instance())
+    {
+        toStringMode = stream.instance()->toStringMode();
+    }
+
     Identity identity;
     stream.read(identity);
-    s << "\nidentity = " << stream.instance()->identityToString(identity);
+    s << "\nidentity = " << Ice::identityToString(identity, toStringMode);
 
     vector<string> facet;
     stream.read(facet);
     s << "\nfacet = ";
     if(!facet.empty())
     {
-        s << IceUtilInternal::escapeString(facet[0], "");
+        s << escapeString(facet[0], "", toStringMode);
     }
 
     string operation;
@@ -66,28 +73,28 @@ getMessageTypeAsString(Byte type)
 }
 
 static void
-printRequestHeader(ostream& s, BasicStream& stream)
+printRequestHeader(ostream& s, InputStream& stream)
 {
     printIdentityFacetOperation(s, stream);
 
     Byte mode;
     stream.read(mode);
     s << "\nmode = " << static_cast<int>(mode) << ' ';
-    switch(mode)
+    switch(static_cast<OperationMode>(mode))
     {
-        case Normal:
+        case ICE_ENUM(OperationMode, Normal):
         {
             s << "(normal)";
             break;
         }
 
-        case Nonmutating:
+        case ICE_ENUM(OperationMode, Nonmutating):
         {
             s << "(nonmutating)";
             break;
         }
 
-        case Idempotent:
+        case ICE_ENUM(OperationMode, Idempotent):
         {
             s << "(idempotent)";
             break;
@@ -114,7 +121,7 @@ printRequestHeader(ostream& s, BasicStream& stream)
         }
     }
 
-    Ice::EncodingVersion v = stream.skipEncaps();
+    Ice::EncodingVersion v = stream.skipEncapsulation();
     if(v > Ice::Encoding_1_0)
     {
         s << "\nencoding = " << v;
@@ -122,7 +129,7 @@ printRequestHeader(ostream& s, BasicStream& stream)
 }
 
 static Byte
-printHeader(ostream& s, BasicStream& stream)
+printHeader(ostream& s, InputStream& stream)
 {
     Byte magicNumber;
     stream.read(magicNumber);   // Don't bother printing the magic number
@@ -187,7 +194,7 @@ printHeader(ostream& s, BasicStream& stream)
 }
 
 static void
-printRequest(ostream& s, BasicStream& stream)
+printRequest(ostream& s, InputStream& stream)
 {
     Int requestId;
     stream.read(requestId);
@@ -201,7 +208,7 @@ printRequest(ostream& s, BasicStream& stream)
 }
 
 static void
-printBatchRequest(ostream& s, BasicStream& stream)
+printBatchRequest(ostream& s, InputStream& stream)
 {
     int batchRequestNum;
     stream.read(batchRequestNum);
@@ -215,7 +222,7 @@ printBatchRequest(ostream& s, BasicStream& stream)
 }
 
 static void
-printReply(ostream& s, BasicStream& stream)
+printReply(ostream& s, InputStream& stream)
 {
     Int requestId;
     stream.read(requestId);
@@ -319,7 +326,7 @@ printReply(ostream& s, BasicStream& stream)
 
     if(replyStatus == replyOK || replyStatus == replyUserException)
     {
-        Ice::EncodingVersion v = stream.skipEncaps();
+        Ice::EncodingVersion v = stream.skipEncapsulation();
         if(v > Ice::Encoding_1_0)
         {
             s << "\nencoding = " << v;
@@ -328,7 +335,7 @@ printReply(ostream& s, BasicStream& stream)
 }
 
 static Byte
-printMessage(ostream& s, BasicStream& stream)
+printMessage(ostream& s, InputStream& stream)
 {
     Byte type = printHeader(s, stream);
 
@@ -408,29 +415,28 @@ IceInternal::traceSlicing(const char* kind, const string& typeId, const char* sl
 }
 
 void
-IceInternal::traceSend(const BasicStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
+IceInternal::traceSend(const OutputStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
 {
     if(tl->protocol >= 1)
     {
-        BasicStream& stream = const_cast<BasicStream&>(str);
-        BasicStream::Container::iterator p = stream.i;
-        stream.i = stream.b.begin();
+        OutputStream& stream = const_cast<OutputStream&>(str);
+        InputStream is(stream.instance(), stream.getEncoding(), stream);
+        is.i = is.b.begin();
 
         ostringstream s;
-        Byte type = printMessage(s, stream);
+        Byte type = printMessage(s, is);
 
         logger->trace(tl->protocolCat, "sending " + getMessageTypeAsString(type) + " " + s.str());
-        stream.i = p;
     }
 }
 
 void
-IceInternal::traceRecv(const BasicStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
+IceInternal::traceRecv(const InputStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
 {
     if(tl->protocol >= 1)
     {
-        BasicStream& stream = const_cast<BasicStream&>(str);
-        BasicStream::Container::iterator p = stream.i;
+        InputStream& stream = const_cast<InputStream&>(str);
+        InputStream::Container::iterator p = stream.i;
         stream.i = stream.b.begin();
 
         ostringstream s;
@@ -442,12 +448,29 @@ IceInternal::traceRecv(const BasicStream& str, const LoggerPtr& logger, const Tr
 }
 
 void
-IceInternal::trace(const char* heading, const BasicStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
+IceInternal::trace(const char* heading, const OutputStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
 {
     if(tl->protocol >= 1)
     {
-        BasicStream& stream = const_cast<BasicStream&>(str);
-        BasicStream::Container::iterator p = stream.i;
+        OutputStream& stream = const_cast<OutputStream&>(str);
+        InputStream is(stream.instance(), stream.getEncoding(), stream);
+        is.i = is.b.begin();
+
+        ostringstream s;
+        s << heading;
+        printMessage(s, is);
+
+        logger->trace(tl->protocolCat, s.str());
+    }
+}
+
+void
+IceInternal::trace(const char* heading, const InputStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
+{
+    if(tl->protocol >= 1)
+    {
+        InputStream& stream = const_cast<InputStream&>(str);
+        InputStream::Container::iterator p = stream.i;
         stream.i = stream.b.begin();
 
         ostringstream s;
@@ -458,4 +481,3 @@ IceInternal::trace(const char* heading, const BasicStream& str, const LoggerPtr&
         stream.i = p;
     }
 }
-