zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/include/Ice/InstanceF.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_INSTANCE_F_H
 #define ICE_INSTANCE_F_H
@@ -20,7 +15,6 @@ namespace IceInternal
 class Instance;
 ICE_API IceUtil::Shared* upCast(Instance*);
 typedef IceInternal::Handle<Instance> InstancePtr;
-
 }
 
 #endif

data/ext/ice/cpp/include/Ice/InterfaceByValue.h

@@ -0,0 +1,57 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_INTERFACE_BY_VALUE_H
+#define ICE_INTERFACE_BY_VALUE_H
+
+#include <Ice/Value.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
+
+#ifdef ICE_CPP11_MAPPING
+
+namespace Ice
+{
+
+/**
+ * Represents an instance of a Slice interface that was marshaled by value.
+ * \headerfile Ice/Ice.h
+ */
+template<typename T>
+class InterfaceByValue : public ValueHelper<InterfaceByValue<T>, Value>
+{
+public:
+    /**
+     * Obtains the Slice type ID of this exception.
+     * @return The fully-scoped type ID.
+     */
+    virtual std::string ice_id() const
+    {
+        return T::ice_staticId();
+    }
+
+    /**
+     * Obtains the Slice type ID of this exception.
+     * @return The fully-scoped type ID.
+     */
+    static const std::string& ice_staticId()
+    {
+        return T::ice_staticId();
+    }
+
+    /**
+     * Returns an empty tuple.
+     * @return The empty tuple.
+     */
+    std::tuple<> ice_tuple() const
+    {
+        return std::tie();
+    }
+};
+
+}
+
+#endif
+
+#endif

data/ext/ice/cpp/include/Ice/LocalObject.h

@@ -1,29 +1,27 @@
-// **********************************************************************
 //
-// 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_LOCAL_OBJECT_H
 #define ICE_LOCAL_OBJECT_H
 
+#if !defined(ICE_CPP11_MAPPING) || defined(ICE_BUILDING_SRC)
+//
+// Part of the C++98 mapping, and "internal" definitions when building Ice
+// with the C++11 mapping
+//
+
 #include <IceUtil/Shared.h>
 #include <Ice/LocalObjectF.h>
 
-namespace IceInternal
-{
-
-class BasicStream;
-
-}
-
 namespace Ice
 {
 
-class ICE_API LocalObject : virtual public ::IceUtil::Shared
+/**
+ * Base class for local Slice classes and interfaces.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API LocalObject : public virtual ::IceUtil::Shared
 {
 public:
 
@@ -34,3 +32,4 @@ public:
 }
 
 #endif
+#endif

data/ext/ice/cpp/include/Ice/LocalObjectF.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_LOCAL_OBJECT_F_H
 #define ICE_LOCAL_OBJECT_F_H

data/ext/ice/cpp/include/Ice/LoggerUtil.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_LOGGER_UTIL_H
 #define ICE_LOGGER_UTIL_H
@@ -18,19 +13,27 @@
 namespace Ice
 {
 
+/**
+ * Base class for logger output utility classes.
+ * \headerfile Ice/Ice.h
+ */
 class ICE_API LoggerOutputBase : private IceUtil::noncopyable
 {
 public:
 
+    /** Obtains the collected output. */
     std::string str() const;
-   
-    std::ostringstream& __str(); // For internal use only. Don't use in your code.
+
+    /// \cond INTERNAL
+    std::ostringstream& _stream(); // For internal use only. Don't use in your code.
+    /// \endcond
 
 private:
 
-    std::ostringstream _str;
+    std::ostringstream _os;
 };
 
+/// \cond INTERNAL
 ICE_API LoggerOutputBase& loggerInsert(LoggerOutputBase& out, const IceUtil::Exception& ex);
 
 template<typename T>
@@ -48,7 +51,7 @@ struct LoggerOutputInserter
     static inline LoggerOutputBase&
     insert(LoggerOutputBase& out, const T& val)
     {
-        out.__str() << val;
+        out._stream() << val;
         return out;
     }
 };
@@ -68,12 +71,18 @@ template
 inline LoggerOutputBase&
 operator<<(LoggerOutputBase& out, const T& val)
 {
-    return LoggerOutputInserter<T, IsException<T>::value>::insert(out, val); 
+    return LoggerOutputInserter<T, IsException<T>::value>::insert(out, val);
 }
 
+#ifdef ICE_CPP11_MAPPING
+template<typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type* = nullptr>
+inline LoggerOutputBase&
+operator<<(LoggerOutputBase& os, const ::std::shared_ptr<T>& p)
+#else
 template<typename T>
-inline LoggerOutputBase& 
+inline LoggerOutputBase&
 operator<<(LoggerOutputBase& os, const ::IceInternal::ProxyHandle<T>& p)
+#endif
 {
     return os << (p ? p->ice_toString() : "");
 }
@@ -81,12 +90,17 @@ operator<<(LoggerOutputBase& os, const ::IceInternal::ProxyHandle& p)
 inline LoggerOutputBase&
 operator<<(LoggerOutputBase& out, const ::std::exception& ex)
 {
-    out.__str() << ex.what();
+    out._stream() << ex.what();
     return out;
 }
 
 ICE_API LoggerOutputBase& operator<<(LoggerOutputBase&, std::ios_base& (*)(std::ios_base&));
+/// \endcond
 
+/**
+ * Collects output and flushes it via a logger method.
+ * \headerfile Ice/Ice.h
+ */
 template<class L, class LPtr, void (L::*output)(const std::string&)>
 class LoggerOutput : public LoggerOutputBase
 {
@@ -94,57 +108,75 @@ public:
     inline LoggerOutput(const LPtr& lptr) :
         _logger(lptr)
     {}
-    
+
     inline ~LoggerOutput()
     {
         flush();
     }
 
+    /** Flushes the colleted output to the logger method. */
     inline void flush()
     {
-        std::string s = __str().str();
+        std::string s = _stream().str();
         if(!s.empty())
         {
             L& ref = *_logger;
             (ref.*output)(s);
         }
-        __str().str("");
+        _stream().str("");
     }
 
 private:
-   
+
     LPtr _logger;
 };
 
+/** Flushes output to Logger::print. */
 typedef LoggerOutput<Logger, LoggerPtr, &Logger::print> Print;
+
+/** Flushes output to Logger::warning. */
 typedef LoggerOutput<Logger, LoggerPtr, &Logger::warning> Warning;
+
+/** Flushes output to Logger::error. */
 typedef LoggerOutput<Logger, LoggerPtr, &Logger::error> Error;
 
+/**
+ * Flushes output to Logger::trace.
+ * \headerfile Ice/Ice.h
+ */
 class ICE_API Trace : public LoggerOutputBase
 {
 public:
     Trace(const LoggerPtr&, const std::string&);
     ~Trace();
     void flush();
-   
+
 private:
-    
+
     LoggerPtr _logger;
     std::string _category;
 };
 
-//
-// A special plug-in that installs a logger during a communicator's initialization.
-// Both initialize and destroy are no-op. See Ice::InitializationData.
-//
+/**
+ * A special plug-in that installs a logger during a communicator's initialization.
+ * Both initialize and destroy are no-op. See Ice::InitializationData.
+ * \headerfile Ice/Ice.h
+ */
 class ICE_API LoggerPlugin : public Ice::Plugin
 {
 public:
 
-    LoggerPlugin(const CommunicatorPtr& communicator, const LoggerPtr&);
+    /**
+     * Constructs the plug-in with a target communicator and a logger.
+     * @param communicator The communicator in which to install the logger.
+     * @param logger The logger to be installed.
+     */
+    LoggerPlugin(const CommunicatorPtr& communicator, const LoggerPtr& logger);
 
+    /** This method is a no-op. */
     virtual void initialize();
 
+    /** This method is a no-op. */
     virtual void destroy();
 };
 

data/ext/ice/cpp/include/Ice/MetricsAdminI.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_METRICSADMIN_I_H
 #define ICE_METRICSADMIN_I_H
@@ -17,7 +12,7 @@
 #include <Ice/Metrics.h>
 
 #ifdef _MSC_VER
-#  define ICE_CPP11_REGEXP
+#  define ICE_CPP11_COMPILER_REGEXP
 #endif
 
 #ifdef __MINGW32__
@@ -25,7 +20,7 @@
     // No regexp support with MinGW, when MinGW C++11 mode is not experimental
     // we can use std::regex.
     //
-#elif defined(ICE_CPP11_REGEXP)
+#elif defined(ICE_CPP11_COMPILER_REGEXP)
 #  include <regex>
 #else
 #  include <regex.h>
@@ -36,22 +31,32 @@
 namespace IceMX
 {
 
+/// \cond INTERNAL
 class Updater;
 template<typename T> class MetricsHelperT;
+/// \endcond
 
 }
 
 namespace IceInternal
 {
 
-class ICE_API MetricsMapI : public IceUtil::Shared
+class ICE_API MetricsMapI;
+ICE_DEFINE_PTR(MetricsMapIPtr, MetricsMapI);
+
+class ICE_API MetricsMapI :
+#ifdef ICE_CPP11_MAPPING
+        public std::enable_shared_from_this<MetricsMapI>
+#else
+        public virtual IceUtil::Shared
+#endif
 {
 public:
 
     class ICE_API RegExp : public IceUtil::Shared
     {
     public:
-        
+
         RegExp(const std::string&, const std::string&);
         ~RegExp();
 
@@ -73,7 +78,7 @@ public:
     private:
 
         bool match(const std::string&);
-        
+
         const std::string _attribute;
 
 #ifdef __MINGW32__
@@ -81,7 +86,7 @@ public:
     // No regexp support with MinGW, when MinGW C++11 mode is not experimental
     // we can use std::regex.
     //
-#elif defined(ICE_CPP11_REGEXP)
+#elif defined(ICE_CPP11_COMPILER_REGEXP)
 #   if _MSC_VER < 1600
         std::tr1::regex _regex;
 #   else
@@ -89,9 +94,11 @@ public:
 #   endif
 #else
         regex_t _preg;
-#endif        
+#endif
     };
-    typedef IceUtil::Handle<RegExp> RegExpPtr;
+    ICE_DEFINE_PTR(RegExpPtr, RegExp);
+
+    virtual ~MetricsMapI();
 
     MetricsMapI(const std::string&, const Ice::PropertiesPtr&);
     MetricsMapI(const MetricsMapI&);
@@ -102,7 +109,7 @@ public:
     virtual IceMX::MetricsFailures getFailures(const std::string&) = 0;
     virtual IceMX::MetricsMap getMetrics() const = 0;
 
-    virtual MetricsMapI* clone() const = 0;
+    virtual MetricsMapIPtr clone() const = 0;
 
     const Ice::PropertyDict& getProperties() const;
 
@@ -115,43 +122,52 @@ protected:
     const std::vector<RegExpPtr> _accept;
     const std::vector<RegExpPtr> _reject;
 };
-typedef IceUtil::Handle<MetricsMapI> MetricsMapIPtr;
 
-class ICE_API MetricsMapFactory : public Ice::LocalObject
+class ICE_API MetricsMapFactory
+#ifndef ICE_CPP11_MAPPING
+    : public Ice::LocalObject
+#endif
 {
 public:
 
+    virtual ~MetricsMapFactory();
+
     MetricsMapFactory(IceMX::Updater*);
 
     virtual MetricsMapIPtr create(const std::string&, const Ice::PropertiesPtr&) = 0;
-    
+
     void update();
 
 private:
-    
+
     IceMX::Updater* _updater;
 };
-typedef IceUtil::Handle<MetricsMapFactory> MetricsMapFactoryPtr;
+ICE_DEFINE_PTR(MetricsMapFactoryPtr, MetricsMapFactory);
 
 template<class MetricsType> class MetricsMapT : public MetricsMapI, private IceUtil::Mutex
 {
 public:
 
     typedef MetricsType T;
-    typedef IceInternal::Handle<MetricsType> TPtr;
+    typedef ICE_INTERNAL_HANDLE<MetricsType> TPtr;
 
-    typedef IceUtil::Handle<MetricsMapT> MetricsMapTPtr;
+    ICE_DEFINE_PTR(MetricsMapTPtr, MetricsMapT);
 
     typedef IceMX::MetricsMap MetricsType::* SubMapMember;
 
     class EntryT;
-    typedef IceUtil::Handle<EntryT> EntryTPtr;
+    ICE_DEFINE_PTR(EntryTPtr, EntryT);
 
-    class EntryT : public Ice::LocalObject
+    class EntryT :
+#ifdef ICE_CPP11_MAPPING
+        public std::enable_shared_from_this<EntryT>
+#else
+        public Ice::LocalObject
+#endif
     {
     public:
 
-        EntryT(MetricsMapT* map, const TPtr& object, const typename std::list<EntryTPtr>::iterator& p) : 
+        EntryT(MetricsMapTPtr map, const TPtr& object, const typename std::list<EntryTPtr>::iterator& p) :
             _map(map), _object(object), _detachedPos(p)
         {
         }
@@ -166,7 +182,7 @@ public:
             }
         }
 
-        void  
+        void
         failed(const std::string& exceptionName)
         {
             IceUtil::Mutex::Lock sync(*_map);
@@ -180,7 +196,7 @@ public:
             MetricsMapIPtr m;
             {
                 IceUtil::Mutex::Lock sync(*_map);
-                typename std::map<std::string, std::pair<MetricsMapIPtr, SubMapMember> >::iterator p = 
+                typename std::map<std::string, std::pair<MetricsMapIPtr, SubMapMember> >::iterator p =
                     _subMaps.find(mapName);
                 if(p == _subMaps.end())
                 {
@@ -196,7 +212,7 @@ public:
                 }
                 m = p->second.first;
             }
-                
+
             MetricsMapT<MemberMetricsType>* map = dynamic_cast<MetricsMapT<MemberMetricsType>*>(m.get());
             assert(map);
             return map->getMatching(helper);
@@ -209,7 +225,11 @@ public:
             _object->totalLifetime += lifetime;
             if(--_object->current == 0)
             {
+#ifdef ICE_CPP11_MAPPING
+                _map->detached(this->shared_from_this());
+#else
                 _map->detached(this);
+#endif
             }
         }
 
@@ -228,7 +248,6 @@ public:
 
     private:
 
-
         IceMX::MetricsFailures
         getFailures() const
         {
@@ -241,7 +260,7 @@ public:
         IceMX::MetricsPtr
         clone() const
         {
-            TPtr metrics = TPtr::dynamicCast(_object->ice_clone());
+            TPtr metrics = ICE_DYNAMIC_CAST(T, _object->ice_clone());
             for(typename std::map<std::string, std::pair<MetricsMapIPtr, SubMapMember> >::const_iterator p =
                     _subMaps.begin(); p != _subMaps.end(); ++p)
             {
@@ -250,7 +269,7 @@ public:
             return metrics;
         }
 
-        bool 
+        bool
         isDetached() const
         {
             return _object->current == 0;
@@ -274,7 +293,7 @@ public:
 
     MetricsMapT(const std::string& mapPrefix,
                 const Ice::PropertiesPtr& properties,
-                const std::map<std::string, std::pair<SubMapMember, MetricsMapFactoryPtr> >& subMaps) : 
+                const std::map<std::string, std::pair<SubMapMember, MetricsMapFactoryPtr> >& subMaps) :
         MetricsMapI(mapPrefix, properties), _destroyed(false)
     {
         std::vector<std::string> subMapNames;
@@ -295,17 +314,31 @@ public:
                     continue; // This sub-map isn't configured.
                 }
             }
-            _subMaps.insert(std::make_pair(p->first, 
-                                           std::make_pair(p->second.first, 
+            _subMaps.insert(std::make_pair(p->first,
+                                           std::make_pair(p->second.first,
                                                           p->second.second->create(subMapPrefix, properties))));
         }
     }
 
-    MetricsMapT(const MetricsMapT& other) : MetricsMapI(other), _destroyed(false)
+    MetricsMapT(const MetricsMapT& other)
+        :
+#ifndef ICE_CPP11_MAPPING
+        IceUtil::Shared(),
+#endif
+        MetricsMapI(other),
+        IceUtil::Mutex(),
+        _destroyed(false)
+    {
+    }
+
+#ifdef ICE_CPP11_MAPPING
+    std::shared_ptr<MetricsMapT> shared_from_this()
     {
+        return std::static_pointer_cast<MetricsMapT>(MetricsMapI::shared_from_this());
     }
+#endif
 
-    virtual void 
+    virtual void
     destroy()
     {
         Lock sync(*this);
@@ -318,7 +351,7 @@ public:
     getMetrics() const
     {
         IceMX::MetricsMap objects;
-        
+
         Lock sync(*this);
         for(typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
@@ -326,12 +359,12 @@ public:
         }
         return objects;
     }
-    
+
     virtual IceMX::MetricsFailuresSeq
     getFailures()
     {
         IceMX::MetricsFailuresSeq failures;
-        
+
         Lock sync(*this);
         for(typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.begin(); p != _objects.end(); ++p)
         {
@@ -343,7 +376,7 @@ public:
         }
         return failures;
     }
-    
+
     virtual IceMX::MetricsFailures
     getFailures(const std::string& id)
     {
@@ -356,7 +389,6 @@ public:
         return IceMX::MetricsFailures();
     }
 
-
     std::pair<MetricsMapIPtr, SubMapMember>
     createSubMap(const std::string& subMapName)
     {
@@ -364,9 +396,9 @@ public:
             _subMaps.find(subMapName);
         if(p != _subMaps.end())
         {
-            return std::pair<MetricsMapIPtr, SubMapMember>(p->second.second->clone(), p->second.first);
+            return std::pair<MetricsMapIPtr, SubMapMember>(ICE_GET_SHARED_FROM_THIS(p->second.second->clone()), p->second.first);
         }
-        return std::pair<MetricsMapIPtr, SubMapMember>(MetricsMapIPtr(), static_cast<SubMapMember>(0));
+        return std::pair<MetricsMapIPtr, SubMapMember>(MetricsMapIPtr(ICE_NULLPTR), static_cast<SubMapMember>(0));
     }
 
     EntryTPtr
@@ -379,15 +411,15 @@ public:
         {
             if(!(*p)->match(helper, false))
             {
-                return 0;
+                return ICE_NULLPTR;
             }
         }
-        
+
         for(std::vector<RegExpPtr>::const_iterator p = _reject.begin(); p != _reject.end(); ++p)
         {
             if((*p)->match(helper, true))
             {
-                return 0;
+                return ICE_NULLPTR;
             }
         }
 
@@ -419,16 +451,16 @@ public:
         }
         catch(const std::exception&)
         {
-            return 0;
+            return ICE_NULLPTR;
         }
 
         //
         // Lookup the metrics object.
-        // 
+        //
         Lock sync(*this);
         if(_destroyed)
         {
-            return 0;
+            return ICE_NULLPTR;
         }
 
         if(previous && previous->_object->id == key)
@@ -440,23 +472,30 @@ public:
         typename std::map<std::string, EntryTPtr>::const_iterator p = _objects.find(key);
         if(p == _objects.end())
         {
-            TPtr t = new T();
+            TPtr t = ICE_MAKE_SHARED(T);
             t->id = key;
+
+#ifdef ICE_CPP11_MAPPING
+            p = _objects.insert(typename std::map<std::string, EntryTPtr>::value_type(
+                key, std::make_shared<EntryT>(shared_from_this(), t, _detachedQueue.end()))).first;
+#else
             p = _objects.insert(typename std::map<std::string, EntryTPtr>::value_type(
-                                    key, new EntryT(this, t, _detachedQueue.end()))).first;
+                key, new EntryT(this, t, _detachedQueue.end()))).first;
+#endif
+
         }
         p->second->attach(helper);
         return p->second;
     }
-    
+
 private:
 
-    virtual MetricsMapI* clone() const
+    virtual MetricsMapIPtr clone() const
     {
-        return new MetricsMapT<MetricsType>(*this);
+        return ICE_MAKE_SHARED(MetricsMapT<MetricsType>, *this);
     }
 
-    void detached(EntryT* entry)
+    void detached(EntryTPtr entry)
     {
         // This is called with the map mutex locked.
 
@@ -529,14 +568,14 @@ public:
     virtual MetricsMapIPtr
     create(const std::string& mapPrefix, const Ice::PropertiesPtr& properties)
     {
-        return new MetricsMapT<MetricsType>(mapPrefix, properties, _subMaps);
+        return ICE_MAKE_SHARED(MetricsMapT<MetricsType>, mapPrefix, properties, _subMaps);
     }
 
     template<class SubMapMetricsType> void
     registerSubMap(const std::string& subMap, IceMX::MetricsMap MetricsType::* member)
     {
-        _subMaps[subMap] = std::pair<IceMX::MetricsMap MetricsType::*, 
-                                     MetricsMapFactoryPtr>(member, new MetricsMapFactoryT<SubMapMetricsType>(0));
+        _subMaps[subMap] = std::pair<IceMX::MetricsMap MetricsType::*,
+                                     MetricsMapFactoryPtr>(member, ICE_MAKE_SHARED(MetricsMapFactoryT<SubMapMetricsType>, ICE_NULLPTR));
     }
 
 private:
@@ -547,12 +586,12 @@ private:
 class MetricsViewI : public IceUtil::Shared
 {
 public:
-    
+
     MetricsViewI(const std::string&);
 
     void destroy();
 
-    bool addOrUpdateMap(const Ice::PropertiesPtr&, const std::string&, const MetricsMapFactoryPtr&, 
+    bool addOrUpdateMap(const Ice::PropertiesPtr&, const std::string&, const MetricsMapFactoryPtr&,
                         const Ice::LoggerPtr&);
     bool removeMap(const std::string&);
 
@@ -569,9 +608,12 @@ private:
     const std::string _name;
     std::map<std::string, MetricsMapIPtr> _maps;
 };
-typedef IceUtil::Handle<MetricsViewI> MetricsViewIPtr;
+ICE_DEFINE_PTR(MetricsViewIPtr, MetricsViewI);
 
-class ICE_API MetricsAdminI : public IceMX::MetricsAdmin, public Ice::PropertiesAdminUpdateCallback,
+class ICE_API MetricsAdminI : public IceMX::MetricsAdmin,
+#ifndef ICE_CPP11_MAPPING
+                              public Ice::PropertiesAdminUpdateCallback,
+#endif
                               private IceUtil::Mutex
 {
 public:
@@ -583,14 +625,14 @@ public:
 
     void updateViews();
 
-    template<class MetricsType> void 
+    template<class MetricsType> void
     registerMap(const std::string& map, IceMX::Updater* updater)
     {
         bool updated;
         MetricsMapFactoryPtr factory;
         {
             Lock sync(*this);
-            factory = new MetricsMapFactoryT<MetricsType>(updater);
+            factory = ICE_MAKE_SHARED(MetricsMapFactoryT<MetricsType>, updater);
             _factories[map] = factory;
             updated = addOrUpdateMap(map, factory);
         }
@@ -604,16 +646,19 @@ public:
     registerSubMap(const std::string& map, const std::string& subMap, IceMX::MetricsMap MetricsType::* member)
     {
         bool updated;
-        IceUtil::Handle<MetricsMapFactoryT<MetricsType> > factory;
+        ICE_HANDLE<MetricsMapFactoryT<MetricsType> > factory;
         {
             Lock sync(*this);
-            
             std::map<std::string, MetricsMapFactoryPtr>::const_iterator p = _factories.find(map);
             if(p == _factories.end())
             {
                 return;
             }
+#ifdef ICE_CPP11_MAPPING
+            factory = ::std::dynamic_pointer_cast<MetricsMapFactoryT<MetricsType>>(p->second);
+#else
             factory = dynamic_cast<MetricsMapFactoryT<MetricsType>*>(p->second.get());
+#endif
             factory->template registerSubMap<MemberMetricsType>(subMap, member);
             removeMap(map);
             updated = addOrUpdateMap(map, factory);
@@ -627,14 +672,24 @@ public:
     void unregisterMap(const std::string&);
 
     virtual Ice::StringSeq getMetricsViewNames(Ice::StringSeq&, const ::Ice::Current&);
+
+    void updated(const Ice::PropertyDict&);
+
+#ifdef ICE_CPP11_MAPPING
+    virtual void enableMetricsView(std::string, const ::Ice::Current&);
+    virtual void disableMetricsView(std::string, const ::Ice::Current&);
+    virtual IceMX::MetricsView getMetricsView(std::string, Ice::Long&, const ::Ice::Current&);
+    virtual IceMX::MetricsFailuresSeq getMapMetricsFailures(std::string, std::string, const ::Ice::Current&);
+    virtual IceMX::MetricsFailures getMetricsFailures(std::string, std::string, std::string, const ::Ice::Current&);
+#else
     virtual void enableMetricsView(const std::string&, const ::Ice::Current&);
     virtual void disableMetricsView(const std::string&, const ::Ice::Current&);
     virtual IceMX::MetricsView getMetricsView(const std::string&, Ice::Long&, const ::Ice::Current&);
-    virtual IceMX::MetricsFailuresSeq getMapMetricsFailures(const std::string&, const std::string&, 
+    virtual IceMX::MetricsFailuresSeq getMapMetricsFailures(const std::string&, const std::string&,
                                                             const ::Ice::Current&);
     virtual IceMX::MetricsFailures getMetricsFailures(const std::string&, const std::string&, const std::string&,
                                                       const ::Ice::Current&);
-
+#endif
     std::vector<MetricsMapIPtr> getMaps(const std::string&) const;
 
     const Ice::LoggerPtr& getLogger() const;
@@ -643,8 +698,6 @@ private:
 
     MetricsViewIPtr getMetricsView(const std::string&);
 
-    void updated(const Ice::PropertyDict&);
-
     bool addOrUpdateMap(const std::string&, const MetricsMapFactoryPtr&);
     bool removeMap(const std::string&);
 
@@ -655,7 +708,7 @@ private:
     const Ice::LoggerPtr _logger;
     Ice::PropertiesPtr _properties;
 };
-typedef IceUtil::Handle<MetricsAdminI> MetricsAdminIPtr;
+ICE_DEFINE_PTR(MetricsAdminIPtr, MetricsAdminI);
 
 };