zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,228 +1,169 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef LOOKUPI_H
 #define LOOKUPI_H
 
-#include <IceDiscovery/IceDiscovery.h>
-#include <IceDiscovery/LocatorI.h>
-
-#include <IceUtil/Timer.h>
-#include <Ice/Properties.h>
-#include <Ice/Comparable.h>
+#include "../Ice/Timer.h"
+#include "Ice/Properties.h"
+#include "IceDiscovery/Lookup.h"
+#include "LocatorI.h"
 
+#include <chrono>
 #include <set>
 
 namespace IceDiscovery
 {
+    class LookupI;
 
-class LookupI;
-
-class Request : public IceUtil::TimerTask
-{
-public:
-
-    Request(const LookupIPtr&, int);
-
-    virtual bool retry();
-    void invoke(const std::string&, const std::vector<std::pair<LookupPrxPtr, LookupReplyPrxPtr> >&);
-    bool exception();
-    std::string getRequestId() const;
-
-    virtual void finished(const Ice::ObjectPrxPtr&) = 0;
+    class Request : public IceInternal::TimerTask
+    {
+    public:
+        Request(LookupIPtr, int);
 
-protected:
+        virtual bool retry();
+        void invoke(const std::string&, const std::vector<std::pair<LookupPrx, LookupReplyPrx>>&);
+        bool exception();
+        [[nodiscard]] std::string getRequestId() const;
 
-    virtual void invokeWithLookup(const std::string&, const LookupPrxPtr&, const LookupReplyPrxPtr&) = 0;
+        virtual void finished(const std::optional<Ice::ObjectPrx>&) = 0;
 
-    LookupIPtr _lookup;
-    const std::string _requestId;
-    int _retryCount;
-    size_t _lookupCount;
-    size_t _failureCount;
-};
-ICE_DEFINE_PTR(RequestPtr, Request);
+    protected:
+        virtual void invokeWithLookup(const std::string&, const LookupPrx&, const LookupReplyPrx&) = 0;
 
-template<class T, class CB> class RequestT : public Request
-{
-public:
-
-    RequestT(const LookupIPtr& lookup, T id, int retryCount) : Request(lookup, retryCount), _id(id)
-    {
-    }
+        LookupIPtr _lookup;
+        const std::string _requestId;
+        int _retryCount;
+        size_t _lookupCount{0};
+        size_t _failureCount{0};
+    };
+    using RequestPtr = std::shared_ptr<Request>;
 
-    T getId() const
+    template<class T, class CB> class RequestT : public Request
     {
-        return _id;
-    }
+    public:
+        RequestT(const LookupIPtr& lookup, T id, int retryCount) : Request(lookup, retryCount), _id(std::move(id)) {}
 
-    bool addCallback(const CB& cb)
-    {
-        _callbacks.push_back(cb);
-        return _callbacks.size() == 1;
-    }
+        [[nodiscard]] T getId() const { return _id; }
 
-    virtual void finished(const Ice::ObjectPrxPtr& proxy)
-    {
-        for(typename std::vector<CB>::const_iterator p = _callbacks.begin(); p != _callbacks.end(); ++p)
+        bool addCallback(const CB& cb)
         {
-#ifdef ICE_CPP11_MAPPING
-            p->first(proxy);
-#else
-            (*p)->ice_response(proxy);
-#endif
+            _callbacks.push_back(cb);
+            return _callbacks.size() == 1;
         }
-        _callbacks.clear();
-    }
-
-protected:
-
-    const T _id;
-    std::vector<CB> _callbacks;
-};
-
-#ifdef ICE_CPP11_MAPPING
-typedef std::pair<std::function<void(const std::shared_ptr<::Ice::ObjectPrx>&)>,
-                  std::function<void(std::exception_ptr)>> ObjectCB;
-typedef std::pair<std::function<void(const std::shared_ptr<::Ice::ObjectPrx>&)>,
-                  std::function<void(std::exception_ptr)>> AdapterCB;
-#else
-typedef Ice::AMD_Locator_findObjectByIdPtr ObjectCB;
-typedef Ice::AMD_Locator_findAdapterByIdPtr AdapterCB;
-#endif
-
-class ObjectRequest : public RequestT<Ice::Identity, ObjectCB>
-#ifdef ICE_CPP11_MAPPING
-                      , public std::enable_shared_from_this<ObjectRequest>
-#endif
-{
-public:
-
-    ObjectRequest(const LookupIPtr&, const Ice::Identity&, int);
 
-    void response(const Ice::ObjectPrxPtr&);
+        void finished(const std::optional<Ice::ObjectPrx>& proxy) override
+        {
+            for (const auto& callback : _callbacks)
+            {
+                callback.first(proxy);
+            }
+            _callbacks.clear();
+        }
 
-private:
+    protected:
+        const T _id;
+        std::vector<CB> _callbacks;
+    };
 
-    virtual void invokeWithLookup(const std::string&, const LookupPrxPtr&, const LookupReplyPrxPtr&);
-    virtual void runTimerTask();
-};
-ICE_DEFINE_PTR(ObjectRequestPtr, ObjectRequest);
+    using ObjectCB =
+        std::pair<std::function<void(const std::optional<Ice::ObjectPrx>&)>, std::function<void(std::exception_ptr)>>;
+    using AdapterCB =
+        std::pair<std::function<void(const std::optional<Ice::ObjectPrx>&)>, std::function<void(std::exception_ptr)>>;
 
-class AdapterRequest : public RequestT<std::string, AdapterCB>
-#ifdef ICE_CPP11_MAPPING
-                      , public std::enable_shared_from_this<AdapterRequest>
-#endif
-{
-public:
+    class ObjectRequest final : public RequestT<Ice::Identity, ObjectCB>,
+                                public std::enable_shared_from_this<ObjectRequest>
+    {
+    public:
+        ObjectRequest(const LookupIPtr&, const Ice::Identity&, int);
 
-    AdapterRequest(const LookupIPtr&, const std::string&, int);
+        void response(const Ice::ObjectPrx&);
 
-    bool response(const Ice::ObjectPrxPtr&, bool);
+    private:
+        void invokeWithLookup(const std::string&, const LookupPrx&, const LookupReplyPrx&) override;
+        void runTimerTask() override;
+    };
+    using ObjectRequestPtr = std::shared_ptr<ObjectRequest>;
 
-    virtual bool retry();
-    virtual void finished(const Ice::ObjectPrxPtr&);
+    class AdapterRequest final : public RequestT<std::string, AdapterCB>,
+                                 public std::enable_shared_from_this<AdapterRequest>
+    {
+    public:
+        AdapterRequest(const LookupIPtr&, const std::string&, int);
+
+        bool response(const Ice::ObjectPrx&, bool);
+
+        bool retry() final;
+        void finished(const std::optional<Ice::ObjectPrx>&) final;
+
+    private:
+        void invokeWithLookup(const std::string&, const LookupPrx&, const LookupReplyPrx&) final;
+        void runTimerTask() final;
+
+        //
+        // We use a set because the same IceDiscovery plugin might return multiple times
+        // the same proxy if it's accessible through multiple network interfaces and if we
+        // also sent the request to multiple interfaces.
+        //
+        std::set<Ice::ObjectPrx> _proxies;
+        std::chrono::steady_clock::time_point _start;
+        std::chrono::nanoseconds _latency;
+    };
+    using AdapterRequestPtr = std::shared_ptr<AdapterRequest>;
+
+    class LookupI final : public Lookup, public std::enable_shared_from_this<LookupI>
+    {
+    public:
+        LookupI(LocatorRegistryIPtr, const LookupPrx&, const Ice::PropertiesPtr&);
 
-private:
+        void destroy();
 
-    virtual void invokeWithLookup(const std::string&, const LookupPrxPtr&, const LookupReplyPrxPtr&);
-    virtual void runTimerTask();
+        void setLookupReply(const LookupReplyPrx&);
 
-    //
-    // We use a set because the same IceDiscovery plugin might return multiple times
-    // the same proxy if it's accessible through multiple network interfaces and if we
-    // also sent the request to multiple interfaces.
-    //
-#ifdef ICE_CPP11_MAPPING
-    std::set<std::shared_ptr<Ice::ObjectPrx>, Ice::TargetCompare<std::shared_ptr<Ice::ObjectPrx>, std::less>> _proxies;
-#else
-    std::set<Ice::ObjectPrx> _proxies;
-#endif
-    IceUtil::Time _start;
-    IceUtil::Time _latency;
-};
-ICE_DEFINE_PTR(AdapterRequestPtr, AdapterRequest);
-
-class LookupI : public Lookup,
-                private IceUtil::Mutex
-#ifdef ICE_CPP11_MAPPING
-              , public std::enable_shared_from_this<LookupI>
-#endif
-{
-public:
+        void findObjectById(std::string, Ice::Identity, std::optional<LookupReplyPrx>, const Ice::Current&) final;
+        void findAdapterById(std::string, std::string, std::optional<LookupReplyPrx>, const Ice::Current&) final;
+        void findObject(const ObjectCB&, const Ice::Identity&);
+        void findAdapter(const AdapterCB&, const std::string&);
 
-    LookupI(const LocatorRegistryIPtr&, const LookupPrxPtr&, const Ice::PropertiesPtr&);
-    virtual ~LookupI();
+        void foundObject(const Ice::Identity&, const std::string&, const Ice::ObjectPrx&);
+        void foundAdapter(const std::string&, const std::string&, const Ice::ObjectPrx&, bool);
 
-    void destroy();
+        void adapterRequestTimedOut(const AdapterRequestPtr&);
+        void adapterRequestException(const AdapterRequestPtr&, std::exception_ptr);
+        void objectRequestTimedOut(const ObjectRequestPtr&);
+        void objectRequestException(const ObjectRequestPtr&, std::exception_ptr);
 
-    void setLookupReply(const LookupReplyPrxPtr&);
+        const IceInternal::TimerPtr& timer() { return _timer; }
 
-    virtual void findObjectById(ICE_IN(std::string), ICE_IN(Ice::Identity), ICE_IN(IceDiscovery::LookupReplyPrxPtr),
-                                const Ice::Current&);
-    virtual void findAdapterById(ICE_IN(std::string), ICE_IN(std::string), ICE_IN(IceDiscovery::LookupReplyPrxPtr),
-                                 const Ice::Current&);
-    void findObject(const ObjectCB&, const Ice::Identity&);
-    void findAdapter(const AdapterCB&, const std::string&);
+        int latencyMultiplier() { return _latencyMultiplier; }
 
-    void foundObject(const Ice::Identity&, const std::string&, const Ice::ObjectPrxPtr&);
-    void foundAdapter(const std::string&, const std::string&, const Ice::ObjectPrxPtr&, bool);
+    private:
+        LocatorRegistryIPtr _registry;
+        LookupPrx _lookup;
+        std::vector<std::pair<LookupPrx, LookupReplyPrx>> _lookups;
+        const std::chrono::milliseconds _timeout;
+        const int _retryCount;
+        const int _latencyMultiplier;
+        const std::string _domainId;
 
-    void adapterRequestTimedOut(const AdapterRequestPtr&);
-    void adapterRequestException(const AdapterRequestPtr&, const Ice::LocalException&);
-    void objectRequestTimedOut(const ObjectRequestPtr&);
-    void objectRequestException(const ObjectRequestPtr&, const Ice::LocalException&);
+        IceInternal::TimerPtr _timer;
+        bool _warnOnce{true};
 
-    const IceUtil::TimerPtr&
-    timer()
-    {
-        return _timer;
-    }
+        std::map<Ice::Identity, ObjectRequestPtr> _objectRequests;
+        std::map<std::string, AdapterRequestPtr> _adapterRequests;
+        std::mutex _mutex;
+    };
 
-    int
-    latencyMultiplier()
+    class LookupReplyI final : public LookupReply
     {
-        return _latencyMultiplier;
-    }
-
-private:
-
-    LocatorRegistryIPtr _registry;
-    LookupPrxPtr _lookup;
-    std::vector<std::pair<LookupPrxPtr, LookupReplyPrxPtr> > _lookups;
-    const IceUtil::Time _timeout;
-    const int _retryCount;
-    const int _latencyMultiplier;
-    const std::string _domainId;
-
-    IceUtil::TimerPtr _timer;
-    Ice::ObjectPrxPtr _wellKnownProxy;
-    bool _warnOnce;
-
-    std::map<Ice::Identity, ObjectRequestPtr> _objectRequests;
-    std::map<std::string, AdapterRequestPtr> _adapterRequests;
-};
-
-class LookupReplyI : public LookupReply
-{
-public:
-
-    LookupReplyI(const LookupIPtr&);
-
-#ifdef ICE_CPP11_MAPPING
-    virtual void foundObjectById(Ice::Identity, std::shared_ptr<Ice::ObjectPrx>, const Ice::Current&);
-    virtual void foundAdapterById(std::string, std::shared_ptr<Ice::ObjectPrx>, bool, const Ice::Current&);
-#else
-    virtual void foundObjectById(const Ice::Identity&, const Ice::ObjectPrx&, const Ice::Current&);
-    virtual void foundAdapterById(const std::string&, const Ice::ObjectPrx&, bool, const Ice::Current&);
-#endif
-
-private:
+    public:
+        LookupReplyI(LookupIPtr);
 
-    const LookupIPtr _lookup;
-};
+        void foundObjectById(Ice::Identity, std::optional<Ice::ObjectPrx>, const Ice::Current&) final;
+        void foundAdapterById(std::string, std::optional<Ice::ObjectPrx>, bool, const Ice::Current&) final;
 
-};
+    private:
+        const LookupIPtr _lookup;
+    };
+}
 
 #endif

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

@@ -1,98 +1,81 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/IceUtil.h>
-#include <Ice/Ice.h>
-#include <Ice/Network.h> // For getInterfacesForMulticast
-
-#include <IceDiscovery/PluginI.h>
-#include <IceDiscovery/LocatorI.h>
-#include <IceDiscovery/LookupI.h>
+#include "PluginI.h"
+#include "../Ice/Network.h" // For getInterfacesForMulticast
+#include "IceDiscovery/IceDiscovery.h"
+#include "LocatorI.h"
+#include "LookupI.h"
 
 using namespace std;
 using namespace IceDiscovery;
 
-#ifndef ICE_DISCOVERY_API
-#   ifdef ICE_DISCOVERY_API_EXPORTS
-#       define ICE_DISCOVERY_API ICE_DECLSPEC_EXPORT
-#   else
-#       define ICE_DISCOVERY_API /**/
-#   endif
-#endif
+namespace
+{
+    const char* const discoveryPluginName = "IceDiscovery";
+}
 
 //
 // Plugin factory function.
 //
 extern "C" ICE_DISCOVERY_API Ice::Plugin*
-createIceDiscovery(const Ice::CommunicatorPtr& communicator, const string&, const Ice::StringSeq&)
-{
-    return new PluginI(communicator);
-}
-
-namespace Ice
+createIceDiscovery(const Ice::CommunicatorPtr& communicator, const string& name, const Ice::StringSeq&)
 {
+    string pluginName{discoveryPluginName};
 
-ICE_DISCOVERY_API void
-registerIceDiscovery(bool loadOnInitialize)
-{
-    Ice::registerPluginFactory("IceDiscovery", createIceDiscovery, loadOnInitialize);
-
-#ifdef ICE_STATIC_LIBS
-    //
-    // Also register the UDP plugin with static builds to ensure the UDP transport is loaded.
-    //
-    registerIceUDP(true);
+    if (name != pluginName)
+    {
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4297) // function assumed not to throw an exception but does
 #endif
-}
+        throw Ice::PluginInitializationException{
+            __FILE__,
+            __LINE__,
+            "the Discovery plug-in must be named '" + pluginName + "'"};
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif
+    }
 
+    return new PluginI(communicator);
 }
 
-//
-// Objective-C function to allow Objective-C programs to register plugin.
-//
-extern "C" ICE_DISCOVERY_API void
-ICEregisterIceDiscovery(bool loadOnInitialize)
+Ice::PluginFactory
+IceDiscovery::discoveryPluginFactory()
 {
-    Ice::registerIceDiscovery(loadOnInitialize);
+    return {discoveryPluginName, createIceDiscovery};
 }
 
-PluginI::PluginI(const Ice::CommunicatorPtr& communicator) : _communicator(communicator)
-{
-}
+PluginI::PluginI(Ice::CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
 void
 PluginI::initialize()
 {
     Ice::PropertiesPtr properties = _communicator->getProperties();
 
-    bool ipv4 = properties->getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
-    bool preferIPv6 = properties->getPropertyAsInt("Ice.PreferIPv6Address") > 0;
-    string address;
-    if(ipv4 && !preferIPv6)
+    bool ipv4 = properties->getIcePropertyAsInt("Ice.IPv4") > 0;
+    bool preferIPv6 = properties->getIcePropertyAsInt("Ice.PreferIPv6Address") > 0;
+    string address = properties->getIceProperty("IceDiscovery.Address");
+    if (address.empty())
     {
-        address = properties->getPropertyWithDefault("IceDiscovery.Address", "239.255.0.1");
+        address = ipv4 && !preferIPv6 ? "239.255.0.1" : "ff15::1";
     }
-    else
-    {
-        address = properties->getPropertyWithDefault("IceDiscovery.Address", "ff15::1");
-    }
-    int port = properties->getPropertyAsIntWithDefault("IceDiscovery.Port", 4061);
-    string intf = properties->getProperty("IceDiscovery.Interface");
+    int port = properties->getIcePropertyAsInt("IceDiscovery.Port");
+    string intf = properties->getIceProperty("IceDiscovery.Interface");
 
-    if(properties->getProperty("IceDiscovery.Multicast.Endpoints").empty())
+    if (properties->getIceProperty("IceDiscovery.Multicast.Endpoints").empty())
     {
         ostringstream os;
         os << "udp -h \"" << address << "\" -p " << port;
-        if(!intf.empty())
+        if (!intf.empty())
         {
             os << " --interface \"" << intf << "\"";
         }
         properties->setProperty("IceDiscovery.Multicast.Endpoints", os.str());
     }
 
-    string lookupEndpoints = properties->getProperty("IceDiscovery.Lookup");
-    if(lookupEndpoints.empty())
+    string lookupEndpoints = properties->getIceProperty("IceDiscovery.Lookup");
+    if (lookupEndpoints.empty())
     {
         //
         // If no lookup endpoints are specified, we get all the network interfaces and create
@@ -101,9 +84,9 @@ PluginI::initialize()
         IceInternal::ProtocolSupport protocol = ipv4 && !preferIPv6 ? IceInternal::EnableIPv4 : IceInternal::EnableIPv6;
         vector<string> interfaces = IceInternal::getInterfacesForMulticast(intf, protocol);
         ostringstream lookup;
-        for(vector<string>::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
+        for (auto p = interfaces.begin(); p != interfaces.end(); ++p)
         {
-            if(p != interfaces.begin())
+            if (p != interfaces.begin())
             {
                 lookup << ":";
             }
@@ -112,12 +95,12 @@ PluginI::initialize()
         lookupEndpoints = lookup.str();
     }
 
-    if(properties->getProperty("IceDiscovery.Reply.Endpoints").empty())
+    if (properties->getIceProperty("IceDiscovery.Reply.Endpoints").empty())
     {
         properties->setProperty("IceDiscovery.Reply.Endpoints", "udp -h " + (intf.empty() ? "*" : "\"" + intf + "\""));
     }
 
-    if(properties->getProperty("IceDiscovery.Locator.Endpoints").empty())
+    if (properties->getIceProperty("IceDiscovery.Locator.Endpoints").empty())
     {
         properties->setProperty("IceDiscovery.Locator.AdapterId", Ice::generateUUID());
     }
@@ -127,33 +110,29 @@ PluginI::initialize()
     _locatorAdapter = _communicator->createObjectAdapter("IceDiscovery.Locator");
 
     //
-    // Setup locatory registry.
+    // Setup locator registry.
     //
-    LocatorRegistryIPtr locatorRegistry = ICE_MAKE_SHARED(LocatorRegistryI, _communicator);
-    Ice::LocatorRegistryPrxPtr locatorRegistryPrx =
-        ICE_UNCHECKED_CAST(Ice::LocatorRegistryPrx, _locatorAdapter->addWithUUID(locatorRegistry));
+    auto locatorRegistry = make_shared<LocatorRegistryI>(_communicator);
+    auto locatorRegistryPrx = _locatorAdapter->addWithUUID<Ice::LocatorRegistryPrx>(locatorRegistry);
 
-    Ice::ObjectPrxPtr lookupPrx = _communicator->stringToProxy("IceDiscovery/Lookup -d:" + lookupEndpoints);
-    // No collocation optimization for the multicast proxy!
-    lookupPrx = lookupPrx->ice_collocationOptimized(false)->ice_router(ICE_NULLPTR);
+    LookupPrx lookupPrx(_communicator, "IceDiscovery/Lookup -d:" + lookupEndpoints);
+    lookupPrx = lookupPrx->ice_router(nullopt);
 
     //
     // Add lookup and lookup reply Ice objects
     //
-    _lookup = ICE_MAKE_SHARED(LookupI, locatorRegistry, ICE_UNCHECKED_CAST(LookupPrx, lookupPrx), properties);
+    _lookup = make_shared<LookupI>(locatorRegistry, lookupPrx, properties);
     _multicastAdapter->add(_lookup, Ice::stringToIdentity("IceDiscovery/Lookup"));
 
-    _replyAdapter->addDefaultServant(ICE_MAKE_SHARED(LookupReplyI, _lookup), "");
-    Ice::Identity id;
-    id.name = "dummy";
-    _lookup->setLookupReply(ICE_UNCHECKED_CAST(LookupReplyPrx, _replyAdapter->createProxy(id)->ice_datagram()));
+    _replyAdapter->addDefaultServant(make_shared<LookupReplyI>(_lookup), "");
+
+    _lookup->setLookupReply(_replyAdapter->createProxy<LookupReplyPrx>(Ice::Identity{"dummy", ""})->ice_datagram());
 
     //
     // Setup locator on the communicator.
     //
-    Ice::ObjectPrxPtr loc = _locatorAdapter->addWithUUID(ICE_MAKE_SHARED(LocatorI, _lookup, locatorRegistryPrx));
+    _locator = _locatorAdapter->addWithUUID<Ice::LocatorPrx>(make_shared<LocatorI>(_lookup, locatorRegistryPrx));
     _defaultLocator = _communicator->getDefaultLocator();
-    _locator = ICE_UNCHECKED_CAST(Ice::LocatorPrx, loc);
     _communicator->setDefaultLocator(_locator);
 
     _multicastAdapter->activate();
@@ -169,7 +148,7 @@ PluginI::destroy()
     _locatorAdapter->destroy();
     _lookup->destroy();
     // Restore original default locator proxy, if the user didn't change it in the meantime.
-    if(_communicator->getDefaultLocator() == _locator)
+    if (_communicator->getDefaultLocator() == _locator)
     {
         _communicator->setDefaultLocator(_defaultLocator);
     }

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

@@ -1,35 +1,30 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef PLUGIN_I_H
 #define PLUGIN_I_H
 
-#include <Ice/Plugin.h>
-#include <IceDiscovery/LookupI.h>
+#include "Ice/Plugin.h"
+#include "LookupI.h"
 
 namespace IceDiscovery
 {
-
-class PluginI : public Ice::Plugin
-{
-public:
-
-    PluginI(const Ice::CommunicatorPtr&);
-
-    virtual void initialize();
-    virtual void destroy();
-
-private:
-
-    const Ice::CommunicatorPtr _communicator;
-    Ice::ObjectAdapterPtr _multicastAdapter;
-    Ice::ObjectAdapterPtr _replyAdapter;
-    Ice::ObjectAdapterPtr _locatorAdapter;
-    LookupIPtr _lookup;
-    Ice::LocatorPrxPtr _locator;
-    Ice::LocatorPrxPtr _defaultLocator;
-};
+    class PluginI : public Ice::Plugin
+    {
+    public:
+        PluginI(Ice::CommunicatorPtr);
+
+        void initialize() override;
+        void destroy() override;
+
+    private:
+        const Ice::CommunicatorPtr _communicator;
+        Ice::ObjectAdapterPtr _multicastAdapter;
+        Ice::ObjectAdapterPtr _replyAdapter;
+        Ice::ObjectAdapterPtr _locatorAdapter;
+        LookupIPtr _lookup;
+        std::optional<Ice::LocatorPrx> _locator;
+        std::optional<Ice::LocatorPrx> _defaultLocator;
+    };
 
 };