zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/DynamicLibrary.h

@@ -0,0 +1,91 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_DYNAMIC_LIBRARY_H
+#define ICE_DYNAMIC_LIBRARY_H
+
+#include "Ice/Config.h"
+
+#ifdef _WIN32
+#    include <windows.h>
+#endif
+
+#include <string>
+
+namespace IceInternal
+{
+    class ICE_API DynamicLibrary final
+    {
+    public:
+        DynamicLibrary() = default;
+        ~DynamicLibrary();
+
+        DynamicLibrary(const DynamicLibrary&) = delete;
+        DynamicLibrary& operator=(const DynamicLibrary&) = delete;
+
+#ifdef _WIN32
+        using symbol_type = FARPROC;
+#else
+        using symbol_type = void*;
+#endif
+
+        //
+        // Load an entry point. This is really a convenience function
+        // which combines calls to load() and getSymbol(). However, it
+        // does add some value.
+        //
+        // An entry point has the following format:
+        //
+        // name[,version]:function
+        //
+        // The name of the library is constructed from the given
+        // information. If no version is supplied and the boolean
+        // argument is true, the Ice version (10 * major + minor) is
+        // used instead.
+        //
+        // For example, consider the following entry point:
+        //
+        // foo:create
+        //
+        // This would result in libfoo.so.11 (Unix) and foo11.dll
+        // (Windows), where the Ice version is 1.1.x.
+        //
+        // Now consider this entry point:
+        //
+        // foo,12:create
+        //
+        // The library names in this case are libfoo.so.12 (Unix) and
+        // foo12.dll (Windows).
+        //
+        // On Windows platforms, a 'd' is appended to the version for
+        // debug builds.
+        //
+        // Returns 0 if a failure occurred.
+        //
+        symbol_type loadEntryPoint(const std::string&, bool = true);
+
+        //
+        // Open a library with the given path.
+        //
+        bool load(const std::string&);
+
+        //
+        // Retrieve a symbol from the library. Returns 0 if no match is found.
+        //
+        symbol_type getSymbol(const std::string&);
+
+        //
+        // Get the error message for the last failure.
+        //
+        [[nodiscard]] const std::string& getErrorMessage() const;
+
+    private:
+#ifdef _WIN32
+        HINSTANCE _hnd{nullptr};
+#else
+        void* _hnd{nullptr};
+#endif
+        std::string _err;
+    };
+}
+
+#endif

data/dist/ice/cpp/src/Ice/Endian.h

@@ -0,0 +1,40 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDIAN_H
+#define ICE_ENDIAN_H
+
+#if __has_include(<bit>)
+#    include <bit>
+#endif
+
+#ifndef __cpp_lib_endian
+
+// NOLINTBEGIN(cert-dcl58-cpp)
+
+// Provide a minimal implementation of std::endian for C++17.
+namespace std
+{
+#    ifdef _MSC_VER
+    // Always little-endian on Windows.
+    enum class endian
+    {
+        little = 0,
+        big = 1,
+        native = little
+    };
+#    else
+    // Use macros predefined by gcc/clang to determine the endianness.
+    enum class endian
+    {
+        little = __ORDER_LITTLE_ENDIAN__,
+        big = __ORDER_BIG_ENDIAN__,
+        native = __BYTE_ORDER__
+    };
+#    endif
+}
+
+// NOLINTEND(cert-dcl58-cpp)
+
+#endif
+
+#endif

data/dist/ice/cpp/src/Ice/EndpointFactory.cpp

@@ -1,25 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/EndpointFactory.h>
-#include <Ice/Instance.h>
-#include <Ice/EndpointFactoryManager.h>
-#include <Ice/ProtocolInstance.h>
+#include "EndpointFactory.h"
+#include "EndpointFactoryManager.h"
+#include "Instance.h"
+#include "ProtocolInstance.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(EndpointFactory* p) { return p; }
+IceInternal::EndpointFactory::EndpointFactory() = default;
 
-IceInternal::EndpointFactory::EndpointFactory()
-{
-}
-
-IceInternal::EndpointFactory::~EndpointFactory()
-{
-}
+IceInternal::EndpointFactory::~EndpointFactory() = default;
 
 void
 IceInternal::EndpointFactory::initialize()
@@ -27,8 +19,9 @@ IceInternal::EndpointFactory::initialize()
     // Nothing to do, can be overridden by specialization to finish initialization.
 }
 
-IceInternal::EndpointFactoryPlugin::EndpointFactoryPlugin(const CommunicatorPtr& communicator,
-                                                          const EndpointFactoryPtr& factory)
+IceInternal::EndpointFactoryPlugin::EndpointFactoryPlugin(
+    const CommunicatorPtr& communicator,
+    const EndpointFactoryPtr& factory)
 {
     assert(communicator);
     getInstance(communicator)->endpointFactoryManager()->add(factory);
@@ -44,9 +37,9 @@ IceInternal::EndpointFactoryPlugin::destroy()
 {
 }
 
-IceInternal::EndpointFactoryWithUnderlying::EndpointFactoryWithUnderlying(const ProtocolInstancePtr& instance,
-                                                                          Short type) :
-    _instance(instance), _type(type)
+IceInternal::EndpointFactoryWithUnderlying::EndpointFactoryWithUnderlying(ProtocolInstancePtr instance, int16_t type)
+    : _instance(std::move(instance)),
+      _type(type)
 {
 }
 
@@ -58,14 +51,14 @@ IceInternal::EndpointFactoryWithUnderlying::initialize()
     // our protocol instance.
     //
     EndpointFactoryPtr factory = _instance->getEndpointFactory(_type);
-    if(factory)
+    if (factory)
     {
         _underlying = factory->clone(_instance);
         _underlying->initialize();
     }
 }
 
-Short
+int16_t
 IceInternal::EndpointFactoryWithUnderlying::type() const
 {
     return _instance->type();
@@ -80,9 +73,9 @@ IceInternal::EndpointFactoryWithUnderlying::protocol() const
 EndpointIPtr
 IceInternal::EndpointFactoryWithUnderlying::create(vector<string>& args, bool oaEndpoint) const
 {
-    if(!_underlying)
+    if (!_underlying)
     {
-        return 0; // Can't create an endpoint without underlying factory.
+        return nullptr; // Can't create an endpoint without underlying factory.
     }
     return createWithUnderlying(_underlying->create(args, oaEndpoint), args, oaEndpoint);
 }
@@ -90,33 +83,26 @@ IceInternal::EndpointFactoryWithUnderlying::create(vector<string>& args, bool oa
 EndpointIPtr
 IceInternal::EndpointFactoryWithUnderlying::read(InputStream* s) const
 {
-    if(!_underlying)
+    if (!_underlying)
     {
-        return 0; // Can't create an endpoint without underlying factory.
+        return nullptr; // Can't create an endpoint without underlying factory.
     }
     return readWithUnderlying(_underlying->read(s), s);
 }
 
-void
-IceInternal::EndpointFactoryWithUnderlying::destroy()
-{
-    if(_underlying)
-    {
-        _underlying->destroy();
-    }
-    _instance = 0;
-}
-
 EndpointFactoryPtr
 IceInternal::EndpointFactoryWithUnderlying::clone(const ProtocolInstancePtr& instance) const
 {
     return cloneWithUnderlying(instance, _type);
 }
 
-IceInternal::UnderlyingEndpointFactory::UnderlyingEndpointFactory(const ProtocolInstancePtr& instance,
-                                                                  Short type,
-                                                                  Short underlying) :
-    _instance(instance), _type(type), _underlying(underlying)
+IceInternal::UnderlyingEndpointFactory::UnderlyingEndpointFactory(
+    ProtocolInstancePtr instance,
+    int16_t type,
+    int16_t underlying)
+    : _instance(std::move(instance)),
+      _type(type),
+      _underlying(underlying)
 {
 }
 
@@ -129,10 +115,10 @@ IceInternal::UnderlyingEndpointFactory::initialize()
     // our underlying factory.
     //
     EndpointFactoryPtr factory = _instance->getEndpointFactory(_type);
-    if(factory)
+    if (factory)
     {
-        EndpointFactoryWithUnderlying* f = dynamic_cast<EndpointFactoryWithUnderlying*>(factory.get());
-        if(f)
+        auto f = dynamic_pointer_cast<EndpointFactoryWithUnderlying>(factory);
+        if (f)
         {
             _factory = f->cloneWithUnderlying(_instance, _underlying);
             _factory->initialize();
@@ -140,7 +126,7 @@ IceInternal::UnderlyingEndpointFactory::initialize()
     }
 }
 
-Short
+int16_t
 IceInternal::UnderlyingEndpointFactory::type() const
 {
     return _instance->type();
@@ -155,9 +141,9 @@ IceInternal::UnderlyingEndpointFactory::protocol() const
 EndpointIPtr
 IceInternal::UnderlyingEndpointFactory::create(vector<string>& args, bool oaEndpoint) const
 {
-    if(!_factory)
+    if (!_factory)
     {
-        return 0;
+        return nullptr;
     }
     return _factory->create(args, oaEndpoint);
 }
@@ -165,25 +151,15 @@ IceInternal::UnderlyingEndpointFactory::create(vector<string>& args, bool oaEndp
 EndpointIPtr
 IceInternal::UnderlyingEndpointFactory::read(InputStream* s) const
 {
-    if(!_factory)
+    if (!_factory)
     {
-        return 0;
+        return nullptr;
     }
     return _factory->read(s);
 }
 
-void
-IceInternal::UnderlyingEndpointFactory::destroy()
-{
-    if(_factory)
-    {
-        _factory->destroy();
-    }
-    _instance = 0;
-}
-
 EndpointFactoryPtr
 IceInternal::UnderlyingEndpointFactory::clone(const ProtocolInstancePtr& instance) const
 {
-    return new UnderlyingEndpointFactory(instance, _type, _underlying);
+    return make_shared<UnderlyingEndpointFactory>(instance, _type, _underlying);
 }

data/dist/ice/cpp/src/Ice/EndpointFactory.h

@@ -1,117 +1,96 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_ENDPOINT_FACTORY_H
 #define ICE_ENDPOINT_FACTORY_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/EndpointIF.h>
-#include <Ice/EndpointFactoryF.h>
-#include <Ice/ProtocolInstanceF.h>
-#include <Ice/CommunicatorF.h>
-#include <Ice/Plugin.h>
+#include "EndpointFactoryF.h"
+#include "EndpointIF.h"
+#include "Ice/CommunicatorF.h"
+#include "Ice/Config.h"
+#include "Ice/Plugin.h"
+#include "ProtocolInstanceF.h"
 
 namespace Ice
 {
-
-class InputStream;
-
+    class InputStream;
 }
 
 namespace IceInternal
 {
-
-class ICE_API EndpointFactory : public ::IceUtil::Shared
-{
-public:
-
-    virtual ~EndpointFactory();
-
-    virtual void initialize();
-    virtual Ice::Short type() const = 0;
-    virtual std::string protocol() const = 0;
-    virtual EndpointIPtr create(std::vector<std::string>&, bool) const = 0;
-    virtual EndpointIPtr read(Ice::InputStream*) const = 0;
-    virtual void destroy() = 0;
-
-    virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const = 0;
-
-protected:
-
-    EndpointFactory();
-};
-
-//
-// The endpoint factory with underlying create endpoints that delegate to an underlying
-// endpoint (e.g.: the SSL/WS endpoints are endpoints with underlying endpoints).
-//
-class ICE_API EndpointFactoryWithUnderlying : public EndpointFactory
-{
-public:
-
-    EndpointFactoryWithUnderlying(const ProtocolInstancePtr&, Ice::Short);
-
-    virtual void initialize();
-    virtual Ice::Short type() const;
-    virtual std::string protocol() const;
-    virtual EndpointIPtr create(std::vector<std::string>&, bool) const;
-    virtual EndpointIPtr read(Ice::InputStream*) const;
-    virtual void destroy();
-
-    virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const;
-
-    virtual EndpointFactoryPtr cloneWithUnderlying(const ProtocolInstancePtr&, Ice::Short) const = 0;
-
-protected:
-
-    virtual EndpointIPtr createWithUnderlying(const EndpointIPtr&, std::vector<std::string>&, bool) const = 0;
-    virtual EndpointIPtr readWithUnderlying(const EndpointIPtr&, Ice::InputStream*) const = 0;
-
-    ProtocolInstancePtr _instance;
-    const Ice::Short _type;
-    EndpointFactoryPtr _underlying;
-};
-
-//
-// The underlying endpoint factory creates endpoints with a factory of the given
-// type. If this factory is of the EndpointFactoryWithUnderlying type, it will
-// delegate to the given underlying factory (this is used by IceIAP/IceBT plugins
-// for the BTS/iAPS endpoint factories).
-//
-class ICE_API UnderlyingEndpointFactory : public EndpointFactory
-{
-public:
-
-    UnderlyingEndpointFactory(const ProtocolInstancePtr&, Ice::Short, Ice::Short);
-
-    virtual void initialize();
-    virtual Ice::Short type() const;
-    virtual std::string protocol() const;
-    virtual EndpointIPtr create(std::vector<std::string>&, bool) const;
-    virtual EndpointIPtr read(Ice::InputStream*) const;
-    virtual void destroy();
-
-    virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const;
-
-private:
-
-    ProtocolInstancePtr _instance;
-    const Ice::Short _type;
-    const Ice::Short _underlying;
-    EndpointFactoryPtr _factory;
-};
-
-class ICE_API EndpointFactoryPlugin : public Ice::Plugin
-{
-public:
-
-    EndpointFactoryPlugin(const Ice::CommunicatorPtr&, const EndpointFactoryPtr&);
-
-    virtual void initialize();
-    virtual void destroy();
-};
-
+    class ICE_API EndpointFactory
+    {
+    public:
+        EndpointFactory();
+        virtual ~EndpointFactory();
+
+        virtual void initialize();
+        [[nodiscard]] virtual std::int16_t type() const = 0;
+        [[nodiscard]] virtual std::string protocol() const = 0;
+        virtual EndpointIPtr create(std::vector<std::string>&, bool) const = 0;
+        virtual EndpointIPtr read(Ice::InputStream*) const = 0;
+
+        [[nodiscard]] virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const = 0;
+    };
+
+    /// This factory is used to create endpoints that delegate to an underlying endpoint.
+    /// For example, the SSL/WS endpoints are endpoints that always delegate to underlying endpoints.
+    class ICE_API EndpointFactoryWithUnderlying : public EndpointFactory
+    {
+    public:
+        EndpointFactoryWithUnderlying(ProtocolInstancePtr, std::int16_t);
+
+        void initialize() override;
+        [[nodiscard]] std::int16_t type() const override;
+        [[nodiscard]] std::string protocol() const override;
+        EndpointIPtr create(std::vector<std::string>&, bool) const override;
+        EndpointIPtr read(Ice::InputStream*) const override;
+
+        [[nodiscard]] EndpointFactoryPtr clone(const ProtocolInstancePtr&) const override;
+
+        [[nodiscard]] virtual EndpointFactoryPtr
+        cloneWithUnderlying(const ProtocolInstancePtr&, std::int16_t) const = 0;
+
+    protected:
+        virtual EndpointIPtr createWithUnderlying(const EndpointIPtr&, std::vector<std::string>&, bool) const = 0;
+        virtual EndpointIPtr readWithUnderlying(const EndpointIPtr&, Ice::InputStream*) const = 0;
+
+        const ProtocolInstancePtr _instance;
+        const std::int16_t _type;
+        EndpointFactoryPtr _underlying;
+    };
+
+    /// The underlying endpoint factory creates endpoints with a factory of the given type.
+    /// If this factory is of the @c EndpointFactoryWithUnderlying type,
+    /// it will delegate to the given underlying factory.
+    /// @remark This is used by IceIAP/IceBT plugins for the BTS/iAPS endpoint factories.
+    class ICE_API UnderlyingEndpointFactory : public EndpointFactory
+    {
+    public:
+        UnderlyingEndpointFactory(ProtocolInstancePtr, std::int16_t, std::int16_t);
+
+        void initialize() override;
+        [[nodiscard]] std::int16_t type() const override;
+        [[nodiscard]] std::string protocol() const override;
+        EndpointIPtr create(std::vector<std::string>&, bool) const override;
+        EndpointIPtr read(Ice::InputStream*) const override;
+
+        [[nodiscard]] EndpointFactoryPtr clone(const ProtocolInstancePtr&) const override;
+
+    private:
+        const ProtocolInstancePtr _instance;
+        const std::int16_t _type;
+        const std::int16_t _underlying;
+        EndpointFactoryPtr _factory;
+    };
+
+    class ICE_API EndpointFactoryPlugin : public Ice::Plugin
+    {
+    public:
+        EndpointFactoryPlugin(const Ice::CommunicatorPtr&, const EndpointFactoryPtr&);
+
+        void initialize() override;
+        void destroy() override;
+    };
 }
 
 #endif

data/dist/ice/cpp/src/Ice/EndpointFactoryF.h

@@ -1,21 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_ENDPOINT_FACTORY_F_H
 #define ICE_ENDPOINT_FACTORY_F_H
 
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
-
-class EndpointFactory;
-ICE_API IceUtil::Shared* upCast(EndpointFactory*);
-typedef Handle<EndpointFactory> EndpointFactoryPtr;
-
+    class EndpointFactory;
+    using EndpointFactoryPtr = std::shared_ptr<EndpointFactory>;
 }
 
 #endif