zeroc-ice 3.7.9.1 → 3.8.0

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

@@ -0,0 +1,103 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_TUPLE_COMPARE_H
+#define ICE_TUPLE_COMPARE_H
+
+#include <tuple>
+#include <type_traits>
+
+/// Relational operators for generated structs.
+namespace Ice::Tuple
+{
+    /// Operator less-than for generated structs.
+    /// @tparam T The type of the generated struct.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if @p lhs is less than @p rhs, `false` otherwise.
+    template<
+        class T,
+        std::enable_if_t<
+            std::is_member_function_pointer_v<decltype(&T::ice_tuple)> && !std::is_polymorphic_v<T>,
+            bool> = true>
+    inline bool operator<(const T& lhs, const T& rhs)
+    {
+        return lhs.ice_tuple() < rhs.ice_tuple();
+    }
+
+    /// Operator less-than or equal to for generated structs.
+    /// @tparam T The type of the generated struct.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if @p lhs is less than or equal to @p rhs, `false` otherwise.
+    template<
+        class T,
+        std::enable_if_t<
+            std::is_member_function_pointer_v<decltype(&T::ice_tuple)> && !std::is_polymorphic_v<T>,
+            bool> = true>
+    inline bool operator<=(const T& lhs, const T& rhs)
+    {
+        return lhs.ice_tuple() <= rhs.ice_tuple();
+    }
+
+    /// Operator greater-than for generated structs.
+    /// @tparam T The type of the generated struct.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if @p lhs is greater than @p rhs, `false` otherwise.
+    template<
+        class T,
+        std::enable_if_t<
+            std::is_member_function_pointer_v<decltype(&T::ice_tuple)> && !std::is_polymorphic_v<T>,
+            bool> = true>
+    inline bool operator>(const T& lhs, const T& rhs)
+    {
+        return lhs.ice_tuple() > rhs.ice_tuple();
+    }
+
+    /// Operator greater-than or equal to for generated structs.
+    /// @tparam T The type of the generated struct.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if @p lhs is greater than or equal to @p rhs, `false` otherwise.
+    template<
+        class T,
+        std::enable_if_t<
+            std::is_member_function_pointer_v<decltype(&T::ice_tuple)> && !std::is_polymorphic_v<T>,
+            bool> = true>
+    inline bool operator>=(const T& lhs, const T& rhs)
+    {
+        return lhs.ice_tuple() >= rhs.ice_tuple();
+    }
+
+    /// Operator equal to for generated structs.
+    /// @tparam T The type of the generated struct.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if @p lhs is equal to @p rhs, `false` otherwise.
+    template<
+        class T,
+        std::enable_if_t<
+            std::is_member_function_pointer_v<decltype(&T::ice_tuple)> && !std::is_polymorphic_v<T>,
+            bool> = true>
+    inline bool operator==(const T& lhs, const T& rhs)
+    {
+        return lhs.ice_tuple() == rhs.ice_tuple();
+    }
+
+    /// Operator not equal to for generated structs.
+    /// @tparam T The type of the generated struct.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if @p lhs is not equal to @p rhs, `false` otherwise.
+    template<
+        class T,
+        std::enable_if_t<
+            std::is_member_function_pointer_v<decltype(&T::ice_tuple)> && !std::is_polymorphic_v<T>,
+            bool> = true>
+    inline bool operator!=(const T& lhs, const T& rhs)
+    {
+        return lhs.ice_tuple() != rhs.ice_tuple();
+    }
+}
+
+#endif

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

@@ -0,0 +1,16 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_UUID_H
+#define ICE_UUID_H
+
+#include "Config.h"
+#include <string>
+
+namespace Ice
+{
+    /// Generates a universally unique identifier (UUID).
+    /// @return The UUID.
+    ICE_API std::string generateUUID();
+}
+
+#endif

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

@@ -0,0 +1,46 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_USER_EXCEPTION_H
+#define ICE_USER_EXCEPTION_H
+
+#include "Exception.h"
+
+namespace Ice
+{
+    class InputStream;
+    class OutputStream;
+
+    /// Abstract base class for all exceptions defined in Slice.
+    /// @headerfile Ice/Ice.h
+    class ICE_API UserException : public Exception
+    {
+    public:
+        /// Throws this exception.
+        virtual void ice_throw() const = 0;
+
+        /// Gets the Slice type ID of this user exception.
+        /// @return The Slice type ID.
+        [[nodiscard]] const char* what() const noexcept final;
+
+        void ice_print(std::ostream& os) const override;
+
+        /// Outputs the name and value of each field of this instance, including inherited fields, to the stream.
+        /// @param os The output stream.
+        virtual void ice_printFields(std::ostream& os) const;
+
+        /// @cond INTERNAL
+
+        // _write and _read are virtual for the Python, Ruby etc. mappings.
+        virtual void _write(OutputStream*) const;
+        virtual void _read(InputStream*);
+
+        [[nodiscard]] virtual bool _usesClasses() const;
+
+    protected:
+        virtual void _writeImpl(OutputStream*) const = 0;
+        virtual void _readImpl(InputStream*) = 0;
+        /// @endcond
+    };
+}
+
+#endif

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

@@ -0,0 +1,15 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_USER_EXCEPTION_FACTORY_H
+#define ICE_USER_EXCEPTION_FACTORY_H
+
+#include <functional>
+#include <string_view>
+
+namespace Ice
+{
+    /// Creates and throws a user exception.
+    using UserExceptionFactory = std::function<void(std::string_view)>;
+}
+
+#endif

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

@@ -0,0 +1,127 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_VALUE_H
+#define ICE_VALUE_H
+
+#include "Config.h"
+#include "SlicedDataF.h"
+#include "ValueF.h"
+
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+namespace Ice
+{
+    class OutputStream;
+    class InputStream;
+
+    /// The base class for instances of Slice-defined classes.
+    /// @headerfile Ice/Ice.h
+    class ICE_API Value
+    {
+    public:
+        /// Default constructor.
+        Value() noexcept = default;
+
+        // There is no copy constructor, move constructor, copy-assignment operator or move-assignment operator to
+        // prevent accidental slicing.
+        Value(Value&&) = delete;
+
+        virtual ~Value();
+
+        Value& operator=(const Value&) = delete;
+        Value& operator=(Value&&) = delete;
+
+        /// The Ice runtime calls this function before marshaling a class instance.
+        /// Subclasses can override this function in order to update or validate their fields before marshaling.
+        virtual void ice_preMarshal() {}
+
+        /// The Ice runtime calls this function after unmarshaling a class instance.
+        /// Subclasses can override this function in order to update or validate their fields after unmarshaling.
+        virtual void ice_postUnmarshal() {}
+
+        /// Gets the Slice type ID of the most-derived class supported by this object.
+        /// @return The Slice type ID.
+        [[nodiscard]] virtual const char* ice_id() const noexcept;
+
+        /// Gets the Slice type ID of this type.
+        /// @return The return value is always "::Ice::Object".
+        static const char* ice_staticId() noexcept;
+
+        /// Creates a shallow polymorphic copy of this instance.
+        /// @return The cloned value.
+        [[nodiscard]] ValuePtr ice_clone() const { return _iceCloneImpl(); }
+
+        /// Gets the sliced data associated with this instance.
+        /// @return The sliced data if the value has a preserved-slice base class and has been sliced during
+        /// unmarshaling of the value, null otherwise.
+        [[nodiscard]] SlicedDataPtr ice_getSlicedData() const;
+
+        /// Outputs a description of this instance to the stream. This description includes the type name and the name
+        /// and value of all the fields of this instance.
+        /// Use ["cpp:custom-print"] to tell the Slice compiler to generate an override implemented by the application.
+        /// @param os The output stream.
+        virtual void ice_print(std::ostream& os) const;
+
+        /// Outputs the name and value of each field of this instance, including inherited fields, to the stream.
+        /// Classes generated by the Slice compiler override this function.
+        /// @param os The output stream.
+        virtual void ice_printFields(std::ostream& os) const;
+
+        /// @cond INTERNAL
+
+        virtual void _iceWrite(Ice::OutputStream*) const;
+        virtual void _iceRead(Ice::InputStream*);
+
+    protected:
+        Value(const Value&) = default; // for clone
+
+        // Helper class that allows derived classes to clone "this" even though the copy constructor is protected.
+        template<class T> struct CloneEnabler : public T
+        {
+            CloneEnabler(const T& other) : T(other) {}
+            static std::shared_ptr<T> clone(const T& other) { return std::make_shared<CloneEnabler>(other); }
+        };
+
+        [[nodiscard]] virtual ValuePtr _iceCloneImpl() const;
+
+        virtual void _iceWriteImpl(Ice::OutputStream*) const {}
+        virtual void _iceReadImpl(Ice::InputStream*) {}
+        /// @endcond
+
+    private:
+        SlicedDataPtr _slicedData;
+    };
+
+    /// Outputs the description of a class instance to a stream. This function calls Value::ice_print on @p value.
+    /// @param os The output stream.
+    /// @param value The class instance.
+    /// @return The output stream.
+    inline std::ostream& operator<<(std::ostream& os, const Value& value)
+    {
+        value.ice_print(os);
+        return os;
+    }
+
+    /// Outputs the description of a class instance held in a shared_ptr.
+    /// @tparam T The class type.
+    /// @param os The output stream.
+    /// @param value The class instance held in a shared pointer. May be null.
+    /// @return The output stream.
+    template<class T, std::enable_if_t<std::is_base_of_v<Value, T>, bool> = true>
+    inline std::ostream& operator<<(std::ostream& os, const std::shared_ptr<T>& value)
+    {
+        if (value)
+        {
+            os << *value;
+        }
+        else
+        {
+            os << "nullptr";
+        }
+        return os;
+    }
+}
+
+#endif

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

@@ -0,0 +1,16 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_VALUE_F_H
+#define ICE_VALUE_F_H
+
+#include <memory>
+
+namespace Ice
+{
+    class Value;
+
+    /// A shared pointer to a Value.
+    using ValuePtr = std::shared_ptr<Value>;
+}
+
+#endif

data/dist/ice/cpp/include/IceDiscovery/IceDiscovery.h

@@ -0,0 +1,28 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_DISCOVERY_H
+#define ICE_DISCOVERY_H
+
+#include "Ice/Ice.h"
+
+#ifndef ICE_DISCOVERY_API
+#    ifdef ICE_DISCOVERY_API_EXPORTS
+#        define ICE_DISCOVERY_API ICE_DECLSPEC_EXPORT
+#    else
+#        define ICE_DISCOVERY_API /**/
+#    endif
+#endif
+
+#if defined(_MSC_VER) && !defined(ICE_DISCOVERY_API_EXPORTS) && !defined(ICE_DISABLE_PRAGMA_COMMENT)
+#    pragma comment(lib, ICE_LIBNAME("IceDiscovery")) // Automatically link with IceDiscovery[D].lib
+#endif
+
+namespace IceDiscovery
+{
+    /// Returns the factory for the IceDiscovery plug-in.
+    /// @return The factory for the IceDiscovery plug-in.
+    /// @see Ice::InitializationData::pluginFactories
+    ICE_DISCOVERY_API Ice::PluginFactory discoveryPluginFactory();
+}
+
+#endif

data/dist/ice/cpp/include/IceLocatorDiscovery/IceLocatorDiscovery.h

@@ -0,0 +1,28 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_LOCATOR_DISCOVERY_H
+#define ICE_LOCATOR_DISCOVERY_H
+
+#include "Ice/Ice.h"
+
+#ifndef ICE_LOCATOR_DISCOVERY_API
+#    ifdef ICE_LOCATOR_DISCOVERY_API_EXPORTS
+#        define ICE_LOCATOR_DISCOVERY_API ICE_DECLSPEC_EXPORT
+#    else
+#        define ICE_LOCATOR_DISCOVERY_API /**/
+#    endif
+#endif
+
+#if defined(_MSC_VER) && !defined(ICE_LOCATOR_DISCOVERY_API_EXPORTS) && !defined(ICE_DISABLE_PRAGMA_COMMENT)
+#    pragma comment(lib, ICE_LIBNAME("IceLocatorDiscovery")) // Automatically link with IceLocatorDiscovery[D].lib
+#endif
+
+namespace IceLocatorDiscovery
+{
+    /// Returns the factory for the IceLocatorDiscovery plug-in.
+    /// @return The factory for the IceLocatorDiscovery plug-in.
+    /// @see Ice::InitializationData::pluginFactories
+    ICE_LOCATOR_DISCOVERY_API Ice::PluginFactory locatorDiscoveryPluginFactory();
+}
+
+#endif

data/dist/ice/cpp/include/generated/Ice/BuiltinSequences.h

@@ -0,0 +1,70 @@
+// Copyright (c) ZeroC, Inc.
+
+// slice2cpp version 3.8.0
+// <auto-generated>Generated from Slice file 'BuiltinSequences.ice'.</auto-generated>
+// clang-format off
+
+#ifndef Ice_BuiltinSequences_h_
+#define Ice_BuiltinSequences_h_
+
+#include <Ice/PushDisableWarnings.h>
+#include <Ice/Config.h>
+#include <Ice/ObjectF.h>
+#include <Ice/ProxyF.h>
+#include <Ice/ValueF.h>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+#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 < 0
+#       error Ice patch level mismatch!
+#   endif
+#endif
+
+// NOLINTBEGIN(modernize-concat-nested-namespaces)
+
+namespace Ice
+{
+    /// A sequence of bools.
+    using BoolSeq = std::vector<bool>;
+
+    /// A sequence of bytes.
+    using ByteSeq = std::vector<std::byte>;
+
+    /// A sequence of shorts.
+    using ShortSeq = std::vector<std::int16_t>;
+
+    /// A sequence of ints.
+    using IntSeq = std::vector<std::int32_t>;
+
+    /// A sequence of longs.
+    using LongSeq = std::vector<std::int64_t>;
+
+    /// A sequence of floats.
+    using FloatSeq = std::vector<float>;
+
+    /// A sequence of doubles.
+    using DoubleSeq = std::vector<double>;
+
+    /// A sequence of strings.
+    using StringSeq = std::vector<std::string>;
+
+    /// A sequence of class instances.
+    using ObjectSeq [[deprecated("Define your own sequence instead and avoid using the term `object` to designate a class instance.")]] = std::vector<Ice::ValuePtr>;
+
+    /// A sequence of object proxies.
+    using ObjectProxySeq = std::vector<std::optional<Ice::ObjectPrx>>;
+}
+
+// NOLINTEND(modernize-concat-nested-namespaces)
+
+#include <Ice/PopDisableWarnings.h>
+#endif

data/dist/ice/cpp/include/generated/Ice/Context.h

@@ -0,0 +1,40 @@
+// Copyright (c) ZeroC, Inc.
+
+// slice2cpp version 3.8.0
+// <auto-generated>Generated from Slice file 'Context.ice'.</auto-generated>
+// clang-format off
+
+#ifndef Ice_Context_h_
+#define Ice_Context_h_
+
+#include <Ice/PushDisableWarnings.h>
+#include <Ice/Config.h>
+#include <map>
+#include <string>
+
+#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 < 0
+#       error Ice patch level mismatch!
+#   endif
+#endif
+
+// NOLINTBEGIN(modernize-concat-nested-namespaces)
+
+namespace Ice
+{
+    /// Represents additional information carried by an Ice request. This information is filled in by the application
+    /// and transmitted by Ice as-is, from the client to the server.
+    /// @remarks The Ice protocol provides request contexts but does not provide response contexts.
+    using Context = std::map<std::string, std::string, std::less<>>;
+}
+
+// NOLINTEND(modernize-concat-nested-namespaces)
+
+#include <Ice/PopDisableWarnings.h>
+#endif

data/dist/ice/cpp/include/generated/Ice/EndpointTypes.h

@@ -0,0 +1,74 @@
+// Copyright (c) ZeroC, Inc.
+
+// slice2cpp version 3.8.0
+// <auto-generated>Generated from Slice file 'EndpointTypes.ice'.</auto-generated>
+// clang-format off
+
+#ifndef Ice_EndpointTypes_h_
+#define Ice_EndpointTypes_h_
+
+#include <Ice/PushDisableWarnings.h>
+#include <Ice/Config.h>
+#include <cstdint>
+
+#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 < 0
+#       error Ice patch level mismatch!
+#   endif
+#endif
+
+// NOLINTBEGIN(modernize-concat-nested-namespaces)
+
+namespace Ice
+{
+    /// Identifies endpoints marshaled as URI strings.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::URIEndpointType`.
+    constexpr std::int16_t URIEndpointType = 0;
+
+    /// Identifies TCP endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::TCPEndpointType`.
+    constexpr std::int16_t TCPEndpointType = 1;
+
+    /// Identifies SSL endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::SSLEndpointType`.
+    constexpr std::int16_t SSLEndpointType = 2;
+
+    /// Identifies UDP endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::UDPEndpointType`.
+    constexpr std::int16_t UDPEndpointType = 3;
+
+    /// Identifies TCP-based WebSocket endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::WSEndpointType`.
+    constexpr std::int16_t WSEndpointType = 4;
+
+    /// Identifies SSL-based WebSocket endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::WSSEndpointType`.
+    constexpr std::int16_t WSSEndpointType = 5;
+
+    /// Identifies Bluetooth endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::BTEndpointType`.
+    constexpr std::int16_t BTEndpointType = 6;
+
+    /// Identifies SSL Bluetooth endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::BTSEndpointType`.
+    constexpr std::int16_t BTSEndpointType = 7;
+
+    /// Identifies iAP-based endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::iAPEndpointType`.
+    constexpr std::int16_t iAPEndpointType = 8;
+
+    /// Identifies SSL iAP-based endpoints.
+    /// @remarks The Slice compiler generated this constant from Slice constant `::Ice::iAPSEndpointType`.
+    constexpr std::int16_t iAPSEndpointType = 9;
+}
+
+// NOLINTEND(modernize-concat-nested-namespaces)
+
+#include <Ice/PopDisableWarnings.h>
+#endif

data/dist/ice/cpp/include/generated/Ice/Identity.h

@@ -0,0 +1,108 @@
+// Copyright (c) ZeroC, Inc.
+
+// slice2cpp version 3.8.0
+// <auto-generated>Generated from Slice file 'Identity.ice'.</auto-generated>
+// clang-format off
+
+#ifndef Ice_Identity_h_
+#define Ice_Identity_h_
+
+#include <Ice/PushDisableWarnings.h>
+#include <Ice/Config.h>
+#include <Ice/StreamHelpers.h>
+#include <Ice/TupleCompare.h>
+#include <string>
+#include <vector>
+
+#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 < 0
+#       error Ice patch level mismatch!
+#   endif
+#endif
+
+// NOLINTBEGIN(modernize-concat-nested-namespaces)
+
+/// The Ice RPC framework.
+namespace Ice
+{
+    struct Identity;
+
+    /// A sequence of identities.
+    using IdentitySeq = std::vector<Identity>;
+}
+
+namespace Ice
+{
+    /// Represents the identity of an Ice object. It is comparable to the path of a URI. Its string representation is
+    /// `name` when the category is empty, and `category/name` when the category is not empty.
+    /// @remarks The Slice compiler generated this struct from Slice struct `::Ice::Identity`.
+    /// @headerfile Ice/Ice.h
+    struct Identity
+    {
+        /// The name of the Ice object. An empty name is not valid.
+        std::string name;
+
+        /// The category of the object.
+        std::string category{};
+
+        /// Creates a tuple with all the fields of this struct.
+        /// @return A tuple with all the fields of this struct.
+        [[nodiscard]] std::tuple<const std::string&, const std::string&> ice_tuple() const
+        {
+            return std::tie(name, category);
+        }
+
+        /// Outputs the name and value of each field of this instance to the stream.
+        /// @param os The output stream.
+        ICE_API void ice_printFields(std::ostream& os) const;
+    };
+
+    /// Outputs the description of an Identity to a stream, including all its fields.
+    /// @param os The output stream.
+    /// @param value The instance to output.
+    /// @return The output stream.
+    ICE_API std::ostream& operator<<(std::ostream& os, const Identity& value);
+
+    /// @cond INTERNAL
+    using Ice::Tuple::operator<;
+    using Ice::Tuple::operator<=;
+    using Ice::Tuple::operator>;
+    using Ice::Tuple::operator>=;
+    using Ice::Tuple::operator==;
+    using Ice::Tuple::operator!=;
+    /// @endcond
+}
+
+namespace Ice
+{
+    /// @cond INTERNAL
+    template<>
+    struct StreamableTraits<::Ice::Identity>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
+        static constexpr int minWireSize = 2;
+        static constexpr bool fixedLength = false;
+    };
+
+    template<>
+    struct StreamReader<::Ice::Identity>
+    {
+        /// Unmarshals a ::Ice::Identity from the input stream.
+        static void read(InputStream* istr, ::Ice::Identity& v)
+        {
+            istr->readAll(v.name, v.category);
+        }
+    };
+    /// @endcond
+}
+
+// NOLINTEND(modernize-concat-nested-namespaces)
+
+#include <Ice/PopDisableWarnings.h>
+#endif