zeroc-ice 3.7.11 → 3.8.1

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

@@ -0,0 +1,62 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_LOGGER_H
+#define ICE_LOGGER_H
+
+#include "Config.h"
+
+#include <memory>
+#include <string>
+
+namespace Ice
+{
+    class Logger;
+
+    /// A shared pointer to a Logger.
+    using LoggerPtr = std::shared_ptr<Logger>;
+
+    /// Represents Ice's abstraction for logging and tracing. Applications can provide their own logger by
+    /// implementing this abstraction and setting a logger on the communicator.
+    /// @see InitializationData
+    /// @headerfile Ice/Ice.h
+    class ICE_API Logger
+    {
+    public:
+        virtual ~Logger();
+
+        // We use const std::string& and not std::string_view for the log messages because implementations commonly
+        // send the message to C APIs that require null-terminated strings.
+        // The message itself is also often constructed from a string produced by an ostringstream.
+
+        /// Prints a message.
+        /// The message is printed literally, without any decorations such as executable name or timestamp.
+        /// @param message The message to log.
+        virtual void print(const std::string& message) = 0;
+
+        /// Logs a trace message.
+        /// @param category The trace category.
+        /// @param message The trace message to log.
+        virtual void trace(const std::string& category, const std::string& message) = 0;
+
+        /// Logs a warning message.
+        /// @param message The warning message to log.
+        /// @see #error
+        virtual void warning(const std::string& message) = 0;
+
+        /// Logs an error message.
+        /// @param message The error message to log.
+        /// @see #warning
+        virtual void error(const std::string& message) = 0;
+
+        /// Returns this logger's prefix.
+        /// @return The prefix.
+        virtual std::string getPrefix() = 0;
+
+        /// Returns a clone of the logger with a new prefix.
+        /// @param prefix The new prefix for the logger.
+        /// @return A new logger instance with the specified prefix.
+        virtual LoggerPtr cloneWithPrefix(std::string prefix) = 0;
+    };
+}
+
+#endif

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

@@ -1,185 +1,162 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_LOGGER_UTIL_H
 #define ICE_LOGGER_UTIL_H
 
-#include <Ice/Logger.h>
-#include <Ice/CommunicatorF.h>
-#include <Ice/Plugin.h>
-#include <Ice/Exception.h>
+#include "CommunicatorF.h"
+#include "Config.h"
+#include "Exception.h"
+#include "Logger.h"
+#include "Plugin.h"
+#include "Proxy.h"
+
+#include <sstream>
+#include <utility>
 
 namespace Ice
 {
+    /// Base class for logger output utility classes.
+    /// @headerfile Ice/Ice.h
+    class ICE_API LoggerOutputBase
+    {
+    public:
+        LoggerOutputBase() = default;
+        LoggerOutputBase(const LoggerOutputBase&) = delete;
 
-/**
- * Base class for logger output utility classes.
- * \headerfile Ice/Ice.h
- */
-class ICE_API LoggerOutputBase : private IceUtil::noncopyable
-{
-public:
+        LoggerOutputBase& operator=(const LoggerOutputBase&) = delete;
 
-    /** Obtains the collected output. */
-    std::string str() const;
+        /// Gets the collected output.
+        [[nodiscard]] std::string str() const;
 
-    /// \cond INTERNAL
-    std::ostringstream& _stream(); // For internal use only. Don't use in your code.
-    /// \endcond
+        /// @private
+        std::ostringstream& _stream(); // For internal use only. Don't use in your code.
 
-private:
+    private:
+        std::ostringstream _os;
+    };
 
-    std::ostringstream _os;
-};
+    /// @cond INTERNAL
+    ICE_API LoggerOutputBase& loggerInsert(LoggerOutputBase& out, const Ice::Exception& ex);
 
-/// \cond INTERNAL
-ICE_API LoggerOutputBase& loggerInsert(LoggerOutputBase& out, const IceUtil::Exception& ex);
+    template<typename T> struct IsException
+    {
+        static char testex(Ice::Exception*) noexcept;
+        static long testex(...) noexcept;
 
-template<typename T>
-struct IsException
-{
-    static char testex(IceUtil::Exception*);
-    static long testex(...);
+        static constexpr bool value = sizeof(testex(static_cast<T*>(nullptr))) == sizeof(char);
+    };
 
-    static const bool value = sizeof(testex(static_cast<T*>(0))) == sizeof(char);
-};
+    template<typename T, bool = false> struct LoggerOutputInserter
+    {
+        static inline LoggerOutputBase& insert(LoggerOutputBase& out, const T& val)
+        {
+            out._stream() << val;
+            return out;
+        }
+    };
 
-template<typename T, bool = false>
-struct LoggerOutputInserter
-{
-    static inline LoggerOutputBase&
-    insert(LoggerOutputBase& out, const T& val)
+    // Partial specialization
+    template<typename T> struct LoggerOutputInserter<T, true>
     {
-        out._stream() << val;
-        return out;
-    }
-};
+        static inline LoggerOutputBase& insert(LoggerOutputBase& out, const T& ex) { return loggerInsert(out, ex); }
+    };
 
-// Partial specialization
-template<typename T>
-struct LoggerOutputInserter<T, true>
-{
-    static inline LoggerOutputBase&
-    insert(LoggerOutputBase& out, const T& ex)
+    template<typename T> inline LoggerOutputBase& operator<<(LoggerOutputBase& out, const T& val)
     {
-        return loggerInsert(out, ex);
+        return LoggerOutputInserter<T, IsException<T>::value>::insert(out, val);
     }
-};
-
-template<typename T>
-inline LoggerOutputBase&
-operator<<(LoggerOutputBase& out, const T& val)
-{
-    return LoggerOutputInserter<T, IsException<T>::value>::insert(out, val);
-}
-
-#ifdef ICE_CPP11_MAPPING
-template<typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type* = nullptr>
-inline LoggerOutputBase&
-operator<<(LoggerOutputBase& os, const ::std::shared_ptr<T>& p)
-#else
-template<typename T>
-inline LoggerOutputBase&
-operator<<(LoggerOutputBase& os, const ::IceInternal::ProxyHandle<T>& p)
-#endif
-{
-    return os << (p ? p->ice_toString() : "");
-}
 
-inline LoggerOutputBase&
-operator<<(LoggerOutputBase& out, const ::std::exception& ex)
-{
-    out._stream() << ex.what();
-    return out;
-}
-
-ICE_API LoggerOutputBase& operator<<(LoggerOutputBase&, std::ios_base& (*)(std::ios_base&));
-/// \endcond
-
-/**
- * Collects output and flushes it via a logger method.
- * \headerfile Ice/Ice.h
- */
-template<class L, class LPtr, void (L::*output)(const std::string&)>
-class LoggerOutput : public LoggerOutputBase
-{
-public:
-    inline LoggerOutput(const LPtr& lptr) :
-        _logger(lptr)
-    {}
-
-    inline ~LoggerOutput()
+    template<typename Prx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
+    inline LoggerOutputBase& operator<<(LoggerOutputBase& os, const std::optional<Prx>& p)
     {
-        flush();
+        return os << (p ? p->ice_toString() : "");
     }
 
-    /** Flushes the colleted output to the logger method. */
-    inline void flush()
+    inline LoggerOutputBase& operator<<(LoggerOutputBase& os, const ObjectPrx& p) { return os << p.ice_toString(); }
+
+    inline LoggerOutputBase& operator<<(LoggerOutputBase& out, const std::exception& ex)
     {
-        std::string s = _stream().str();
-        if(!s.empty())
-        {
-            L& ref = *_logger;
-            (ref.*output)(s);
-        }
-        _stream().str("");
+        out._stream() << ex.what();
+        return out;
     }
 
-private:
+    ICE_API LoggerOutputBase& operator<<(LoggerOutputBase&, std::ios_base& (*)(std::ios_base&));
+    /// @endcond
 
-    LPtr _logger;
-};
+    /// Collects output and flushes it via a logger method.
+    /// @headerfile Ice/Ice.h
+    template<class L, class LPtr, void (L::*output)(const std::string&)> class LoggerOutput : public LoggerOutputBase
+    {
+    public:
+        /// Constructs a LoggerOutput object with the given logger.
+        /// @param logger The logger or logger-like object to log to.
+        LoggerOutput(LPtr logger) : _logger(std::move(logger)) {}
 
-/** Flushes output to Logger::print. */
-typedef LoggerOutput<Logger, LoggerPtr, &Logger::print> Print;
+        ~LoggerOutput() { flush(); }
 
-/** Flushes output to Logger::warning. */
-typedef LoggerOutput<Logger, LoggerPtr, &Logger::warning> Warning;
+        /// Flushes the colleted output to the logger method.
+        void flush()
+        {
+            std::string s = _stream().str();
+            if (!s.empty())
+            {
+                L& ref = *_logger;
+                (ref.*output)(s);
+            }
+            _stream().str("");
+        }
 
-/** Flushes output to Logger::error. */
-typedef LoggerOutput<Logger, LoggerPtr, &Logger::error> Error;
+    private:
+        LPtr _logger;
+    };
 
-/**
- * Flushes output to Logger::trace.
- * \headerfile Ice/Ice.h
- */
-class ICE_API Trace : public LoggerOutputBase
-{
-public:
-    Trace(const LoggerPtr&, const std::string&);
-    ~Trace();
-    void flush();
-
-private:
-
-    LoggerPtr _logger;
-    std::string _category;
-};
-
-/**
- * A special plug-in that installs a logger during a communicator's initialization.
- * Both initialize and destroy are no-op. See Ice::InitializationData.
- * \headerfile Ice/Ice.h
- */
-class ICE_API LoggerPlugin : public Ice::Plugin
-{
-public:
-
-    /**
-     * Constructs the plug-in with a target communicator and a logger.
-     * @param communicator The communicator in which to install the logger.
-     * @param logger The logger to be installed.
-     */
-    LoggerPlugin(const CommunicatorPtr& communicator, const LoggerPtr& logger);
+    /// Flushes output to Logger::print.
+    using Print = LoggerOutput<Logger, LoggerPtr, &Logger::print>;
 
-    /** This method is a no-op. */
-    virtual void initialize();
+    /// Flushes output to Logger::warning.
+    using Warning = LoggerOutput<Logger, LoggerPtr, &Logger::warning>;
 
-    /** This method is a no-op. */
-    virtual void destroy();
-};
+    /// Flushes output to Logger::error.
+    using Error = LoggerOutput<Logger, LoggerPtr, &Logger::error>;
 
+    /// Flushes output to Logger::trace.
+    /// @headerfile Ice/Ice.h
+    class ICE_API Trace : public LoggerOutputBase
+    {
+    public:
+        /// Constructs a Trace object with the given logger and category.
+        /// @param logger The logger to log to.
+        /// @param category The trace category.
+        Trace(LoggerPtr logger, std::string category);
+
+        ~Trace();
+
+        /// Calls Logger::trace with the collected output.
+        void flush();
+
+    private:
+        LoggerPtr _logger;
+        std::string _category;
+    };
+
+    /// A special plug-in that installs a logger during a communicator's initialization.
+    /// Both initialize and destroy are no-op.
+    /// @see Ice::InitializationData
+    /// @headerfile Ice/Ice.h
+    class ICE_API LoggerPlugin : public Ice::Plugin
+    {
+    public:
+        /// Constructs the plug-in with a target communicator and a logger.
+        /// @param communicator The communicator in which to install the logger.
+        /// @param logger The logger to install.
+        LoggerPlugin(const CommunicatorPtr& communicator, const LoggerPtr& logger);
+
+        /// This method is no-op.
+        void initialize() override;
+
+        /// This method is no-op.
+        void destroy() override;
+    };
 }
 
 #endif

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

@@ -0,0 +1,50 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_MARSHALED_RESULT_H
+#define ICE_MARSHALED_RESULT_H
+
+#include "Config.h"
+#include "Current.h"
+#include "OutputStream.h"
+
+namespace Ice
+{
+    /// Base class for marshaled result structures, which are generated for operations marked with
+    /// "marshaled-result" metadata.
+    /// @headerfile Ice/Ice.h
+    class ICE_API MarshaledResult
+    {
+    public:
+        MarshaledResult() = delete;
+        MarshaledResult(const MarshaledResult&) = delete;
+
+        /// Move constructor. Constructs a MarshaledResult with the contents of @p other using move semantics.
+        /// @param other The result to move from.
+        MarshaledResult(MarshaledResult&& other) = default;
+
+        virtual ~MarshaledResult();
+
+        MarshaledResult& operator=(const MarshaledResult&) = delete;
+
+        /// Move assignment operator. Replaces the contents of this result with the contents of @p rhs using move
+        /// semantics.
+        /// @param rhs The result to move from.
+        /// @return A reference to this result.
+        MarshaledResult& operator=(MarshaledResult&& rhs) = default;
+
+        /// @cond INTERNAL
+
+        OutputStream&& outputStream() && noexcept { return std::move(_ostr); }
+
+    protected:
+        /// The constructor requires the Current object that was passed to the servant.
+        MarshaledResult(const Current& current);
+
+        /// The output stream used to marshal the results.
+        OutputStream _ostr;
+
+        /// @endcond
+    };
+}
+
+#endif

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

@@ -1,86 +1,56 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#ifndef ICE_PROPERTIES_ADMIN_H
-#define ICE_PROPERTIES_ADMIN_H
+#ifndef ICE_NATIVE_PROPERTIES_ADMIN_H
+#define ICE_NATIVE_PROPERTIES_ADMIN_H
 
-#include <Ice/PropertiesAdmin.h>
+#include "Ice/PropertiesAdmin.h"
+#include "Ice/PropertyDict.h"
+
+#include <functional>
+#include <list>
+#include <memory>
+#include <mutex>
 
 namespace Ice
 {
+    /// The default implementation of the "Properties" admin facet.
+    /// @headerfile Ice/Ice.h
+    class ICE_API NativePropertiesAdmin final : public PropertiesAdmin,
+                                                public std::enable_shared_from_this<NativePropertiesAdmin>
+    {
+    public:
+        /// Constructs a NativePropertiesAdmin.
+        /// @param properties The properties to manage.
+        /// @param logger The logger to use for logging.
+        NativePropertiesAdmin(PropertiesPtr properties, LoggerPtr logger);
 
-#ifndef ICE_CPP11_MAPPING
-/**
- * An application can be notified when its configuration properties are modified
- * via the Properties admin facet. The application must define a subclass of
- * PropertiesAdminUpdateCallback and register it with the facet. The facet
- * implements the class NativePropertiesAdmin, so the application needs to
- * downcast the facet to this type in order to register the callback.
- *
- * For example:
- *
- * \code
- * Ice::ObjectPtr obj = communicator->findAdminFacet("Properties");
- * assert(obj); // May be null if the facet is not enabled
- * NativePropertiesAdminPtr facet = NativePropertiesAdminPtr::dynamicCast(obj);
- * PropertiesAdminUpdateCallbackPtr myCallback = ...;
- * facet->addUpdateCallback(myCallback);
- * \endcode
- *
- * Ice ignores any exceptions raised by the callback.
- * \headerfile Ice/Ice.h
- */
-class ICE_API PropertiesAdminUpdateCallback : public virtual Ice::LocalObject
-{
-public:
+        ~NativePropertiesAdmin() final;
 
-    virtual ~PropertiesAdminUpdateCallback();
+        std::string getProperty(std::string key, const Current& current) final;
 
-    /**
-     * Called when the communicator's properties have been updated.
-     * @param d A dictionary containing the properties that were added, changed or removed,
-     * with a removed property denoted by an entry whose value is an empty string.
-     */
-    virtual void updated(const PropertyDict& d) = 0;
-};
-typedef IceUtil::Handle<PropertiesAdminUpdateCallback> PropertiesAdminUpdateCallbackPtr;
-#endif
+        PropertyDict getPropertiesForPrefix(std::string prefix, const Current& current) final;
 
-/**
- * Base class for the Properties admin facet.
- * \headerfile Ice/Ice.h
- */
-class ICE_API NativePropertiesAdmin
-#ifndef ICE_CPP11_MAPPING
-    : public virtual IceUtil::Shared
-#endif
-{
-public:
+        void setProperties(PropertyDict newProperties, const Current& current) final;
 
-    virtual ~NativePropertiesAdmin();
+        /// Registers an update callback that will be invoked when a property update occurs.
+        /// @param cb The callback.
+        /// @return A function that unregisters the callback.
+        std::function<void()> addUpdateCallback(std::function<void(const PropertyDict&)> cb);
 
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Register an update callback that will be invoked when property updates occur.
-     * @param cb The callback.
-     */
-    virtual std::function<void()> addUpdateCallback(std::function<void(const PropertyDict&)> cb) = 0;
-#else
-    /**
-     * Register an update callback that will be invoked when property updates occur.
-     * @param cb The callback.
-     */
-    virtual void addUpdateCallback(const PropertiesAdminUpdateCallbackPtr& cb) = 0;
-    /**
-     * Remove an update callback.
-     * @param cb The callback to be removed.
-     */
-    virtual void removeUpdateCallback(const PropertiesAdminUpdateCallbackPtr& cb) = 0;
-#endif
-};
-ICE_DEFINE_PTR(NativePropertiesAdminPtr, NativePropertiesAdmin);
+    private:
+        /// Removes a previously registered update callback.
+        /// @param p An iterator which points to the callback to remove.
+        void removeUpdateCallback(std::list<std::function<void(const PropertyDict&)>>::iterator p);
+
+        const PropertiesPtr _properties;
+        const LoggerPtr _logger;
+        std::recursive_mutex _mutex;
+
+        std::list<std::function<void(const PropertyDict&)>> _updateCallbacks;
+    };
 
+    /// A shared pointer to a NativePropertiesAdmin.
+    using NativePropertiesAdminPtr = std::shared_ptr<NativePropertiesAdmin>;
 }
 
 #endif