zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,19 +1,16 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_UUID_H
 #define ICE_UUID_H
 
-#include <Ice/Config.h>
-#include <IceUtil/UUID.h>
+#include "Config.h"
+#include <string>
 
 namespace Ice
 {
-
-/** Generates a UUID. */
-using IceUtil::generateUUID;
-
+    /// 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

@@ -1,90 +1,15 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_USER_EXCEPTION_FACTORY_H
 #define ICE_USER_EXCEPTION_FACTORY_H
 
-#include <IceUtil/Shared.h>
-#include <IceUtil/Handle.h>
-#include <Ice/Config.h>
-
-#ifdef ICE_CPP11_MAPPING
-
 #include <functional>
+#include <string_view>
 
 namespace Ice
 {
-
-/** Creates and throws a user exception. */
-using UserExceptionFactory = std::function<void(const std::string&)>;
-
-}
-
-namespace IceInternal
-{
-
-template<class E>
-void
-#ifdef NDEBUG
-defaultUserExceptionFactory(const std::string&)
-#else
-defaultUserExceptionFactory(const std::string& typeId)
-#endif
-{
-    assert(typeId == E::ice_staticId());
-    throw E();
-}
-
+    /// Creates and throws a user exception.
+    using UserExceptionFactory = std::function<void(std::string_view)>;
 }
-#else
 
-namespace Ice
-{
-
-/**
- * Creates and throws a user exception.
- * \headerfile Ice/Ice.h
- */
-class ICE_API UserExceptionFactory : public IceUtil::Shared
-{
-public:
-
-    virtual void createAndThrow(const ::std::string&) = 0;
-    virtual ~UserExceptionFactory();
-};
-typedef ::IceUtil::Handle<UserExceptionFactory> UserExceptionFactoryPtr;
-
-}
-
-namespace IceInternal
-{
-
-template<class E>
-class DefaultUserExceptionFactory : public Ice::UserExceptionFactory
-{
-public:
-
-    DefaultUserExceptionFactory(const ::std::string& typeId) :
-        _typeId(typeId)
-    {
-    }
-
-#ifdef NDEBUG
-    virtual void createAndThrow(const ::std::string&)
-#else
-    virtual void createAndThrow(const ::std::string& typeId)
-#endif
-    {
-        assert(typeId == _typeId);
-        throw E();
-    }
-
-private:
-    const ::std::string _typeId;
-};
-
-}
-
-#endif
 #endif

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

@@ -1,139 +1,127 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_VALUE_H
 #define ICE_VALUE_H
 
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
+#include "Config.h"
+#include "SlicedDataF.h"
+#include "ValueF.h"
 
-#include <Ice/ValueF.h>
-#include <Ice/SlicedDataF.h>
-
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
+#include <ostream>
+#include <string>
+#include <type_traits>
 
 namespace Ice
 {
+    class OutputStream;
+    class InputStream;
 
-/**
- * The base class for instances of Slice classes.
- * \headerfile Ice/Ice.h
- */
-class ICE_API Value
-{
-public:
-
-    // See "Rule of zero" at http://en.cppreference.com/w/cpp/language/rule_of_three
-    // The virtual dtor is actually not stricly necessary since Values are always stored
-    // in std::shared_ptr
-
-    Value() = default;
-    Value(const Value&) = default;
-    Value(Value&&) = default;
-    Value& operator=(const Value&) = default;
-    Value& operator=(Value&&) = default;
-    virtual ~Value() = default;
-
-    /**
-     * The Ice run time invokes this method prior to marshaling an object's data members. This allows a subclass
-     * to override this method in order to validate its data members.
-     */
-    virtual void ice_preMarshal();
-
-    /**
-     * The Ice run time invokes this method after unmarshaling an object's data members. This allows a
-     * subclass to override this method in order to perform additional initialization.
-     */
-    virtual void ice_postUnmarshal();
-
-    /**
-     * Obtains the Slice type ID of the most-derived class supported by this object.
-     * @return The type ID.
-     */
-    virtual std::string ice_id() const;
-
-    /**
-     * Obtains the Slice type ID of this type.
-     * @return The return value is always "::Ice::Object".
-     */
-    static const std::string& ice_staticId();
-
-    /**
-     * Returns a shallow copy of the object.
-     * @return The cloned value.
-     */
-    std::shared_ptr<Value> ice_clone() const;
-
-    /**
-     * Obtains 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, nil otherwise.
-     */
-    virtual std::shared_ptr<SlicedData> ice_getSlicedData() const;
-
-    /// \cond STREAM
-    virtual void _iceWrite(Ice::OutputStream*) const;
-    virtual void _iceRead(Ice::InputStream*);
-    /// \endcond
-
-protected:
-
-    /// \cond INTERNAL
-    virtual std::shared_ptr<Value> _iceCloneImpl() const = 0;
-    /// \endcond
-
-    /// \cond STREAM
-    virtual void _iceWriteImpl(Ice::OutputStream*) const {}
-    virtual void _iceReadImpl(Ice::InputStream*) {}
-    /// \endcond
-};
-
-/// \cond INTERNAL
-template<typename T, typename Base> class ValueHelper : public Base
-{
-public:
+    /// The base class for instances of Slice-defined classes.
+    /// @headerfile Ice/Ice.h
+    class ICE_API Value
+    {
+    public:
+        /// Default constructor.
+        Value() noexcept = default;
 
-    using Base::Base;
+        // There is no copy constructor, move constructor, copy-assignment operator or move-assignment operator to
+        // prevent accidental slicing.
+        Value(Value&&) = delete;
 
-    ValueHelper() = default;
+        virtual ~Value();
 
-    std::shared_ptr<T> ice_clone() const
-    {
-        return std::static_pointer_cast<T>(_iceCloneImpl());
-    }
+        Value& operator=(const Value&) = delete;
+        Value& operator=(Value&&) = delete;
 
-    virtual std::string ice_id() const override
-    {
-        return T::ice_staticId();
-    }
+        /// 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() {}
 
-protected:
+        /// 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() {}
 
-    virtual std::shared_ptr<Value> _iceCloneImpl() const override
-    {
-        return std::make_shared<T>(static_cast<const T&>(*this));
-    }
+        /// 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(); }
 
-    virtual void _iceWriteImpl(Ice::OutputStream* os) const override
+        /// 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)
     {
-        os->startSlice(T::ice_staticId(), -1, std::is_same<Base, Ice::Value>::value ? true : false);
-        Ice::StreamWriter<T, Ice::OutputStream>::write(os, static_cast<const T&>(*this));
-        os->endSlice();
-        Base::_iceWriteImpl(os);
+        value.ice_print(os);
+        return os;
     }
 
-    virtual void _iceReadImpl(Ice::InputStream* is) override
+    /// 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)
     {
-        is->startSlice();
-        Ice::StreamReader<T, Ice::InputStream>::read(is, static_cast<T&>(*this));
-        is->endSlice();
-        Base::_iceReadImpl(is);
+        if (value)
+        {
+            os << *value;
+        }
+        else
+        {
+            os << "nullptr";
+        }
+        return os;
     }
-};
-/// \endcond
-
 }
-#endif // C++11 mapping end
 
 #endif

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

@@ -1,21 +1,16 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_VALUE_F_H
 #define ICE_VALUE_F_H
 
-#ifdef ICE_CPP11_MAPPING
-#include <Ice/Config.h>
+#include <memory>
 
 namespace Ice
 {
+    class Value;
 
-class Value;
-/// \cond INTERNAL
-using ValuePtr = ::std::shared_ptr<Value>;
-/// \endcond
-
+    /// A shared pointer to a Value.
+    using ValuePtr = std::shared_ptr<Value>;
 }
-#endif
+
 #endif