zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/generated/SliceChecksumDict.cpp

@@ -1,49 +1,39 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-//
-// Ice version 3.7.11
-//
-// <auto-generated>
-//
-// Generated from file `SliceChecksumDict.ice'
-//
-// Warning: do not edit this file.
-//
-// </auto-generated>
-//
+// Copyright (c) ZeroC, Inc.
+
+// slice2cpp version 3.8.1
+// <auto-generated>Generated from Slice file 'SliceChecksumDict.ice'.</auto-generated>
 
 #ifndef ICE_API_EXPORTS
 #   define ICE_API_EXPORTS
 #endif
-#include <Ice/SliceChecksumDict.h>
-#include <IceUtil/PushDisableWarnings.h>
-#include <Ice/InputStream.h>
-#include <Ice/OutputStream.h>
-#include <IceUtil/PopDisableWarnings.h>
+#define ICE_BUILDING_GENERATED_CODE
+
+#include "Ice/SliceChecksumDict.h"
+#include <Ice/AsyncResponseHandler.h>
+#include <Ice/DefaultSliceLoader.h>
+#include <Ice/OutgoingAsync.h>
+#include <algorithm>
+#include <array>
 
 #if defined(_MSC_VER)
-#   pragma warning(disable:4458) // declaration of ... hides class member
+#   pragma warning(disable : 4458) // declaration of ... hides class member
+#   pragma warning(disable : 4996) // ... was declared deprecated
 #elif defined(__clang__)
 #   pragma clang diagnostic ignored "-Wshadow"
+#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #elif defined(__GNUC__)
 #   pragma GCC diagnostic ignored "-Wshadow"
+#   pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-#ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 307
+#ifndef ICE_DISABLE_VERSION
+#   if ICE_INT_VERSION / 100 != 308
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 11
+#   if ICE_INT_VERSION % 100 < 1
 #       error Ice patch level mismatch!
 #   endif
 #endif
-
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-
-#else // C++98 mapping
-
-#endif

data/dist/ice/cpp/src/Ice/generated/Version.cpp

@@ -1,57 +1,54 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-//
-// Ice version 3.7.11
-//
-// <auto-generated>
-//
-// Generated from file `Version.ice'
-//
-// Warning: do not edit this file.
-//
-// </auto-generated>
-//
+// Copyright (c) ZeroC, Inc.
+
+// slice2cpp version 3.8.1
+// <auto-generated>Generated from Slice file 'Version.ice'.</auto-generated>
 
 #ifndef ICE_API_EXPORTS
 #   define ICE_API_EXPORTS
 #endif
-#include <Ice/Version.h>
-#include <IceUtil/PushDisableWarnings.h>
-#include <Ice/InputStream.h>
-#include <Ice/OutputStream.h>
-#include <IceUtil/PopDisableWarnings.h>
+#define ICE_BUILDING_GENERATED_CODE
+
+#include "Ice/Version.h"
+#include <Ice/Ice.h>
+#include <Ice/AsyncResponseHandler.h>
+#include <Ice/DefaultSliceLoader.h>
+#include <Ice/OutgoingAsync.h>
+#include <algorithm>
+#include <array>
 
 #if defined(_MSC_VER)
-#   pragma warning(disable:4458) // declaration of ... hides class member
+#   pragma warning(disable : 4458) // declaration of ... hides class member
+#   pragma warning(disable : 4996) // ... was declared deprecated
 #elif defined(__clang__)
 #   pragma clang diagnostic ignored "-Wshadow"
+#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #elif defined(__GNUC__)
 #   pragma GCC diagnostic ignored "-Wshadow"
+#   pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-#ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 307
+#ifndef ICE_DISABLE_VERSION
+#   if ICE_INT_VERSION / 100 != 308
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 11
+#   if ICE_INT_VERSION % 100 < 1
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-
-namespace Ice
+void
+Ice::ProtocolVersion::ice_printFields(std::ostream& os) const
 {
+    Ice::print(os << "major = ", this->major);
+    Ice::print(os << ", minor = ", this->minor);
 }
 
-#else // C++98 mapping
-
-namespace Ice
+void
+Ice::EncodingVersion::ice_printFields(std::ostream& os) const
 {
+    Ice::print(os << "major = ", this->major);
+    Ice::print(os << ", minor = ", this->minor);
 }
-
-#endif

data/dist/ice/cpp/src/IceDiscovery/LocatorI.cpp

@@ -1,15 +1,11 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceDiscovery/LocatorI.h>
-#include <IceDiscovery/LookupI.h>
-
-#include <Ice/LocalException.h>
-#include <Ice/Communicator.h>
-#include <Ice/ObjectAdapter.h>
-
-#include <IceUtil/Random.h>
+#include "LocatorI.h"
+#include "../Ice/Random.h"
+#include "Ice/Communicator.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/ObjectAdapter.h"
+#include "LookupI.h"
 
 #include <iterator>
 
@@ -17,66 +13,39 @@ using namespace std;
 using namespace Ice;
 using namespace IceDiscovery;
 
-LocatorRegistryI::LocatorRegistryI(const Ice::CommunicatorPtr& com) :
-    _wellKnownProxy(com->stringToProxy("p")->ice_locator(0)->ice_router(0)->ice_collocationOptimized(true))
+LocatorRegistryI::LocatorRegistryI(const Ice::CommunicatorPtr& communicator)
+    : _wellKnownProxy{
+          ObjectPrx{communicator, "dummy"}.ice_locator(nullopt).ice_router(nullopt).ice_collocationOptimized(true)}
 {
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
-LocatorRegistryI::setAdapterDirectProxyAsync(string adapterId,
-                                              shared_ptr<ObjectPrx> proxy,
-                                              function<void()> response,
-                                              function<void(exception_ptr)>,
-                                              const Ice::Current&)
-#else
-void
-LocatorRegistryI::setAdapterDirectProxy_async(const AMD_LocatorRegistry_setAdapterDirectProxyPtr& cb,
-                                              const std::string& adapterId,
-                                              const ObjectPrxPtr& proxy,
-                                              const Current&)
-#endif
+LocatorRegistryI::setAdapterDirectProxy(string adapterId, optional<ObjectPrx> proxy, const Ice::Current&)
 {
-    Lock sync(*this);
-    if(proxy)
+    lock_guard lock(_mutex);
+    if (proxy)
     {
-        _adapters[adapterId] = proxy;
+        _adapters.insert_or_assign(adapterId, std::move(*proxy));
     }
     else
     {
         _adapters.erase(adapterId);
     }
-#ifdef ICE_CPP11_MAPPING
-    response();
-#else
-    cb->ice_response();
-#endif
 }
 
-#ifdef ICE_CPP11_MAPPING
-void
-LocatorRegistryI::setReplicatedAdapterDirectProxyAsync(string adapterId,
-                                                        string replicaGroupId,
-                                                        shared_ptr<ObjectPrx> proxy,
-                                                        function<void()> response,
-                                                        function<void(exception_ptr)>,
-                                                        const Ice::Current&)
-#else
 void
-LocatorRegistryI::setReplicatedAdapterDirectProxy_async(
-    const AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr& cb,
-    const std::string& adapterId,
-    const std::string& replicaGroupId,
-    const ObjectPrxPtr& proxy,
-    const Current&)
-#endif
+LocatorRegistryI::setReplicatedAdapterDirectProxy(
+    string adapterId,
+    string replicaGroupId,
+    optional<ObjectPrx> proxy,
+    const Ice::Current&)
 {
-    Lock sync(*this);
-    if(proxy)
+    lock_guard lock(_mutex);
+    if (proxy)
     {
-        _adapters[adapterId] = proxy;
-        map<string, set<string> >::iterator p = _replicaGroups.find(replicaGroupId);
-        if(p == _replicaGroups.end())
+        _adapters.insert_or_assign(adapterId, std::move(*proxy));
+        auto p = _replicaGroups.find(replicaGroupId);
+        if (p == _replicaGroups.end())
         {
             p = _replicaGroups.insert(make_pair(replicaGroupId, set<string>())).first;
         }
@@ -85,120 +54,99 @@ LocatorRegistryI::setReplicatedAdapterDirectProxy_async(
     else
     {
         _adapters.erase(adapterId);
-        map<string, set<string> >::iterator p = _replicaGroups.find(replicaGroupId);
-        if(p != _replicaGroups.end())
+        auto p = _replicaGroups.find(replicaGroupId);
+        if (p != _replicaGroups.end())
         {
             p->second.erase(adapterId);
-            if(p->second.empty())
+            if (p->second.empty())
             {
                 _replicaGroups.erase(p);
             }
         }
     }
-#ifdef ICE_CPP11_MAPPING
-    response();
-#else
-    cb->ice_response();
-#endif
 }
 
-#ifdef ICE_CPP11_MAPPING
-void
-LocatorRegistryI::setServerProcessProxyAsync(string,
-                                              shared_ptr<ProcessPrx>,
-                                              function<void()> response,
-                                              function<void(exception_ptr)>,
-                                              const Ice::Current&)
-{
-    response();
-}
-#else
 void
-LocatorRegistryI::setServerProcessProxy_async(const AMD_LocatorRegistry_setServerProcessProxyPtr& cb,
-                                              const std::string&,
-                                              const ProcessPrxPtr&,
-                                              const Current&)
+LocatorRegistryI::setServerProcessProxy(string, optional<ProcessPrx>, const Ice::Current&)
 {
-    cb->ice_response();
 }
-#endif
 
-Ice::ObjectPrxPtr
+optional<Ice::ObjectPrx>
 LocatorRegistryI::findObject(const Ice::Identity& id) const
 {
-    Lock sync(*this);
-    if(id.name.empty())
+    lock_guard lock(_mutex);
+    if (id.name.empty())
     {
-        return 0;
+        return nullopt;
     }
 
-    Ice::ObjectPrxPtr prx = _wellKnownProxy->ice_identity(id);
+    Ice::ObjectPrx prx = _wellKnownProxy->ice_identity(id);
 
     vector<string> adapterIds;
-    for(map<string, set<string> >::const_iterator p = _replicaGroups.begin(); p != _replicaGroups.end(); ++p)
+    for (const auto& [adapterId, _] : _replicaGroups)
     {
         try
         {
-            prx->ice_adapterId(p->first)->ice_ping();
-            adapterIds.push_back(p->first);
+            prx->ice_adapterId(adapterId)->ice_ping();
+            adapterIds.push_back(adapterId);
         }
-        catch(const Ice::Exception&)
+        catch (const Ice::Exception&)
         {
             // Ignore
         }
     }
 
-    if(adapterIds.empty())
+    if (adapterIds.empty())
     {
-        for(map<string, Ice::ObjectPrxPtr>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p)
+        for (const auto& [adapterId, _] : _adapters)
         {
             try
             {
-                prx->ice_adapterId(p->first)->ice_ping();
-                adapterIds.push_back(p->first);
+                prx->ice_adapterId(adapterId)->ice_ping();
+                adapterIds.push_back(adapterId);
             }
-            catch(const Ice::Exception&)
+            catch (const Ice::Exception&)
             {
                 // Ignore
             }
         }
     }
 
-    if(adapterIds.empty())
+    if (adapterIds.empty())
     {
-        return 0;
+        return nullopt;
     }
 
-    IceUtilInternal::shuffle(adapterIds.begin(), adapterIds.end());
+    IceInternal::shuffle(adapterIds.begin(), adapterIds.end());
     return prx->ice_adapterId(adapterIds[0]);
 }
 
-Ice::ObjectPrxPtr
+optional<Ice::ObjectPrx>
 LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    map<string, Ice::ObjectPrxPtr>::const_iterator p = _adapters.find(adapterId);
-    if(p != _adapters.end())
+    auto p = _adapters.find(adapterId);
+    if (p != _adapters.end())
     {
         isReplicaGroup = false;
         return p->second;
     }
 
-    map<string, set<string> >::const_iterator q = _replicaGroups.find(adapterId);
-    if(q != _replicaGroups.end())
+    auto q = _replicaGroups.find(adapterId);
+    if (q != _replicaGroups.end())
     {
         Ice::EndpointSeq endpoints;
-        Ice::ObjectPrxPtr prx;
-        for(set<string>::const_iterator r = q->second.begin(); r != q->second.end(); ++r)
+        optional<Ice::ObjectPrx> prx;
+        for (const auto& r : q->second)
         {
-            map<string, Ice::ObjectPrxPtr>::const_iterator s = _adapters.find(*r);
-            if(s == _adapters.end())
+            auto s = _adapters.find(r);
+            if (s == _adapters.end())
             {
                 continue; // TODO: Inconsistency
             }
 
-            if(!prx)
+            if (!prx)
             {
                 prx = s->second;
             }
@@ -207,7 +155,7 @@ LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) con
             copy(endpts.begin(), endpts.end(), back_inserter(endpoints));
         }
 
-        if(prx)
+        if (prx)
         {
             isReplicaGroup = true;
             return prx->ice_endpoints(endpoints);
@@ -215,51 +163,40 @@ LocatorRegistryI::findAdapter(const string& adapterId, bool& isReplicaGroup) con
     }
 
     isReplicaGroup = false;
-    return 0;
+    return nullopt;
 }
 
-LocatorI::LocatorI(const LookupIPtr& lookup, const LocatorRegistryPrxPtr& registry) : _lookup(lookup), _registry(registry)
+LocatorI::LocatorI(LookupIPtr lookup, LocatorRegistryPrx registry)
+    : _lookup(std::move(lookup)),
+      _registry(std::move(registry))
 {
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
-LocatorI::findObjectByIdAsync(Ice::Identity id,
-                              function<void(const shared_ptr<ObjectPrx>&)> response,
-                              function<void(exception_ptr)> ex,
-                              const Ice::Current&) const
+LocatorI::findObjectByIdAsync(
+    Ice::Identity id,
+    function<void(const optional<ObjectPrx>&)> response,
+    function<void(exception_ptr)> ex,
+    const Ice::Current&) const
 {
     _lookup->findObject(make_pair(response, ex), id);
 }
 
 void
-LocatorI::findAdapterByIdAsync(string adapterId,
-                               function<void(const shared_ptr<ObjectPrx>&)> response,
-                               function<void(exception_ptr)> ex,
-                               const Ice::Current&) const
+LocatorI::findAdapterByIdAsync(
+    string adapterId,
+    function<void(const optional<ObjectPrx>&)> response,
+    function<void(exception_ptr)> ex,
+    const Ice::Current&) const
 {
     _lookup->findAdapter(make_pair(response, ex), adapterId);
 }
-#else
-void
-LocatorI::findObjectById_async(const AMD_Locator_findObjectByIdPtr& cb,
-                               const Identity& id,
-                               const Current&) const
-{
-    _lookup->findObject(cb, id);
-}
 
 void
-LocatorI::findAdapterById_async(const AMD_Locator_findAdapterByIdPtr& cb,
-                                const std::string& adapterId,
-                                const Current&) const
-{
-    _lookup->findAdapter(cb, adapterId);
-}
-#endif
-
-LocatorRegistryPrxPtr
-LocatorI::getRegistry(const Current&) const
+LocatorI::getRegistryAsync(
+    function<void(const optional<LocatorRegistryPrx>&)> response,
+    function<void(exception_ptr)>,
+    const Ice::Current&) const
 {
-    return _registry;
+    response(_registry);
 }

data/dist/ice/cpp/src/IceDiscovery/LocatorI.h

@@ -1,108 +1,67 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef LOCATORI_H
 #define LOCATORI_H
 
-#include <Ice/Locator.h>
-#include <Ice/ProxyF.h>
+#include "Ice/Locator.h"
 
 #include <set>
 
 namespace IceDiscovery
 {
-
-class LocatorRegistryI : public Ice::LocatorRegistry, private IceUtil::Mutex
-{
-public:
-
-    LocatorRegistryI(const Ice::CommunicatorPtr&);
-
-#ifdef ICE_CPP11_MAPPING
-    virtual void
-    setAdapterDirectProxyAsync(std::string,
-                               std::shared_ptr<Ice::ObjectPrx>,
-                               std::function<void()>,
-                               std::function<void(std::exception_ptr)>,
-                               const Ice::Current&);
-
-    virtual void
-    setReplicatedAdapterDirectProxyAsync(std::string,
-                                         std::string,
-                                         std::shared_ptr<Ice::ObjectPrx>,
-                                         std::function<void()>,
-                                         std::function<void(std::exception_ptr)>,
-                                         const Ice::Current&);
-
-    virtual void
-    setServerProcessProxyAsync(std::string,
-                               std::shared_ptr<Ice::ProcessPrx>,
-                               std::function<void()>,
-                               std::function<void(std::exception_ptr)>,
-                               const Ice::Current&);
-#else
-    virtual void
-    setAdapterDirectProxy_async(const Ice::AMD_LocatorRegistry_setAdapterDirectProxyPtr&, const std::string&,
-                                const Ice::ObjectPrx&, const Ice::Current&);
-
-    virtual void
-    setReplicatedAdapterDirectProxy_async(const Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr&,
-                                          const std::string&, const std::string&, const Ice::ObjectPrx&,
-                                          const Ice::Current&);
-
-    virtual void
-    setServerProcessProxy_async(const Ice::AMD_LocatorRegistry_setServerProcessProxyPtr&, const std::string&,
-                                const Ice::ProcessPrx&, const Ice::Current&);
-#endif
-    Ice::ObjectPrxPtr findObject(const Ice::Identity&) const;
-    Ice::ObjectPrxPtr findAdapter(const std::string&, bool&) const;
-
-private:
-
-    const Ice::ObjectPrxPtr _wellKnownProxy;
-    std::map<std::string, Ice::ObjectPrxPtr> _adapters;
-    std::map<std::string, std::set<std::string> > _replicaGroups;
-};
-ICE_DEFINE_PTR(LocatorRegistryIPtr, LocatorRegistryI);
-
-class LookupI;
-ICE_DEFINE_PTR(LookupIPtr, LookupI);
-
-class LocatorI : public Ice::Locator
-{
-public:
-
-    LocatorI(const LookupIPtr&, const Ice::LocatorRegistryPrxPtr&);
-
-#ifdef ICE_CPP11_MAPPING
-    virtual void
-    findObjectByIdAsync(Ice::Identity,
-                        std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
-                        std::function<void(std::exception_ptr)>,
-                        const Ice::Current&) const;
-
-    virtual void
-    findAdapterByIdAsync(std::string,
-                         std::function<void(const std::shared_ptr<Ice::ObjectPrx>&)>,
-                         std::function<void(std::exception_ptr)>,
-                         const Ice::Current&) const;
-#else
-    virtual void
-    findObjectById_async(const Ice::AMD_Locator_findObjectByIdPtr&, const Ice::Identity&,
-                         const Ice::Current&) const;
-
-    virtual void
-    findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr&, const std::string&,
-                          const Ice::Current&) const;
-#endif
-    virtual Ice::LocatorRegistryPrxPtr getRegistry(const Ice::Current&) const;
-
-private:
-
-    LookupIPtr _lookup;
-    Ice::LocatorRegistryPrxPtr _registry;
-};
+    class LocatorRegistryI final : public Ice::LocatorRegistry
+    {
+    public:
+        LocatorRegistryI(const Ice::CommunicatorPtr&);
+
+        void setAdapterDirectProxy(std::string, std::optional<Ice::ObjectPrx>, const Ice::Current&) final;
+
+        void
+        setReplicatedAdapterDirectProxy(std::string, std::string, std::optional<Ice::ObjectPrx>, const Ice::Current&)
+            final;
+
+        void setServerProcessProxy(std::string, std::optional<Ice::ProcessPrx>, const Ice::Current&) final;
+
+        [[nodiscard]] std::optional<Ice::ObjectPrx> findObject(const Ice::Identity&) const;
+        std::optional<Ice::ObjectPrx> findAdapter(const std::string&, bool&) const;
+
+    private:
+        const Ice::ObjectPrx _wellKnownProxy;
+        std::map<std::string, Ice::ObjectPrx> _adapters;
+        std::map<std::string, std::set<std::string>> _replicaGroups;
+        mutable std::mutex _mutex;
+    };
+    using LocatorRegistryIPtr = std::shared_ptr<LocatorRegistryI>;
+
+    class LookupI;
+    using LookupIPtr = std::shared_ptr<LookupI>;
+
+    class LocatorI final : public Ice::AsyncLocator
+    {
+    public:
+        LocatorI(LookupIPtr, Ice::LocatorRegistryPrx);
+
+        void findObjectByIdAsync(
+            Ice::Identity,
+            std::function<void(const std::optional<Ice::ObjectPrx>&)>,
+            std::function<void(std::exception_ptr)>,
+            const Ice::Current&) const final;
+
+        void findAdapterByIdAsync(
+            std::string,
+            std::function<void(const std::optional<Ice::ObjectPrx>&)>,
+            std::function<void(std::exception_ptr)>,
+            const Ice::Current&) const final;
+
+        void getRegistryAsync(
+            std::function<void(const std::optional<Ice::LocatorRegistryPrx>&)>,
+            std::function<void(std::exception_ptr)>,
+            const Ice::Current&) const final;
+
+    private:
+        LookupIPtr _lookup;
+        Ice::LocatorRegistryPrx _registry;
+    };
 
 };