zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/include/Ice/DefaultSliceLoader.h

@@ -0,0 +1,160 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_DEFAULT_SLICE_LOADER_H
+#define ICE_DEFAULT_SLICE_LOADER_H
+
+#include "SliceLoader.h"
+#include "UserException.h"
+#include <functional>
+#include <map>
+#include <mutex>
+#include <string>
+#include <type_traits>
+
+#if defined(_MSC_VER)
+#    pragma warning(push)
+#    pragma warning(disable : 4251) // class ... needs to have dll-interface to be used by clients of class ...
+#endif
+
+namespace IceInternal
+{
+    class DefaultSliceLoader;
+    using DefaultSliceLoaderPtr = std::shared_ptr<DefaultSliceLoader>;
+
+    /// A singleton SliceLoader that the generated code uses to register factories for classes and exceptions.
+    class ICE_API DefaultSliceLoader final : public Ice::SliceLoader
+    {
+    public:
+        /// Returns the singleton instance of DefaultSliceLoader.
+        /// @return The single instance of DefaultSliceLoader.
+        static DefaultSliceLoaderPtr instance();
+
+        ~DefaultSliceLoader() final;
+
+        [[nodiscard]] Ice::ValuePtr newClassInstance(std::string_view typeId) const final;
+        [[nodiscard]] std::exception_ptr newExceptionInstance(std::string_view typeId) const final;
+
+        template<class T, std::enable_if_t<std::is_base_of_v<Ice::Value, T>, bool> = true> void addClass(int compactId)
+        {
+            std::lock_guard lock{_mutex};
+            auto p = _classFactories.find(T::ice_staticId());
+            if (p == _classFactories.end())
+            {
+                _classFactories[T::ice_staticId()] = {[] { return std::make_shared<T>(); }, 1};
+            }
+            else
+            {
+                p->second.second++;
+            }
+
+            if (compactId != -1)
+            {
+                std::string compactIdStr{std::to_string(compactId)};
+                p = _classFactories.find(compactIdStr);
+                if (p == _classFactories.end())
+                {
+                    _classFactories[compactIdStr] = {[] { return std::make_shared<T>(); }, 1};
+                }
+                else
+                {
+                    p->second.second++;
+                }
+            }
+        }
+
+        void removeClass(std::string_view typeId, int compactId)
+        {
+            std::lock_guard lock{_mutex};
+            auto p = _classFactories.find(typeId);
+            if (p != _classFactories.end())
+            {
+                if (--p->second.second == 0)
+                {
+                    _classFactories.erase(p);
+                }
+            }
+
+            if (compactId != -1)
+            {
+                std::string compactIdStr{std::to_string(compactId)};
+                p = _classFactories.find(compactIdStr);
+                if (p != _classFactories.end())
+                {
+                    if (--p->second.second == 0)
+                    {
+                        _classFactories.erase(p);
+                    }
+                }
+            }
+        }
+
+        template<class T, std::enable_if_t<std::is_base_of_v<Ice::UserException, T>, bool> = true> void addException()
+        {
+            std::lock_guard lock{_mutex};
+            auto p = _exceptionFactories.find(T::ice_staticId());
+            if (p == _exceptionFactories.end())
+            {
+                _exceptionFactories[T::ice_staticId()] = {[] { return std::make_exception_ptr(T{}); }, 1};
+            }
+            else
+            {
+                p->second.second++;
+            }
+        }
+
+        void removeException(std::string_view typeId)
+        {
+            std::lock_guard lock{_mutex};
+            auto p = _exceptionFactories.find(typeId);
+            if (p != _exceptionFactories.end())
+            {
+                if (--p->second.second == 0)
+                {
+                    _exceptionFactories.erase(p);
+                }
+            }
+        }
+
+    private:
+        using ClassFactory = std::function<Ice::ValuePtr()>;
+        using ExceptionFactory = std::function<std::exception_ptr()>;
+
+        DefaultSliceLoader() = default;
+
+        mutable std::mutex _mutex;
+
+        std::map<std::string, std::pair<ClassFactory, int>, std::less<>> _classFactories;
+        std::map<std::string, std::pair<ExceptionFactory, int>, std::less<>> _exceptionFactories;
+    };
+
+    template<class T> class ClassInit
+    {
+    public:
+        explicit ClassInit(int compactId = -1) noexcept : _typeId(T::ice_staticId()), _compactId(compactId)
+        {
+            DefaultSliceLoader::instance()->addClass<T>(compactId);
+        }
+
+        ~ClassInit() { DefaultSliceLoader::instance()->removeClass(_typeId, _compactId); }
+
+    private:
+        const char* _typeId;
+        int _compactId;
+    };
+
+    template<class T> class ExceptionInit
+    {
+    public:
+        ExceptionInit() noexcept : _typeId(T::ice_staticId()) { DefaultSliceLoader::instance()->addException<T>(); }
+        ~ExceptionInit() { DefaultSliceLoader::instance()->removeException(_typeId); }
+
+    private:
+        const char* _typeId;
+    };
+}
+
+#if defined(_MSC_VER)
+#    pragma warning(pop)
+#endif
+
+#endif

data/dist/ice/cpp/include/Ice/Demangle.h

@@ -0,0 +1,17 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_DEMANGLE_H
+#define ICE_DEMANGLE_H
+
+#include "Config.h"
+#include <string>
+
+namespace IceInternal
+{
+    /// Demangles a C++ type type.
+    /// @param name The possibly mangled type name, as returned by typeid().name().
+    /// @return The demangled name.
+    ICE_API std::string demangle(const char* name);
+}
+
+#endif

data/dist/ice/cpp/include/Ice/Endpoint.h

@@ -0,0 +1,298 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_H
+#define ICE_ENDPOINT_H
+
+#include "EndpointF.h"
+#include "Ice/EndpointTypes.h"
+#include "Ice/Version.h"
+
+#include <string>
+#include <vector>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wshadow-field-in-constructor"
+#elif defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
+namespace Ice
+{
+    /// An endpoint specifies the address of the server-end of an Ice connection.
+    /// An object adapter listens on one or more endpoints and a client establishes a connection to an endpoint.
+    /// @headerfile Ice/Ice.h
+    class ICE_API Endpoint
+    {
+    public:
+        /// Default constructor.
+        Endpoint() = default;
+
+        virtual ~Endpoint();
+
+        Endpoint(const Endpoint&) = delete;
+        Endpoint& operator=(const Endpoint&) = delete;
+
+        /// Operator equal to. Checks if this endpoint is equal to the @p rhs endpoint.
+        /// @param rhs The endpoint to compare against.
+        /// @return `true` if the endpoints are equal, `false` otherwise.
+        virtual bool operator==(const Endpoint& rhs) const = 0;
+
+        /// Operator less than. Checks if this endpoint is less than the @p rhs endpoint.
+        /// @param rhs The endpoint to compare against.
+        /// @return `true` if this endpoint is less than the @p rhs endpoint, `false` otherwise.
+        virtual bool operator<(const Endpoint& rhs) const = 0;
+
+        /// Returns a string representation of this endpoint.
+        /// @return The string representation of this endpoint.
+        [[nodiscard]] virtual std::string toString() const noexcept = 0;
+
+        /// Returns this endpoint's information.
+        /// @return This endpoint's information class.
+        [[nodiscard]] virtual EndpointInfoPtr getInfo() const noexcept = 0;
+    };
+
+    /// Base class for the endpoint info classes.
+    /// @headerfile Ice/Ice.h
+    class ICE_API EndpointInfo
+    {
+    public:
+        virtual ~EndpointInfo();
+        EndpointInfo(const EndpointInfo&) = delete;
+        EndpointInfo& operator=(const EndpointInfo&) = delete;
+
+        /// Returns the type of the endpoint.
+        /// @return The endpoint type.
+        [[nodiscard]] virtual std::int16_t type() const noexcept;
+
+        /// Returns `true` if this endpoint's transport is a datagram transport (namely, UDP), `false` otherwise.
+        /// @return `true` for a UDP endpoint, `false` otherwise.
+        [[nodiscard]] virtual bool datagram() const noexcept;
+
+        /// Returns `true` if this endpoint's transport uses SSL, `false` otherwise.
+        /// @return `true` for SSL and SSL-based transports, `false` otherwise.
+        [[nodiscard]] virtual bool secure() const noexcept;
+
+        /// The information of the underlying endpoint or nullptr if there's no underlying endpoint.
+        const EndpointInfoPtr underlying;
+
+        /// Specifies whether or not compression should be used if available when using this endpoint.
+        const bool compress;
+
+    protected:
+        /// @private
+        explicit EndpointInfo(EndpointInfoPtr underlyingInfo)
+            : underlying(std::move(underlyingInfo)),
+              compress(underlying->compress)
+        {
+        }
+
+        /// @private
+        explicit EndpointInfo(bool compress) : compress(compress) {}
+    };
+
+    /// Provides access to the address details of an IP endpoint.
+    /// @see Endpoint
+    /// @headerfile Ice/Ice.h
+    class ICE_API IPEndpointInfo : public EndpointInfo
+    {
+    public:
+        IPEndpointInfo(const IPEndpointInfo&) = delete;
+        IPEndpointInfo& operator=(const IPEndpointInfo&) = delete;
+
+        ~IPEndpointInfo() override;
+
+        /// The host or address configured with the endpoint.
+        const std::string host;
+
+        /// The port number.
+        const int port;
+
+        /// The source IP address.
+        const std::string sourceAddress;
+
+    protected:
+        /// @private
+        IPEndpointInfo(bool compress, std::string host, int port, std::string sourceAddress)
+            : EndpointInfo{compress},
+              host{std::move(host)},
+              port{port},
+              sourceAddress{std::move(sourceAddress)}
+        {
+        }
+    };
+
+    /// Provides access to a TCP endpoint information.
+    /// @see Endpoint
+    /// @headerfile Ice/Ice.h
+    class ICE_API TCPEndpointInfo final : public IPEndpointInfo
+    {
+    public:
+        ~TCPEndpointInfo() final;
+        TCPEndpointInfo(const TCPEndpointInfo&) = delete;
+        TCPEndpointInfo& operator=(const TCPEndpointInfo&) = delete;
+
+        [[nodiscard]] std::int16_t type() const noexcept final { return _type; }
+        [[nodiscard]] bool secure() const noexcept final { return _secure; }
+
+        /// @private
+        TCPEndpointInfo(
+            bool compress,
+            std::string host,
+            int port,
+            std::string sourceAddress,
+            std::int16_t type,
+            bool secure)
+            : IPEndpointInfo{compress, std::move(host), port, std::move(sourceAddress)},
+              _type{type},
+              _secure{secure}
+        {
+        }
+
+    private:
+        const std::int16_t _type;
+        const bool _secure;
+    };
+
+    /// Provides access to a UDP endpoint information.
+    /// @see Endpoint
+    /// @headerfile Ice/Ice.h
+    class ICE_API UDPEndpointInfo final : public IPEndpointInfo
+    {
+    public:
+        ~UDPEndpointInfo() final;
+        UDPEndpointInfo(const UDPEndpointInfo&) = delete;
+        UDPEndpointInfo& operator=(const UDPEndpointInfo&) = delete;
+
+        /// The multicast interface.
+        const std::string mcastInterface;
+
+        /// The multicast time-to-live (or hops).
+        const int mcastTtl;
+
+        [[nodiscard]] std::int16_t type() const noexcept final { return UDPEndpointType; }
+        [[nodiscard]] bool datagram() const noexcept final { return true; }
+
+        /// @private
+        UDPEndpointInfo(
+            bool compress,
+            std::string host,
+            int port,
+            std::string sourceAddress,
+            std::string mcastInterface,
+            int mcastTtl)
+            : IPEndpointInfo{compress, std::move(host), port, std::move(sourceAddress)},
+              mcastInterface{std::move(mcastInterface)},
+              mcastTtl{mcastTtl}
+        {
+        }
+    };
+
+    /// Provides access to a WebSocket endpoint information.
+    /// @headerfile Ice/Ice.h
+    class ICE_API WSEndpointInfo final : public EndpointInfo
+    {
+    public:
+        ~WSEndpointInfo() final;
+        WSEndpointInfo(const WSEndpointInfo&) = delete;
+        WSEndpointInfo& operator=(const WSEndpointInfo&) = delete;
+
+        /// The URI configured with the endpoint.
+        const std::string resource;
+
+        /// @private
+        WSEndpointInfo(EndpointInfoPtr underlying, std::string resource)
+            : EndpointInfo{std::move(underlying)},
+              resource{std::move(resource)}
+        {
+        }
+    };
+
+    /// Provides access to an IAP endpoint information.
+    /// @headerfile Ice/Ice.h
+    class IAPEndpointInfo final : public EndpointInfo
+    {
+    public:
+        ~IAPEndpointInfo() final;
+        IAPEndpointInfo(const IAPEndpointInfo&) = delete;
+        IAPEndpointInfo& operator=(const IAPEndpointInfo&) = delete;
+
+        [[nodiscard]] std::int16_t type() const noexcept final { return _type; }
+        [[nodiscard]] bool secure() const noexcept final { return _secure; }
+
+        /// The accessory manufacturer. Can be empty.
+        const std::string manufacturer;
+
+        /// The accessory model number. Can be empty.
+        const std::string modelNumber;
+
+        /// The accessory name. Can be empty.
+        const std::string name;
+
+        /// The protocol supported by the accessory.
+        const std::string protocol;
+
+        /// @private
+        IAPEndpointInfo(
+            bool compress,
+            std::string manufacturer,
+            std::string modelNumber,
+            std::string name,
+            std::string protocol,
+            std::int16_t type,
+            bool secure)
+            : EndpointInfo{compress},
+              manufacturer{std::move(manufacturer)},
+              modelNumber{std::move(modelNumber)},
+              name{std::move(name)},
+              protocol{std::move(protocol)},
+              _type{type},
+              _secure{secure}
+        {
+        }
+
+    private:
+        const std::int16_t _type;
+        const bool _secure;
+    };
+
+    /// Provides access to the details of an opaque endpoint.
+    /// @see Endpoint
+    /// @headerfile Ice/Ice.h
+    class ICE_API OpaqueEndpointInfo final : public EndpointInfo
+    {
+    public:
+        ~OpaqueEndpointInfo() final;
+        OpaqueEndpointInfo(const OpaqueEndpointInfo&) = delete;
+        OpaqueEndpointInfo& operator=(const OpaqueEndpointInfo&) = delete;
+
+        [[nodiscard]] std::int16_t type() const noexcept final { return _type; }
+
+        /// The encoding version of the opaque endpoint (to decode or encode the rawBytes).
+        const Ice::EncodingVersion rawEncoding;
+
+        /// The raw encoding of the opaque endpoint.
+        const std::vector<std::byte> rawBytes;
+
+        /// @private
+        OpaqueEndpointInfo(std::int16_t type, Ice::EncodingVersion rawEncoding, std::vector<std::byte> rawBytes)
+            : EndpointInfo{false},
+              rawEncoding{rawEncoding},
+              rawBytes{std::move(rawBytes)},
+              _type{type}
+        {
+        }
+
+    private:
+        std::int16_t _type;
+    };
+}
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+
+#endif

data/dist/ice/cpp/include/Ice/EndpointF.h

@@ -0,0 +1,44 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_F_H
+#define ICE_ENDPOINT_F_H
+
+#include <memory>
+#include <vector>
+
+namespace Ice
+{
+    class Endpoint;
+    class EndpointInfo;
+    class IPEndpointInfo;
+    class OpaqueEndpointInfo;
+    class TCPEndpointInfo;
+    class UDPEndpointInfo;
+    class WSEndpointInfo;
+
+    /// A shared pointer to an Endpoint.
+    using EndpointPtr = std::shared_ptr<Endpoint>;
+
+    /// A shared pointer to an EndpointInfo.
+    using EndpointInfoPtr = std::shared_ptr<EndpointInfo>;
+
+    /// A shared pointer to an IPEndpointInfo.
+    using IPEndpointInfoPtr = std::shared_ptr<IPEndpointInfo>;
+
+    /// A shared pointer to an OpaqueEndpointInfo.
+    using OpaqueEndpointInfoPtr = std::shared_ptr<OpaqueEndpointInfo>;
+
+    /// A shared pointer to a TCPEndpointInfo.
+    using TCPEndpointInfoPtr = std::shared_ptr<TCPEndpointInfo>;
+
+    /// A shared pointer to a UDPEndpointInfo.
+    using UDPEndpointInfoPtr = std::shared_ptr<UDPEndpointInfo>;
+
+    /// A shared pointer to a WSEndpointInfo.
+    using WSEndpointInfoPtr = std::shared_ptr<WSEndpointInfo>;
+
+    /// A sequence of endpoints.
+    using EndpointSeq = std::vector<EndpointPtr>;
+}
+
+#endif

data/dist/ice/cpp/include/Ice/EndpointSelectionType.h

@@ -0,0 +1,21 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_SELECTION_TYPE_H
+#define ICE_ENDPOINT_SELECTION_TYPE_H
+
+#include <cstdint>
+
+namespace Ice
+{
+    /// Determines how the Ice runtime sorts proxy endpoints when establishing a connection.
+    enum class EndpointSelectionType : std::uint8_t
+    {
+        /// The Ice runtime shuffles the endpoints in a random order.
+        Random,
+
+        /// The Ice runtime uses the endpoints in the order they appear in the proxy.
+        Ordered
+    };
+}
+
+#endif