1 files changed, 54 insertions, 89 deletions

diff --git a/cpp/src/IceGrid/Util.h b/cpp/src/IceGrid/Util.h
index 6f5312102c4..d2792a595da 100644
--- a/cpp/src/IceGrid/Util.h
+++ b/cpp/src/IceGrid/Util.h
@@ -5,6 +5,7 @@
 #ifndef ICE_GRID_UTIL_H
 #define ICE_GRID_UTIL_H
 
+#include <Ice/Properties.h>
 #include <IceGrid/Descriptor.h>
 #include <IceUtil/StringUtil.h>
 #include <IceGrid/Exception.h>
@@ -23,7 +24,7 @@ inline set_inserter(T& container)
 }
 
 std::string toString(const std::vector<std::string>&, const std::string& = std::string(" "));
-std::string toString(const Ice::Exception&);
+std::string toString(std::exception_ptr);
 
 std::string getProperty(const PropertyDescriptorSeq&, const std::string&, const std::string& = std::string());
 int getPropertyAsInt(const PropertyDescriptorSeq&, const std::string&, int = 0);
@@ -32,9 +33,9 @@ bool hasProperty(const PropertyDescriptorSeq&, const std::string&);
 PropertyDescriptor createProperty(const std::string&, const std::string& = std::string());
 std::string escapeProperty(const std::string&, bool = false);
 
-ObjectInfo toObjectInfo(const Ice::CommunicatorPtr&, const ObjectDescriptor&, const std::string&);
+ObjectInfo toObjectInfo(const std::shared_ptr<Ice::Communicator>&, const ObjectDescriptor&, const std::string&);
 
-void setupThreadPool(const Ice::PropertiesPtr&, const std::string&, int, int = 0, bool = false);
+void setupThreadPool(const std::shared_ptr<Ice::Properties>&, const std::string&, int, int = 0, bool = false);
 
 int getMMVersion(const std::string&);
 
@@ -45,118 +46,82 @@ Ice::StringSeq readDirectory(const std::string&);
 void createDirectory(const std::string&);
 void createDirectoryRecursive(const std::string&);
 
-template<class Function>
-struct ForEachCommunicator : std::unary_function<CommunicatorDescriptorPtr&, void>
+int secondsToInt(const std::chrono::seconds&);
+
+inline void
+forEachCommunicator(const std::shared_ptr<CommunicatorDescriptor>& descriptor,
+                    std::function<void(const std::shared_ptr<CommunicatorDescriptor>&)> callback)
 {
-    ForEachCommunicator(Function f) : _function(f)
+    callback(descriptor);
+    auto iceBox = std::dynamic_pointer_cast<IceBoxDescriptor>(descriptor);
+    if(iceBox)
     {
+        for(const auto& service : iceBox->services)
+        {
+            forEachCommunicator(service.descriptor, callback);
+        }
     }
+}
 
-    void
-    operator()(const ServiceInstanceDescriptor& descriptor)
+inline void
+forEachCommunicator(const std::shared_ptr<CommunicatorDescriptor>& oldDescriptor,
+                    const std::shared_ptr<CommunicatorDescriptor>& newDescriptor,
+                    std::function<void(const std::shared_ptr<CommunicatorDescriptor>&,
+                                       const std::shared_ptr<CommunicatorDescriptor>&)> callback)
+{
+    callback(oldDescriptor, newDescriptor);
+
+    auto oldIceBox = std::dynamic_pointer_cast<IceBoxDescriptor>(oldDescriptor);
+    auto newIceBox = std::dynamic_pointer_cast<IceBoxDescriptor>(newDescriptor);
+
+    if(oldIceBox && !newIceBox)
     {
-        assert(descriptor.descriptor);
-        operator()(descriptor.descriptor);
+        for(const auto& service : oldIceBox->services)
+        {
+            callback(service.descriptor, nullptr);
+        }
     }
-
-    void
-    operator()(const CommunicatorDescriptorPtr& descriptor)
+    else if(!oldIceBox && newIceBox)
     {
-        _function(descriptor);
-        IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(descriptor);
-        if(iceBox)
+        for(const auto& service: newIceBox->services)
         {
-            for_each(iceBox->services.begin(), iceBox->services.end(), forEachCommunicator(_function));
+            callback(nullptr, service.descriptor);
         }
     }
-
-    void
-    operator()(const CommunicatorDescriptorPtr& oldDesc, const CommunicatorDescriptorPtr& newDesc)
+    else if(oldIceBox && newIceBox)
     {
-        _function(oldDesc, newDesc);
-
-        IceBoxDescriptorPtr oldIceBox = IceBoxDescriptorPtr::dynamicCast(oldDesc);
-        IceBoxDescriptorPtr newIceBox = IceBoxDescriptorPtr::dynamicCast(newDesc);
-        ServiceInstanceDescriptorSeq::const_iterator p;
-        if(oldIceBox && !newIceBox)
+        for(const auto& oldService : oldIceBox->services)
         {
-            for(p = oldIceBox->services.begin(); p != oldIceBox->services.end(); ++p)
+            ServiceInstanceDescriptorSeq::const_iterator q;
+            for(q = newIceBox->services.begin(); q != newIceBox->services.end(); ++q)
             {
-                _function(p->descriptor, 0);
+                if(oldService.descriptor->name == q->descriptor->name)
+                {
+                    callback(oldService.descriptor, q->descriptor);
+                    break;
+                }
             }
-        }
-        else if(!oldIceBox && newIceBox)
-        {
-            for(p = newIceBox->services.begin(); p != newIceBox->services.end(); ++p)
+            if(q == newIceBox->services.end())
             {
-                _function(0, p->descriptor);
+                callback(oldService.descriptor, nullptr);
             }
         }
-        else if(oldIceBox && newIceBox)
+        for(const auto& newService : newIceBox->services)
         {
-            for(p = oldIceBox->services.begin(); p != oldIceBox->services.end(); ++p)
+            ServiceInstanceDescriptorSeq::const_iterator q;
+            for(q = oldIceBox->services.begin(); q != oldIceBox->services.end(); ++q)
             {
-                ServiceInstanceDescriptorSeq::const_iterator q;
-                for(q = newIceBox->services.begin(); q != newIceBox->services.end(); ++q)
-                {
-                    if(p->descriptor->name == q->descriptor->name)
-                    {
-                        _function(p->descriptor, q->descriptor);
-                        break;
-                    }
-                }
-                if(q == newIceBox->services.end())
+                if(newService.descriptor->name == q->descriptor->name)
                 {
-                    _function(p->descriptor, 0);
+                    break;
                 }
             }
-            for(p = newIceBox->services.begin(); p != newIceBox->services.end(); ++p)
+            if(q == oldIceBox->services.end())
             {
-                ServiceInstanceDescriptorSeq::const_iterator q;
-                for(q = oldIceBox->services.begin(); q != oldIceBox->services.end(); ++q)
-                {
-                    if(p->descriptor->name == q->descriptor->name)
-                    {
-                        break;
-                    }
-                }
-                if(q == oldIceBox->services.end())
-                {
-                    _function(0, p->descriptor);
-                }
+                callback(nullptr, newService.descriptor);
             }
         }
     }
-
-    Function _function;
-};
-
-template<typename Function> ForEachCommunicator<Function>
-inline forEachCommunicator(Function function)
-{
-    return ForEachCommunicator<Function>(function);
-}
-
-template<class T, class A>
-struct ObjFunc : std::unary_function<A, void>
-{
-    T& _obj;
-    typedef void (T::*MemberFN)(A);
-    MemberFN _mfn;
-
-public:
-
-    explicit ObjFunc(T& obj, void (T::*f)(A)) : _obj(obj), _mfn(f) { }
-    void operator()(A arg) const
-    {
-        (_obj.*_mfn)(arg);
-    }
-};
-
-template<class T, class A> ObjFunc<T, A>
-inline objFunc(T& obj, void (T::*p)(A))
-{
-    return ObjFunc<T, A>(obj, p);
 }
 
 template <class T> std::vector<std::string>