C++11 mapping for PropertiesAdminUpdateCallback

12 files changed, 246 insertions, 67 deletions

diff --git a/cpp/include/Ice/MetricsAdminI.h b/cpp/include/Ice/MetricsAdminI.h
index cda90d06061..61a6903ab47 100644
--- a/cpp/include/Ice/MetricsAdminI.h
+++ b/cpp/include/Ice/MetricsAdminI.h
@@ -601,7 +601,10 @@ private:
 };
 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:
@@ -661,6 +664,8 @@ public:
 
     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&);
@@ -684,8 +689,6 @@ private:
 
     MetricsViewIPtr getMetricsView(const std::string&);
 
-    void updated(const Ice::PropertyDict&);
-
     bool addOrUpdateMap(const std::string&, const MetricsMapFactoryPtr&);
     bool removeMap(const std::string&);
 
diff --git a/cpp/include/Ice/NativePropertiesAdmin.h b/cpp/include/Ice/NativePropertiesAdmin.h
index dc8734a35f0..681682c4ab7 100644
--- a/cpp/include/Ice/NativePropertiesAdmin.h
+++ b/cpp/include/Ice/NativePropertiesAdmin.h
@@ -33,10 +33,8 @@ namespace Ice
 // Ice ignores any exceptions raised by the callback.
 //
 
-class ICE_API PropertiesAdminUpdateCallback 
 #ifndef ICE_CPP11_MAPPING
-    : public virtual Ice::LocalObject
-#endif
+class ICE_API PropertiesAdminUpdateCallback : public virtual Ice::LocalObject
 {
 public:
 
@@ -44,7 +42,8 @@ public:
 
     virtual void updated(const PropertyDict&) = 0;
 };
-ICE_DEFINE_PTR(PropertiesAdminUpdateCallbackPtr, PropertiesAdminUpdateCallback);
+typedef IceUtil::Handle<PropertiesAdminUpdateCallback> PropertiesAdminUpdateCallbackPtr;
+#endif
 
 class ICE_API NativePropertiesAdmin
 #ifndef ICE_CPP11_MAPPING
@@ -55,8 +54,12 @@ public:
 
     virtual ~NativePropertiesAdmin();
 
+#ifdef ICE_CPP11_MAPPING
+    virtual std::function<void()> addUpdateCallback(std::function<void(const PropertyDict&)>) = 0;
+#else
     virtual void addUpdateCallback(const PropertiesAdminUpdateCallbackPtr&) = 0;
     virtual void removeUpdateCallback(const PropertiesAdminUpdateCallbackPtr&) = 0;
+#endif
 };
 ICE_DEFINE_PTR(NativePropertiesAdminPtr, NativePropertiesAdmin);
 
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index ae4a2a07a61..cd9feeca62b 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -1425,7 +1425,13 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::Communica
             //
             if(propsAdmin)
             {
+#ifdef ICE_CPP11_MAPPING
+                auto metricsAdmin = observer->getFacet();
+                propsAdmin->addUpdateCallback(
+                    [metricsAdmin](const PropertyDict& changes) { metricsAdmin->updated(changes); });
+#else
                 propsAdmin->addUpdateCallback(observer->getFacet());
+#endif
             }
         }
     }
diff --git a/cpp/src/Ice/PropertiesAdminI.cpp b/cpp/src/Ice/PropertiesAdminI.cpp
index a7e6174c79c..3b5198531dd 100644
--- a/cpp/src/Ice/PropertiesAdminI.cpp
+++ b/cpp/src/Ice/PropertiesAdminI.cpp
@@ -21,10 +21,12 @@ const char* traceCategory = "Admin.Properties";
 
 }
 
+#ifndef ICE_CPP11_MAPPING
 PropertiesAdminUpdateCallback::~PropertiesAdminUpdateCallback()
 {
     // Out of line to avoid weak vtable
 }
+#endif
 
 NativePropertiesAdmin::~NativePropertiesAdmin()
 {
@@ -198,12 +200,32 @@ PropertiesAdminI::setProperties_async(const AMD_PropertiesAdmin_setPropertiesPtr
     //
     // Copy the callbacks to allow callbacks to update the callbacks.
     //
+
+#ifdef ICE_CPP11_MAPPING
+    auto callbacks = _updateCallbacks;
+#else
     vector<PropertiesAdminUpdateCallbackPtr> callbacks = _updateCallbacks;
+#endif
+
     if(!callbacks.empty())
     {
         PropertyDict changes = added;
         changes.insert(changed.begin(), changed.end());
         changes.insert(removed.begin(), removed.end());
+
+#ifdef ICE_CPP11_MAPPING
+        for(const auto& cb: callbacks)
+        {
+            try
+            {
+                cb(changes);
+            }
+            catch(...)
+            {
+                // Ignore.
+            }
+        }
+#else
         for(vector<PropertiesAdminUpdateCallbackPtr>::const_iterator p = callbacks.begin(); p != callbacks.end(); ++p)
         {
             try
@@ -215,9 +237,33 @@ PropertiesAdminI::setProperties_async(const AMD_PropertiesAdmin_setPropertiesPtr
                 // Ignore.
             }
         }
+#endif
     }
 }
 
+
+#ifdef ICE_CPP11_MAPPING
+
+std::function<void()>
+PropertiesAdminI::addUpdateCallback(std::function<void(const Ice::PropertyDict&)> cb)
+{
+    Lock sync(*this);
+
+    auto p = _updateCallbacks.insert(_updateCallbacks.end(), std::move(cb));
+    auto propertiesAdmin = shared_from_this();
+
+    return [p, propertiesAdmin] { propertiesAdmin->removeUpdateCallback(p); };
+}
+
+void
+PropertiesAdminI::removeUpdateCallback(std::list<std::function<void(const Ice::PropertyDict&)>>::iterator p)
+{
+    Lock sync(*this);
+    _updateCallbacks.erase(p);
+}
+
+#else
+
 void
 PropertiesAdminI::addUpdateCallback(const PropertiesAdminUpdateCallbackPtr& cb)
 {
@@ -232,4 +278,6 @@ PropertiesAdminI::removeUpdateCallback(const PropertiesAdminUpdateCallbackPtr& c
     _updateCallbacks.erase(remove(_updateCallbacks.begin(), _updateCallbacks.end(), cb), _updateCallbacks.end());
 }
 
+#endif
+
 }
diff --git a/cpp/src/Ice/PropertiesAdminI.h b/cpp/src/Ice/PropertiesAdminI.h
index 6e852c7b583..8fcdc891cfe 100644
--- a/cpp/src/Ice/PropertiesAdminI.h
+++ b/cpp/src/Ice/PropertiesAdminI.h
@@ -16,36 +16,53 @@
 #include <Ice/NativePropertiesAdmin.h>
 #include <Ice/LoggerF.h>
 
+#ifdef ICE_CPP11_MAPPING
+#include <list>
+#endif
+
 namespace IceInternal
 {
 
-class PropertiesAdminI : public Ice::PropertiesAdmin, public Ice::NativePropertiesAdmin, private IceUtil::RecMutex
+class PropertiesAdminI : public Ice::PropertiesAdmin, public Ice::NativePropertiesAdmin,
+#ifdef ICE_CPP11_MAPPING
+                         public std::enable_shared_from_this<PropertiesAdminI>,
+#endif
+                         private IceUtil::RecMutex
 {
 public:
 
     PropertiesAdminI(const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
 
 #ifdef ICE_CPP11_MAPPING
-    virtual std::string getProperty(std::string, const Ice::Current&);
-    virtual Ice::PropertyDict getPropertiesForPrefix(std::string, const Ice::Current&);
+    virtual std::string getProperty(std::string, const Ice::Current&) override;
+    virtual Ice::PropertyDict getPropertiesForPrefix(std::string, const Ice::Current&) override;
     virtual void setPropertiesAsync(::Ice::PropertyDict,
                                     ::std::function<void()>,
                                     ::std::function<void(::std::exception_ptr)>,
-                                    const Ice::Current&);
+                                    const Ice::Current&) override;
+
+    virtual std::function<void()> addUpdateCallback(std::function<void(const Ice::PropertyDict&)>) override;
+    void removeUpdateCallback(std::list<std::function<void(const Ice::PropertyDict&)>>::iterator);
+
 #else
     virtual std::string getProperty(const std::string&, const Ice::Current&);
     virtual Ice::PropertyDict getPropertiesForPrefix(const std::string&, const Ice::Current&);
     virtual void setProperties_async(const Ice::AMD_PropertiesAdmin_setPropertiesPtr&, const Ice::PropertyDict&, const Ice::Current&);
-#endif
 
     virtual void addUpdateCallback(const Ice::PropertiesAdminUpdateCallbackPtr&);
     virtual void removeUpdateCallback(const Ice::PropertiesAdminUpdateCallbackPtr&);
+#endif
 
 private:
 
     const Ice::PropertiesPtr _properties;
     const Ice::LoggerPtr _logger;
+
+#ifdef ICE_CPP11_MAPPING
+    std::list<std::function<void(const Ice::PropertyDict&)>> _updateCallbacks;
+#else
     std::vector<Ice::PropertiesAdminUpdateCallbackPtr> _updateCallbacks;
+#endif
 };
 ICE_DEFINE_PTR(PropertiesAdminIPtr, PropertiesAdminI);
 
diff --git a/cpp/test/Ice/admin/AllTests.cpp b/cpp/test/Ice/admin/AllTests.cpp
index 9863fe9de20..da880fc0ced 100644
--- a/cpp/test/Ice/admin/AllTests.cpp
+++ b/cpp/test/Ice/admin/AllTests.cpp
@@ -25,7 +25,7 @@ testFacets(const Ice::CommunicatorPtr& com, bool builtInFacets = true)
         test(com->findAdminFacet("Logger"));
         test(com->findAdminFacet("Metrics"));
     }
-    
+
     TestFacetPtr f1 = ICE_MAKE_SHARED(TestFacetI);
     TestFacetPtr f2 = ICE_MAKE_SHARED(TestFacetI);
     TestFacetPtr f3 = ICE_MAKE_SHARED(TestFacetI);
@@ -40,7 +40,7 @@ testFacets(const Ice::CommunicatorPtr& com, bool builtInFacets = true)
     test(!com->findAdminFacet("Bogus"));
 
     const Ice::FacetMap facetMap = com->findAllAdminFacets();
-    
+
     if(builtInFacets)
     {
         test(facetMap.size() == 7);
@@ -56,8 +56,8 @@ testFacets(const Ice::CommunicatorPtr& com, bool builtInFacets = true)
     test(facetMap.find("Facet1") != facetMap.end());
     test(facetMap.find("Facet2") != facetMap.end());
     test(facetMap.find("Facet3") != facetMap.end());
-   
-     
+
+
     try
     {
         com->addAdminFacet(f1, "Facet1");
@@ -96,7 +96,7 @@ testFacets(const Ice::CommunicatorPtr& com, bool builtInFacets = true)
 class RemoteLoggerI : public Ice::RemoteLogger
 {
 public:
-    
+
     RemoteLoggerI();
 
     virtual void init(ICE_IN(string), ICE_IN(Ice::LogMessageSeq), const Ice::Current&);
@@ -115,7 +115,7 @@ private:
 
     string _expectedPrefix;
     Ice::LogMessageSeq _expectedInitMessages;
-    
+
     Ice::LogMessageSeq _expectedLogMessages;
 };
 
@@ -140,7 +140,7 @@ RemoteLoggerI::log(ICE_IN(Ice::LogMessage) logMessage, const Ice::Current&)
 {
     IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
     Ice::LogMessage front = _expectedLogMessages.front();
-    
+
     test(front.type == logMessage.type && front.message == logMessage.message &&
          front.traceCategory == logMessage.traceCategory);
 
@@ -158,7 +158,7 @@ RemoteLoggerI::checkNextInit(const string& prefix, const Ice::LogMessageSeq& log
 }
 
 void
-RemoteLoggerI::checkNextLog(Ice::LogMessageType messageType, const string& message, 
+RemoteLoggerI::checkNextLog(Ice::LogMessageType messageType, const string& message,
                             const string& category)
 {
     Ice::LogMessage logMessage = { messageType, 0, category, message };
@@ -238,7 +238,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         Ice::ObjectAdapterPtr adapter = com->createObjectAdapter("");
         test(com->createAdmin(adapter, id));
         test(com->getAdmin());
-       
+
         testFacets(com);
         com->destroy();
     }
@@ -346,13 +346,31 @@ allTests(const Ice::CommunicatorPtr& communicator)
         changes = com->getChanges();
         test(changes.empty());
 
+        com->removeUpdateCallback();
+        Ice::PropertyDict moreProps;
+        moreProps["Prop1"] = "11"; // Changed
+        moreProps["Prop2"] = ""; // Removed
+        moreProps["Prop6"] = "6"; // Added
+        pa->setProperties(moreProps);
+        changes = com->getChanges();
+        test(changes.empty());
+        com->addUpdateCallback();
+        pa->setProperties(moreProps);
+        changes = com->getChanges();
+        test(changes.empty());
+        moreProps["Prop1"] = "10"; // Changed back
+        pa->setProperties(moreProps);
+        changes = com->getChanges();
+        test(changes.size() == 1);
+        test(changes["Prop1"] == "10");
+
         com->destroy();
     }
     cout << "ok" << endl;
 
 #ifndef ICE_OS_WINRT
     //
-    // This doesn't work well with WinRT because connection to localhost are 
+    // This doesn't work well with WinRT because connection to localhost are
     // restricted to the same process.
     //
     cout << "testing logger facet... " << flush;
@@ -367,7 +385,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         com->warning("warning");
         com->error("error");
         com->print("print");
-       
+
         Ice::ObjectPrxPtr obj = com->getAdmin();
 #ifdef ICE_CPP11_MAPPING
         shared_ptr<Ice::LoggerAdminPrx> logger = Ice::checkedCast<Ice::LoggerAdminPrx>(obj, "Logger");
@@ -376,22 +394,22 @@ allTests(const Ice::CommunicatorPtr& communicator)
 #endif
         test(logger);
 
-        string prefix;   
+        string prefix;
 
         //
         // Get all
         //
-        Ice::LogMessageSeq logMessages = 
+        Ice::LogMessageSeq logMessages =
             logger->getLog(Ice::LogMessageTypeSeq(), Ice::StringSeq(), -1, prefix);
-        
+
         test(logMessages.size() == 4);
         test(prefix == "NullLogger");
         Ice::LogMessageSeq::const_iterator p = logMessages.begin();
-        test(p->traceCategory == "testCat" && p++->message == "trace"); 
+        test(p->traceCategory == "testCat" && p++->message == "trace");
         test(p++->message == "warning");
         test(p++->message == "error");
         test(p++->message == "print");
-       
+
         //
         // Get only errors and warnings
         //
@@ -399,12 +417,12 @@ allTests(const Ice::CommunicatorPtr& communicator)
         com->print("print2");
         com->trace("testCat", "trace2");
         com->warning("warning2");
-        
+
         Ice::LogMessageTypeSeq messageTypes;
         messageTypes.push_back(ICE_ENUM(LogMessageType, ErrorMessage));
         messageTypes.push_back(ICE_ENUM(LogMessageType, WarningMessage));
 
-        logMessages = 
+        logMessages =
             logger->getLog(messageTypes, Ice::StringSeq(), -1, prefix);
         test(logMessages.size() == 4);
         test(prefix == "NullLogger");
@@ -415,22 +433,22 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(p->type == ICE_ENUM(LogMessageType, ErrorMessage) || p->type == ICE_ENUM(LogMessageType, WarningMessage));
             ++p;
         }
-        
+
         //
         // Get only errors and traces with Cat = "testCat"
         //
         com->trace("testCat2", "A");
         com->trace("testCat", "trace3");
         com->trace("testCat2", "B");
-        
+
         messageTypes.clear();
         messageTypes.push_back(ICE_ENUM(LogMessageType, ErrorMessage));
         messageTypes.push_back(ICE_ENUM(LogMessageType, TraceMessage));
-        
+
         Ice::StringSeq categories;
         categories.push_back("testCat");
 
-        logMessages = 
+        logMessages =
             logger->getLog(messageTypes, categories, -1, prefix);
         test(logMessages.size() == 5);
         test(prefix == "NullLogger");
@@ -438,7 +456,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         p = logMessages.begin();
         while(p != logMessages.end())
         {
-            test(p->type == ICE_ENUM(LogMessageType, ErrorMessage) || 
+            test(p->type == ICE_ENUM(LogMessageType, ErrorMessage) ||
                 (p->type == ICE_ENUM(LogMessageType, TraceMessage) && p->traceCategory == "testCat"));
             ++p;
         }
@@ -447,8 +465,8 @@ allTests(const Ice::CommunicatorPtr& communicator)
         // Same, but limited to last 2 messages (trace3 + error3)
         //
         com->error("error3");
-        
-        logMessages = 
+
+        logMessages =
             logger->getLog(messageTypes, categories, 2, prefix);
         test(logMessages.size() == 2);
         test(prefix == "NullLogger");
@@ -461,22 +479,22 @@ allTests(const Ice::CommunicatorPtr& communicator)
         // Now, test RemoteLogger
         //
 
-        Ice::ObjectAdapterPtr adapter = 
+        Ice::ObjectAdapterPtr adapter =
             communicator->createObjectAdapterWithEndpoints("RemoteLoggerAdapter", "tcp -h localhost");
-   
+
         RemoteLoggerIPtr remoteLogger = ICE_MAKE_SHARED(RemoteLoggerI);
-        
-        Ice::RemoteLoggerPrxPtr myProxy = 
+
+        Ice::RemoteLoggerPrxPtr myProxy =
             ICE_UNCHECKED_CAST(Ice::RemoteLoggerPrx, adapter->addWithUUID(remoteLogger));
-        
+
         adapter->activate();
-         
+
         //
         // No filtering
         //
         logMessages = logger->getLog(Ice::LogMessageTypeSeq(), Ice::StringSeq(), -1, prefix);
         remoteLogger->checkNextInit(prefix, logMessages);
-       
+
         logger->attachRemoteLogger(myProxy, Ice::LogMessageTypeSeq(), Ice::StringSeq(), -1);
         remoteLogger->wait(1);
 
@@ -505,7 +523,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
         remoteLogger->checkNextLog(ICE_ENUM(LogMessageType, TraceMessage), "rtrace2", "testCat");
         remoteLogger->checkNextLog(ICE_ENUM(LogMessageType, ErrorMessage), "rerror2");
-     
+
         com->warning("rwarning2");
         com->trace("testCat", "rtrace2");
         com->warning("rwarning3");
diff --git a/cpp/test/Ice/admin/Test.ice b/cpp/test/Ice/admin/Test.ice
index 292269201db..02d8b851738 100644
--- a/cpp/test/Ice/admin/Test.ice
+++ b/cpp/test/Ice/admin/Test.ice
@@ -21,6 +21,9 @@ interface RemoteCommunicator
 
     Ice::PropertyDict getChanges();
 
+    void addUpdateCallback();
+    void removeUpdateCallback();
+
     //
     // Logger operations
     //
diff --git a/cpp/test/Ice/admin/TestI.cpp b/cpp/test/Ice/admin/TestI.cpp
index cc2aa92733f..b7537b54a9d 100644
--- a/cpp/test/Ice/admin/TestI.cpp
+++ b/cpp/test/Ice/admin/TestI.cpp
@@ -43,7 +43,7 @@ public:
     {
         return "NullLogger";
     }
-    
+
     virtual Ice::LoggerPtr cloneWithPrefix(const string&)
     {
         return shared_from_this();
@@ -55,7 +55,12 @@ public:
 
 
 RemoteCommunicatorI::RemoteCommunicatorI(const Ice::CommunicatorPtr& communicator) :
-    _communicator(communicator), _called(false)
+    _communicator(communicator), _called(false),
+#ifdef ICE_CPP11_MAPPING
+    _removeCallback(nullptr)
+#else
+    _hasCallback(false)
+#endif
 {
 }
 
@@ -70,21 +75,75 @@ RemoteCommunicatorI::getChanges(const Ice::Current&)
 {
     IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
 
-    //
-    // The client calls PropertiesAdmin::setProperties() and then invokes
-    // this operation. Since setProperties() is implemented using AMD, the
-    // client might receive its reply and then call getChanges() before our
-    // updated() method is called. We block here to ensure that updated()
-    // gets called before we return the most recent set of changes.
-    //
-    while(!_called)
+#ifdef ICE_CPP11_MAPPING
+    if(_removeCallback)
+#else
+    if(_hasCallback)
+#endif
+    {
+       //
+       // The client calls PropertiesAdmin::setProperties() and then invokes
+       // this operation. Since setProperties() is implemented using AMD, the
+       // client might receive its reply and then call getChanges() before our
+       // updated() method is called. We block here to ensure that updated()
+       // gets called before we return the most recent set of changes.
+       //
+       while(!_called)
+       {
+           wait();
+       }
+
+       _called = false;
+       return _changes;
+    }
+    else
     {
-        wait();
+        return Ice::PropertyDict();
     }
+}
 
-    _called = false;
+void
+RemoteCommunicatorI::addUpdateCallback(const Ice::Current&)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+
+    Ice::ObjectPtr propFacet = _communicator->findAdminFacet("Properties");
+    if(propFacet)
+    {
+        Ice::NativePropertiesAdminPtr admin = ICE_DYNAMIC_CAST(Ice::NativePropertiesAdmin, propFacet);
+        assert(admin);
+#ifdef ICE_CPP11_MAPPING
+        _removeCallback =
+            admin->addUpdateCallback([this](const Ice::PropertyDict& changes) { updated(changes); });
+#else
+        admin->addUpdateCallback(this);
+        _hasCallback = true;
+#endif
+    }
+}
+
+void
+RemoteCommunicatorI::removeUpdateCallback(const Ice::Current&)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+
+    Ice::ObjectPtr propFacet = _communicator->findAdminFacet("Properties");
+    if(propFacet)
+    {
+        Ice::NativePropertiesAdminPtr admin = ICE_DYNAMIC_CAST(Ice::NativePropertiesAdmin, propFacet);
+        assert(admin);
+#ifdef ICE_CPP11_MAPPING
+        if(_removeCallback)
+        {
+            _removeCallback();
+            _removeCallback = nullptr;
+        }
+#else
+        admin->removeUpdateCallback(this);
+        _hasCallback = false;
+#endif
+    }
 
-    return _changes;
 }
 
 void
@@ -174,13 +233,7 @@ RemoteCommunicatorFactoryI::createCommunicator(ICE_IN(Ice::PropertyDict) props,
     // Set the callback on the admin facet.
     //
     RemoteCommunicatorIPtr servant = ICE_MAKE_SHARED(RemoteCommunicatorI, communicator);
-    Ice::ObjectPtr propFacet = communicator->findAdminFacet("Properties");
-    if(propFacet)
-    {
-        Ice::NativePropertiesAdminPtr admin = ICE_DYNAMIC_CAST(Ice::NativePropertiesAdmin, propFacet);
-        assert(admin);
-        admin->addUpdateCallback(servant);
-    }
+    servant->addUpdateCallback(Ice::noExplicitCurrent);
 
     Ice::ObjectPrxPtr proxy = current.adapter->addWithUUID(servant);
     return ICE_UNCHECKED_CAST(Test::RemoteCommunicatorPrx, proxy);
diff --git a/cpp/test/Ice/admin/TestI.h b/cpp/test/Ice/admin/TestI.h
index 12e815cceac..85f9e697f6e 100644
--- a/cpp/test/Ice/admin/TestI.h
+++ b/cpp/test/Ice/admin/TestI.h
@@ -15,7 +15,9 @@
 #include <Ice/NativePropertiesAdmin.h>
 
 class RemoteCommunicatorI : public virtual Test::RemoteCommunicator,
+#ifndef ICE_CPP11_MAPPING
                             public virtual Ice::PropertiesAdminUpdateCallback,
+#endif
                             public IceUtil::Monitor<IceUtil::Mutex>
 {
 public:
@@ -25,6 +27,9 @@ public:
     virtual Ice::ObjectPrxPtr getAdmin(const Ice::Current&);
     virtual Ice::PropertyDict getChanges(const Ice::Current&);
 
+    virtual void addUpdateCallback(const Ice::Current&);
+    virtual void removeUpdateCallback(const Ice::Current&);
+
     virtual void print(ICE_IN(std::string), const Ice::Current&);
     virtual void trace(ICE_IN(std::string), ICE_IN(std::string), const Ice::Current&);
     virtual void warning(ICE_IN(std::string), const Ice::Current&);
@@ -41,6 +46,12 @@ private:
     Ice::CommunicatorPtr _communicator;
     Ice::PropertyDict _changes;
     bool _called;
+
+#ifdef ICE_CPP11_MAPPING
+    std::function<void()> _removeCallback;
+#else
+    bool _hasCallback;
+#endif
 };
 ICE_DEFINE_PTR(RemoteCommunicatorIPtr, RemoteCommunicatorI);
 
diff --git a/cpp/test/Ice/metrics/AllTests.cpp b/cpp/test/Ice/metrics/AllTests.cpp
index baed7a0cdcc..c5d692fd2d7 100644
--- a/cpp/test/Ice/metrics/AllTests.cpp
+++ b/cpp/test/Ice/metrics/AllTests.cpp
@@ -119,7 +119,11 @@ getServerConnectionMetrics(const IceMX::MetricsAdminPrxPtr& metrics, Ice::Long e
     return s;
 }
 
-class UpdateCallbackI : public Ice::PropertiesAdminUpdateCallback, private IceUtil::Monitor<IceUtil::Mutex>
+class UpdateCallbackI :
+#ifndef ICE_CPP11_MAPPING
+        public Ice::PropertiesAdminUpdateCallback,
+#endif
+private IceUtil::Monitor<IceUtil::Mutex>
 {
 public:
 
@@ -421,7 +425,13 @@ allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPt
 
     UpdateCallbackIPtr update = ICE_MAKE_SHARED(UpdateCallbackI, serverProps);
 
-    ICE_DYNAMIC_CAST(Ice::NativePropertiesAdmin, communicator->findAdminFacet("Properties"))->addUpdateCallback(update);
+    ICE_DYNAMIC_CAST(Ice::NativePropertiesAdmin, communicator->findAdminFacet("Properties"))->addUpdateCallback(
+#ifdef ICE_CPP11_MAPPING
+        [update](const Ice::PropertyDict& changes) { update->updated(changes); }
+#else
+        update
+#endif
+        );
 
     cout << "ok" << endl;
 
diff --git a/cpp/test/IceBox/admin/Service.cpp b/cpp/test/IceBox/admin/Service.cpp
index 4bb07f5e917..23c8740348a 100644
--- a/cpp/test/IceBox/admin/Service.cpp
+++ b/cpp/test/IceBox/admin/Service.cpp
@@ -58,7 +58,12 @@ ServiceI::ServiceI(const CommunicatorPtr& serviceManagerCommunicator)
     ObjectPtr propFacet = serviceManagerCommunicator->findAdminFacet("IceBox.Service.TestService.Properties");
     NativePropertiesAdminPtr admin = ICE_DYNAMIC_CAST(NativePropertiesAdmin, propFacet);
     assert(admin);
+
+#ifdef ICE_CPP11_MAPPING
+    admin->addUpdateCallback([facet](const Ice::PropertyDict& changes) { facet->updated(changes); });
+#else
     admin->addUpdateCallback(facet);
+#endif
 }
 
 ServiceI::~ServiceI()
diff --git a/cpp/test/IceBox/admin/TestI.h b/cpp/test/IceBox/admin/TestI.h
index 3b024ee4c83..2ad1b340cfd 100644
--- a/cpp/test/IceBox/admin/TestI.h
+++ b/cpp/test/IceBox/admin/TestI.h
@@ -13,7 +13,9 @@
 #include <Test.h>
 
 class TestFacetI : public virtual ::Test::TestFacet,
+#ifndef ICE_CPP11_MAPPING
                    public virtual Ice::PropertiesAdminUpdateCallback,
+#endif
                    IceUtil::Monitor<IceUtil::Mutex>
 {
 public: