zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Ice/LocatorInfo.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.
@@ -22,7 +22,7 @@
 #include <Ice/PropertiesF.h>
 #include <Ice/Version.h>
 
-#include <IceUtil/UniquePtr.h>
+#include <Ice/UniquePtr.h>
 
 namespace IceInternal
 {
@@ -39,14 +39,21 @@ public:
     // Returns locator info for a given locator. Automatically creates
     // the locator info if it doesn't exist yet.
     //
-    LocatorInfoPtr get(const Ice::LocatorPrx&);
+    LocatorInfoPtr get(const Ice::LocatorPrxPtr&);
 
 private:
 
     const bool _background;
 
-    std::map<Ice::LocatorPrx, LocatorInfoPtr> _table;
-    std::map<Ice::LocatorPrx, LocatorInfoPtr>::iterator _tableHint;
+#ifdef ICE_CPP11_MAPPING
+    using LocatorInfoTable = std::map<std::shared_ptr<Ice::LocatorPrx>,
+                                      LocatorInfoPtr,
+                                      Ice::TargetCompare<std::shared_ptr<Ice::LocatorPrx>, std::less>>;
+#else
+    typedef std::map<Ice::LocatorPrx, LocatorInfoPtr> LocatorInfoTable;
+#endif
+    LocatorInfoTable _table;
+    LocatorInfoTable::iterator _tableHint;
 
     std::map<std::pair<Ice::Identity, Ice::EncodingVersion>, LocatorTablePtr> _locatorTables;
 };
@@ -79,7 +86,7 @@ class LocatorInfo : public IceUtil::Shared, public IceUtil::Mutex
 {
 public:
 
-    class GetEndpointsCallback : virtual public IceUtil::Shared
+    class GetEndpointsCallback : public virtual IceUtil::Shared
     {
     public:
 
@@ -88,13 +95,13 @@ public:
     };
     typedef IceUtil::Handle<GetEndpointsCallback> GetEndpointsCallbackPtr;
 
-    class RequestCallback : virtual public IceUtil::Shared
+    class RequestCallback : public virtual IceUtil::Shared
     {
     public:
 
         RequestCallback(const ReferencePtr&, int, const GetEndpointsCallbackPtr&);
 
-        void response(const LocatorInfoPtr&, const Ice::ObjectPrx&);
+        void response(const LocatorInfoPtr&, const Ice::ObjectPrxPtr&);
         void exception(const LocatorInfoPtr&, const Ice::Exception&);
 
     private:
@@ -105,14 +112,13 @@ public:
     };
     typedef IceUtil::Handle<RequestCallback> RequestCallbackPtr;
 
-    class Request : virtual public IceUtil::Shared
+    class Request : public virtual IceUtil::Shared
     {
     public:
 
         void addCallback(const ReferencePtr&, const ReferencePtr&, int, const GetEndpointsCallbackPtr&);
-        std::vector<EndpointIPtr> getEndpoints(const ReferencePtr&, const ReferencePtr&, int, bool&);
 
-        void response(const Ice::ObjectPrx&);
+        void response(const Ice::ObjectPrxPtr&);
         void exception(const Ice::Exception&);
 
     protected:
@@ -131,39 +137,32 @@ public:
         std::vector<ReferencePtr> _wellKnownRefs;
         bool _sent;
         bool _response;
-        Ice::ObjectPrx _proxy;
-        IceUtil::UniquePtr<Ice::Exception> _exception;
+        Ice::ObjectPrxPtr _proxy;
+        IceInternal::UniquePtr<Ice::Exception> _exception;
     };
     typedef IceUtil::Handle<Request> RequestPtr;
 
-    LocatorInfo(const Ice::LocatorPrx&, const LocatorTablePtr&, bool);
+    LocatorInfo(const Ice::LocatorPrxPtr&, const LocatorTablePtr&, bool);
 
     void destroy();
 
     bool operator==(const LocatorInfo&) const;
-    bool operator!=(const LocatorInfo&) const;
     bool operator<(const LocatorInfo&) const;
 
-    const Ice::LocatorPrx& getLocator() const
+    const Ice::LocatorPrxPtr& getLocator() const
     {
         //
         // No mutex lock necessary, _locator is immutable.
         //
         return _locator;
     }
-    Ice::LocatorRegistryPrx getLocatorRegistry();
-
-    std::vector<EndpointIPtr> getEndpoints(const ReferencePtr& ref, int ttl, bool& cached)
-    {
-        return getEndpoints(ref, 0, ttl, cached);
-    }
-    std::vector<EndpointIPtr> getEndpoints(const ReferencePtr&, const ReferencePtr&, int, bool&);
+    Ice::LocatorRegistryPrxPtr getLocatorRegistry();
 
-    void getEndpointsWithCallback(const ReferencePtr& ref, int ttl, const GetEndpointsCallbackPtr& cb)
+    void getEndpoints(const ReferencePtr& ref, int ttl, const GetEndpointsCallbackPtr& cb)
     {
-        getEndpointsWithCallback(ref, 0, ttl, cb);
+        getEndpoints(ref, 0, ttl, cb);
     }
-    void getEndpointsWithCallback(const ReferencePtr&, const ReferencePtr&, int, const GetEndpointsCallbackPtr&);
+    void getEndpoints(const ReferencePtr&, const ReferencePtr&, int, const GetEndpointsCallbackPtr&);
 
     void clearCache(const ReferencePtr&);
 
@@ -172,16 +171,17 @@ private:
     void getEndpointsException(const ReferencePtr&, const Ice::Exception&);
     void getEndpointsTrace(const ReferencePtr&, const std::vector<EndpointIPtr>&, bool);
     void trace(const std::string&, const ReferencePtr&, const std::vector<EndpointIPtr>&);
+    void trace(const std::string&, const ReferencePtr&, const ReferencePtr&);
 
     RequestPtr getAdapterRequest(const ReferencePtr&);
     RequestPtr getObjectRequest(const ReferencePtr&);
 
-    void finishRequest(const ReferencePtr&, const std::vector<ReferencePtr>&, const Ice::ObjectPrx&, bool);
+    void finishRequest(const ReferencePtr&, const std::vector<ReferencePtr>&, const Ice::ObjectPrxPtr&, bool);
     friend class Request;
     friend class RequestCallback;
 
-    const Ice::LocatorPrx _locator;
-    Ice::LocatorRegistryPrx _locatorRegistry;
+    const Ice::LocatorPrxPtr _locator;
+    Ice::LocatorRegistryPrxPtr _locatorRegistry;
     const LocatorTablePtr _table;
     const bool _background;
 

data/ext/ice/cpp/src/Ice/LocatorInfoF.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/Logger.cpp

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 //
-// Ice version 3.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
@@ -23,24 +23,54 @@
 #endif
 #include <Ice/Logger.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <IceUtil/Iterator.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
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
+namespace
+{
+
+}
+
+Ice::Logger::~Logger()
+{
+}
+
+#else // C++98 mapping
+
 namespace
 {
 
 }
 
+Ice::Logger::~Logger()
+{
+}
+
 ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::Logger* p) { return p; }
+
+namespace Ice
+{
+}
+
+#endif

data/ext/ice/cpp/src/Ice/LoggerAdminI.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.
@@ -28,34 +28,48 @@ namespace
 const char* traceCategory = "Admin.Logger";
 
 class LoggerAdminI : public Ice::LoggerAdmin
+#ifdef ICE_CPP11_MAPPING
+                   , public std::enable_shared_from_this<LoggerAdminI>
+#endif
 {
 public:
 
     LoggerAdminI(const PropertiesPtr&);
-    
-    virtual void attachRemoteLogger(const RemoteLoggerPrx&, const LogMessageTypeSeq&, 
+
+#ifdef ICE_CPP11_MAPPING
+    virtual void attachRemoteLogger(shared_ptr<RemoteLoggerPrx>, LogMessageTypeSeq,
+                                    StringSeq, Int, const Current&);
+
+    virtual bool detachRemoteLogger(shared_ptr<RemoteLoggerPrx>, const Current&);
+
+    virtual LogMessageSeq getLog(LogMessageTypeSeq, StringSeq, Int, string&, const Current&);
+#else
+    virtual void attachRemoteLogger(const RemoteLoggerPrx&, const LogMessageTypeSeq&,
                                     const StringSeq&, Int, const Current&);
-    
+
     virtual bool detachRemoteLogger(const RemoteLoggerPrx&, const Current&);
-    
+
     virtual LogMessageSeq getLog(const LogMessageTypeSeq&, const StringSeq&, Int, string&, const Current&);
+#endif
 
     void destroy();
 
-    vector<RemoteLoggerPrx> log(const LogMessage&);
+    vector<RemoteLoggerPrxPtr> log(const LogMessage&);
 
-    void deadRemoteLogger(const RemoteLoggerPrx&, const LoggerPtr&, const LocalException&, const string&);
+    void deadRemoteLogger(const RemoteLoggerPrxPtr&, const LoggerPtr&, const LocalException&, const string&);
 
-    const int getTraceLevel() const
+    int getTraceLevel() const
     {
         return _traceLevel;
     }
 
 private:
 
-    bool removeRemoteLogger(const RemoteLoggerPrx&);
-    
+    bool removeRemoteLogger(const RemoteLoggerPrxPtr&);
+
+#ifndef ICE_CPP11_MAPPING // C++98 mapping begin_init callback
     void initCompleted(const AsyncResultPtr&);
+#endif
 
     IceUtil::Mutex _mutex;
     list<LogMessage> _queue;
@@ -70,7 +84,7 @@ private:
 
     struct ObjectIdentityCompare
     {
-        bool operator()(const RemoteLoggerPrx& lhs, const RemoteLoggerPrx& rhs) const
+        bool operator()(const RemoteLoggerPrxPtr& lhs, const RemoteLoggerPrxPtr& rhs) const
         {
             //
             // Caller should make sure that proxies are never null
@@ -93,7 +107,7 @@ private:
         const set<string> traceCategories;
     };
 
-    typedef map<RemoteLoggerPrx, Filters, ObjectIdentityCompare> RemoteLoggerMap;
+    typedef map<RemoteLoggerPrxPtr, Filters, ObjectIdentityCompare> RemoteLoggerMap;
 
     struct GetRemoteLoggerMapKey
     {
@@ -108,29 +122,31 @@ private:
     CommunicatorPtr _sendLogCommunicator;
     bool _destroyed;
 };
-typedef IceUtil::Handle<LoggerAdminI> LoggerAdminIPtr;
-
+ICE_DEFINE_PTR(LoggerAdminIPtr, LoggerAdminI);
 
 class Job : public IceUtil::Shared
 {
 public:
 
-    Job(const vector<RemoteLoggerPrx>& r, const LogMessage& l) :
+    Job(const vector<RemoteLoggerPrxPtr>& r, const LogMessage& l) :
         remoteLoggers(r),
         logMessage(l)
     {
     }
 
-    const vector<RemoteLoggerPrx> remoteLoggers;
+    const vector<RemoteLoggerPrxPtr> remoteLoggers;
     const LogMessage logMessage;
 };
 typedef IceUtil::Handle<Job> JobPtr;
 
-
 class LoggerAdminLoggerI : public IceInternal::LoggerAdminLogger
+#ifdef ICE_CPP11_MAPPING
+                         , public std::enable_shared_from_this<LoggerAdminLoggerI>
+#endif
+
 {
 public:
-    
+
     LoggerAdminLoggerI(const PropertiesPtr&, const LoggerPtr&);
 
     virtual void print(const std::string&);
@@ -141,22 +157,23 @@ public:
     virtual LoggerPtr cloneWithPrefix(const std::string&);
 
     virtual ObjectPtr getFacet() const;
-   
+
     virtual void destroy();
 
     const LoggerPtr& getLocalLogger() const
     {
         return _localLogger;
     }
- 
+
     void run();
 
 private:
 
     void log(const LogMessage&);
-
+#ifndef ICE_CPP11_MAPPING // C++98 mapping begin_log callback
     void logCompleted(const AsyncResultPtr&);
-    
+#endif
+
     LoggerPtr _localLogger;
     const LoggerAdminIPtr _loggerAdmin;
 
@@ -164,10 +181,9 @@ private:
 
     bool _destroyed;
     IceUtil::ThreadPtr _sendLogThread;
-    std::deque<JobPtr> _jobQueue;   
+    std::deque<JobPtr> _jobQueue;
 };
-typedef IceUtil::Handle<LoggerAdminLoggerI> LoggerAdminLoggerIPtr;
-
+ICE_DEFINE_PTR(LoggerAdminLoggerIPtr, LoggerAdminLoggerI);
 
 class SendLogThread : public IceUtil::Thread
 {
@@ -182,7 +198,6 @@ private:
     LoggerAdminLoggerIPtr _logger;
 };
 
-
 //
 // Helper functions
 //
@@ -195,7 +210,7 @@ filterLogMessages(LogMessageSeq& logMessages, const set<LogMessageType>& message
                   const set<string>& traceCategories, Int messageMax)
 {
     assert(!logMessages.empty() && messageMax != 0);
-   
+
     //
     // Filter only if one of the 3 filters is set; messageMax < 0 means "give me all"
     // that match the other filters, if any.
@@ -209,7 +224,7 @@ filterLogMessages(LogMessageSeq& logMessages, const set<LogMessageType>& message
             bool keepIt = false;
             if(messageTypes.empty() || messageTypes.count(p->type) != 0)
             {
-                if(p->type != TraceMessage || traceCategories.empty() ||
+                if(p->type != ICE_ENUM(LogMessageType, TraceMessage) || traceCategories.empty() ||
                    traceCategories.count(p->traceCategory) != 0)
                 {
                     keepIt = true;
@@ -246,15 +261,15 @@ filterLogMessages(LogMessageSeq& logMessages, const set<LogMessageType>& message
 //
 // Change this proxy's communicator, while keeping its invocation timeout
 //
-RemoteLoggerPrx
-changeCommunicator(const RemoteLoggerPrx& prx, const CommunicatorPtr& communicator)
+RemoteLoggerPrxPtr
+changeCommunicator(const RemoteLoggerPrxPtr& prx, const CommunicatorPtr& communicator)
 {
     if(prx == 0)
     {
         return 0;
     }
 
-    RemoteLoggerPrx result = RemoteLoggerPrx::uncheckedCast(communicator->stringToProxy(prx->ice_toString()));
+    RemoteLoggerPrxPtr result = ICE_UNCHECKED_CAST(RemoteLoggerPrx, communicator->stringToProxy(prx->ice_toString()));
 
     return result->ice_invocationTimeout(prx->ice_getInvocationTimeout());
 }
@@ -301,6 +316,7 @@ createSendLogCommunicator(const CommunicatorPtr& communicator, const LoggerPtr&
         }
         initData.properties->parseCommandLineOptions("", extraProps);
     }
+
     return initialize(initData);
 }
 
@@ -312,7 +328,7 @@ LoggerAdminI::LoggerAdminI(const PropertiesPtr& props) :
     _logCount(0),
     _maxLogCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepLogs", 100)),
     _traceCount(0),
-    _maxTraceCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepTraces", 100)),   
+    _maxTraceCount(props->getPropertyAsIntWithDefault("Ice.Admin.Logger.KeepTraces", 100)),
     _traceLevel(props->getPropertyAsInt("Ice.Trace.Admin.Logger")),
     _destroyed(false)
 {
@@ -321,23 +337,31 @@ LoggerAdminI::LoggerAdminI(const PropertiesPtr& props) :
 }
 
 void
+#ifdef ICE_CPP11_MAPPING
+LoggerAdminI::attachRemoteLogger(shared_ptr<RemoteLoggerPrx> prx,
+                                 LogMessageTypeSeq messageTypes,
+                                 StringSeq categories,
+                                 Int messageMax,
+                                 const Current& current)
+#else
 LoggerAdminI::attachRemoteLogger(const RemoteLoggerPrx& prx,
                                  const LogMessageTypeSeq& messageTypes,
                                  const StringSeq& categories,
                                  Int messageMax,
                                  const Current& current)
+#endif
 {
     if(!prx)
     {
         return; // can't send this null RemoteLogger anything!
     }
-    
+
     //
     // In C++, LoggerAdminI does not keep a "logger" data member to avoid a hard-to-break circular
     // reference, so we retrieve the logger from Current
     //
-    
-    LoggerAdminLoggerIPtr logger = LoggerAdminLoggerIPtr::dynamicCast(current.adapter->getCommunicator()->getLogger());
+
+    LoggerAdminLoggerIPtr logger = ICE_DYNAMIC_CAST(LoggerAdminLoggerI, current.adapter->getCommunicator()->getLogger());
     if(!logger)
     {
         // Our logger is not installed - must be a bug
@@ -345,7 +369,7 @@ LoggerAdminI::attachRemoteLogger(const RemoteLoggerPrx& prx,
         return;
     }
 
-    RemoteLoggerPrx remoteLogger = prx->ice_twoway();
+    RemoteLoggerPrxPtr remoteLogger = prx->ice_twoway();
 
     Filters filters(messageTypes, categories);
     LogMessageSeq initLogMessages;
@@ -391,8 +415,38 @@ LoggerAdminI::attachRemoteLogger(const RemoteLoggerPrx& prx,
         filterLogMessages(initLogMessages, filters.messageTypes, filters.traceCategories, messageMax);
     }
 
+#ifdef ICE_CPP11_MAPPING
+    try
+    {
+        auto self = shared_from_this();
+        remoteLogger->initAsync(logger->getPrefix(), initLogMessages,
+            [self, logger, remoteLogger]()
+            {
+                if(self->_traceLevel > 1)
+                {
+                    Trace trace(logger, traceCategory);
+                    trace << "init on `" << remoteLogger << "' completed successfully";
+                }
+            },
+            [self, logger, remoteLogger](exception_ptr e)
+            {
+                try
+                {
+                    rethrow_exception(e);
+                }
+                catch(const Ice::LocalException& e)
+                {
+                    self->deadRemoteLogger(remoteLogger, logger, e, "init");
+                }
+            });
+    }
+    catch(const LocalException& ex)
+    {
+        deadRemoteLogger(remoteLogger, logger, ex, "init");
+        throw;
+    }
+#else
     CallbackPtr initCompletedCb = newCallback(this, &LoggerAdminI::initCompleted);
-
     try
     {
         remoteLogger->begin_init(logger->getPrefix(), initLogMessages, initCompletedCb, logger);
@@ -402,10 +456,15 @@ LoggerAdminI::attachRemoteLogger(const RemoteLoggerPrx& prx,
         deadRemoteLogger(remoteLogger, logger, ex, "init");
         throw;
     }
+#endif
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+LoggerAdminI::detachRemoteLogger(shared_ptr<RemoteLoggerPrx> remoteLogger, const Current& current)
+#else
 LoggerAdminI::detachRemoteLogger(const RemoteLoggerPrx& remoteLogger, const Current& current)
+#endif
 {
     if(remoteLogger == 0)
     {
@@ -429,13 +488,18 @@ LoggerAdminI::detachRemoteLogger(const RemoteLoggerPrx& remoteLogger, const Curr
             trace << "cannot detach `" << remoteLogger << "': not found";
         }
     }
-    
+
     return found;
 }
 
-LogMessageSeq 
+LogMessageSeq
+#ifdef ICE_CPP11_MAPPING
+LoggerAdminI::getLog(LogMessageTypeSeq messageTypes, StringSeq categories,
+                     Int messageMax, string& prefix, const Current& current)
+#else
 LoggerAdminI::getLog(const LogMessageTypeSeq& messageTypes, const StringSeq& categories,
                      Int messageMax, string& prefix, const Current& current)
+#endif
 {
     LogMessageSeq logMessages;
     {
@@ -449,13 +513,13 @@ LoggerAdminI::getLog(const LogMessageTypeSeq& messageTypes, const StringSeq& cat
 
     LoggerPtr logger = current.adapter->getCommunicator()->getLogger();
     prefix = logger->getPrefix();
-    
+
     if(!logMessages.empty())
     {
         Filters filters(messageTypes, categories);
         filterLogMessages(logMessages, filters.messageTypes, filters.traceCategories, messageMax);
     }
-    
+
     return logMessages;
 }
 
@@ -467,14 +531,14 @@ LoggerAdminI::destroy()
         IceUtil::Mutex::Lock lock(_mutex);
         if(!_destroyed)
         {
-            _destroyed = true; 
+            _destroyed = true;
             sendLogCommunicator = _sendLogCommunicator;
             _sendLogCommunicator = 0;
         }
     }
-    
+
     //
-    // Destroy outside lock to avoid deadlock when there are outstanding two-way log calls sent to 
+    // Destroy outside lock to avoid deadlock when there are outstanding two-way log calls sent to
     // remote logggers
     //
     if(sendLogCommunicator)
@@ -483,22 +547,22 @@ LoggerAdminI::destroy()
     }
 }
 
-vector<RemoteLoggerPrx>
+vector<RemoteLoggerPrxPtr>
 LoggerAdminI::log(const LogMessage& logMessage)
 {
-    vector<RemoteLoggerPrx> remoteLoggers;
+    vector<RemoteLoggerPrxPtr> remoteLoggers;
 
     IceUtil::Mutex::Lock lock(_mutex);
 
     //
     // Put message in _queue
     //
-    if((logMessage.type != TraceMessage && _maxLogCount > 0) ||
-       (logMessage.type == TraceMessage && _maxTraceCount > 0))
+    if((logMessage.type != ICE_ENUM(LogMessageType, TraceMessage) && _maxLogCount > 0) ||
+       (logMessage.type == ICE_ENUM(LogMessageType, TraceMessage) && _maxTraceCount > 0))
     {
         list<LogMessage>::iterator p = _queue.insert(_queue.end(), logMessage);
 
-        if(logMessage.type != TraceMessage)
+        if(logMessage.type != ICE_ENUM(LogMessageType, TraceMessage))
         {
             assert(_maxLogCount > 0);
             if(_logCount == _maxLogCount)
@@ -508,7 +572,7 @@ LoggerAdminI::log(const LogMessage& logMessage)
                 //
                 assert(_oldestLog != _queue.end());
                 _oldestLog = _queue.erase(_oldestLog);
-                while(_oldestLog != _queue.end() && _oldestLog->type == TraceMessage)
+                while(_oldestLog != _queue.end() && _oldestLog->type == ICE_ENUM(LogMessageType, TraceMessage))
                 {
                     _oldestLog++;
                 }
@@ -534,7 +598,7 @@ LoggerAdminI::log(const LogMessage& logMessage)
                 //
                 assert(_oldestTrace != _queue.end());
                 _oldestTrace = _queue.erase(_oldestTrace);
-                while(_oldestTrace != _queue.end() && _oldestTrace->type != TraceMessage)
+                while(_oldestTrace != _queue.end() && _oldestTrace->type != ICE_ENUM(LogMessageType, TraceMessage))
                 {
                     _oldestTrace++;
                 }
@@ -560,7 +624,7 @@ LoggerAdminI::log(const LogMessage& logMessage)
 
             if(filters.messageTypes.empty() || filters.messageTypes.count(logMessage.type) != 0)
             {
-                if(logMessage.type != TraceMessage || filters.traceCategories.empty() ||
+                if(logMessage.type != ICE_ENUM(LogMessageType, TraceMessage) || filters.traceCategories.empty() ||
                    filters.traceCategories.count(logMessage.traceCategory) != 0)
                 {
                     remoteLoggers.push_back(p->first);
@@ -572,7 +636,7 @@ LoggerAdminI::log(const LogMessage& logMessage)
 }
 
 void
-LoggerAdminI::deadRemoteLogger(const RemoteLoggerPrx& remoteLogger,
+LoggerAdminI::deadRemoteLogger(const RemoteLoggerPrxPtr& remoteLogger,
                                const LoggerPtr& logger,
                                const LocalException& ex,
                                const string& operation)
@@ -591,39 +655,44 @@ LoggerAdminI::deadRemoteLogger(const RemoteLoggerPrx& remoteLogger,
 }
 
 bool
-LoggerAdminI::removeRemoteLogger(const RemoteLoggerPrx& remoteLogger)
+LoggerAdminI::removeRemoteLogger(const RemoteLoggerPrxPtr& remoteLogger)
 {
     IceUtil::Mutex::Lock lock(_mutex);
     return _remoteLoggerMap.erase(remoteLogger) > 0;
 }
 
+#ifndef ICE_CPP11_MAPPING
+//
+// begin_init callback method for C++98 mapping
+//
 void
 LoggerAdminI::initCompleted(const AsyncResultPtr& r)
 {
-    RemoteLoggerPrx remoteLogger = RemoteLoggerPrx::uncheckedCast(r->getProxy());
-    
-try 
+    RemoteLoggerPrxPtr remoteLogger = ICE_UNCHECKED_CAST(RemoteLoggerPrx, r->getProxy());
+
+    try
     {
         remoteLogger->end_init(r);
 
         if(_traceLevel > 1)
         {
-            LoggerPtr logger = LoggerPtr::dynamicCast(r->getCookie());
+            LoggerPtr logger = ICE_DYNAMIC_CAST(Logger, r->getCookie());
             Trace trace(logger, traceCategory);
             trace << r->getOperation() << " on `" << remoteLogger << "' completed successfully";
         }
     }
     catch(const LocalException& ex)
     {
-        deadRemoteLogger(remoteLogger, LoggerPtr::dynamicCast(r->getCookie()), ex, r->getOperation());
+        deadRemoteLogger(remoteLogger, ICE_DYNAMIC_CAST(Logger, r->getCookie()), ex, r->getOperation());
     }
 }
+#endif
 
 //
 // LoggerAdminLoggerI
 //
 
-LoggerAdminLoggerI::LoggerAdminLoggerI(const PropertiesPtr& props, 
+LoggerAdminLoggerI::LoggerAdminLoggerI(const PropertiesPtr& props,
                                        const LoggerPtr& localLogger) :
     _loggerAdmin(new LoggerAdminI(props)),
     _destroyed(false)
@@ -648,7 +717,7 @@ LoggerAdminLoggerI::LoggerAdminLoggerI(const PropertiesPtr& props,
 void
 LoggerAdminLoggerI::print(const string& message)
 {
-   LogMessage logMessage = { PrintMessage, IceUtil::Time::now().toMicroSeconds(), "", message };
+   LogMessage logMessage = { ICE_ENUM(LogMessageType, PrintMessage), IceUtil::Time::now().toMicroSeconds(), "", message };
 
     _localLogger->print(message);
     log(logMessage);
@@ -657,7 +726,7 @@ LoggerAdminLoggerI::print(const string& message)
 void
 LoggerAdminLoggerI::trace(const string& category, const string& message)
 {
-    LogMessage logMessage = { TraceMessage, IceUtil::Time::now().toMicroSeconds(), category, message };
+    LogMessage logMessage = { ICE_ENUM(LogMessageType, TraceMessage), IceUtil::Time::now().toMicroSeconds(), category, message };
 
     _localLogger->trace(category, message);
     log(logMessage);
@@ -666,7 +735,7 @@ LoggerAdminLoggerI::trace(const string& category, const string& message)
 void
 LoggerAdminLoggerI::warning(const string& message)
 {
-    LogMessage logMessage = { WarningMessage, IceUtil::Time::now().toMicroSeconds(), "", message };
+    LogMessage logMessage = { ICE_ENUM(LogMessageType, WarningMessage), IceUtil::Time::now().toMicroSeconds(), "", message };
 
     _localLogger->warning(message);
     log(logMessage);
@@ -675,7 +744,7 @@ LoggerAdminLoggerI::warning(const string& message)
 void
 LoggerAdminLoggerI::error(const string& message)
 {
-    LogMessage logMessage = { ErrorMessage, IceUtil::Time::now().toMicroSeconds(), "", message };
+    LogMessage logMessage = { ICE_ENUM(LogMessageType, ErrorMessage), IceUtil::Time::now().toMicroSeconds(), "", message };
 
     _localLogger->error(message);
     log(logMessage);
@@ -702,7 +771,7 @@ LoggerAdminLoggerI::getFacet() const
 void
 LoggerAdminLoggerI::log(const LogMessage& logMessage)
 {
-    const vector<RemoteLoggerPrx> remoteLoggers = _loggerAdmin->log(logMessage);
+    const vector<RemoteLoggerPrxPtr> remoteLoggers = _loggerAdmin->log(logMessage);
 
     if(!remoteLoggers.empty())
     {
@@ -710,7 +779,7 @@ LoggerAdminLoggerI::log(const LogMessage& logMessage)
 
         if(!_sendLogThread)
         {
-            _sendLogThread = new SendLogThread(this);
+            _sendLogThread = new SendLogThread(ICE_SHARED_FROM_THIS);
             _sendLogThread->start();
         }
 
@@ -755,7 +824,9 @@ LoggerAdminLoggerI::run()
         trace << "send log thread started";
     }
 
+#ifndef ICE_CPP11_MAPPING
     CallbackPtr logCompletedCb = newCallback(this, &LoggerAdminLoggerI::logCompleted);
+#endif
 
     for(;;)
     {
@@ -774,7 +845,7 @@ LoggerAdminLoggerI::run()
         _jobQueue.pop_front();
         lock.release();
 
-        for(vector<RemoteLoggerPrx>::const_iterator p = job->remoteLoggers.begin(); p != job->remoteLoggers.end(); ++p)
+        for(vector<RemoteLoggerPrxPtr>::const_iterator p = job->remoteLoggers.begin(); p != job->remoteLoggers.end(); ++p)
         {
             if(_loggerAdmin->getTraceLevel() > 1)
             {
@@ -784,10 +855,39 @@ LoggerAdminLoggerI::run()
 
             try
             {
+#ifdef ICE_CPP11_MAPPING
+                RemoteLoggerPrxPtr remoteLogger = *p;
+                auto self = shared_from_this();
+                remoteLogger->logAsync(job->logMessage,
+                    [self, remoteLogger]()
+                    {
+                        if(self->_loggerAdmin->getTraceLevel() > 1)
+                        {
+                            Trace trace(self->_localLogger, traceCategory);
+                            trace << "log on `" << remoteLogger << "' completed successfully";
+                        }
+                    },
+                    [self, remoteLogger](exception_ptr e)
+                    {
+                        try
+                        {
+                            rethrow_exception(e);
+                        }
+                        catch(const CommunicatorDestroyedException&)
+                        {
+                            // expected if there are outstanding calls during communicator destruction
+                        }
+                        catch(const LocalException& ex)
+                        {
+                            self->_loggerAdmin->deadRemoteLogger(remoteLogger, self->_localLogger, ex, "log");
+                        }
+                    });
+#else
                 //
                 // *p is a proxy associated with the _sendLogCommunicator
                 //
                 (*p)->begin_log(job->logMessage, logCompletedCb);
+#endif
             }
             catch(const LocalException& ex)
             {
@@ -803,12 +903,16 @@ LoggerAdminLoggerI::run()
     }
 }
 
+#ifndef ICE_CPP11_MAPPING
+//
+// begin_log callback for C++98 mapping
+//
 void
 LoggerAdminLoggerI::logCompleted(const AsyncResultPtr& r)
 {
-    RemoteLoggerPrx remoteLogger = RemoteLoggerPrx::uncheckedCast(r->getProxy());
-    
-    try 
+    RemoteLoggerPrxPtr remoteLogger = ICE_UNCHECKED_CAST(RemoteLoggerPrx, r->getProxy());
+
+    try
     {
         remoteLogger->end_log(r);
 
@@ -827,6 +931,7 @@ LoggerAdminLoggerI::logCompleted(const AsyncResultPtr& r)
         _loggerAdmin->deadRemoteLogger(remoteLogger, _localLogger, ex, r->getOperation());
     }
 }
+#endif
 
 //
 // SendLogThread
@@ -852,11 +957,11 @@ SendLogThread::run()
 namespace IceInternal
 {
 
-LoggerAdminLoggerPtr 
-createLoggerAdminLogger(const PropertiesPtr& props, 
+LoggerAdminLoggerPtr
+createLoggerAdminLogger(const PropertiesPtr& props,
                         const LoggerPtr& localLogger)
 {
-    return new LoggerAdminLoggerI(props, localLogger);
+    return ICE_MAKE_SHARED(LoggerAdminLoggerI, props, localLogger);
 }
 
 }