zeroc-ice 3.7.9.1 → 3.8.0

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 logger instance.
+        virtual LoggerPtr cloneWithPrefix(std::string prefix) = 0;
+    };
+}
+
+#endif

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

@@ -0,0 +1,162 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_LOGGER_UTIL_H
+#define ICE_LOGGER_UTIL_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;
+
+        LoggerOutputBase& operator=(const LoggerOutputBase&) = delete;
+
+        /// Gets the collected output.
+        [[nodiscard]] std::string str() const;
+
+        /// @private
+        std::ostringstream& _stream(); // For internal use only. Don't use in your code.
+
+    private:
+        std::ostringstream _os;
+    };
+
+    /// @cond INTERNAL
+    ICE_API LoggerOutputBase& loggerInsert(LoggerOutputBase& out, const Ice::Exception& ex);
+
+    template<typename T> struct IsException
+    {
+        static char testex(Ice::Exception*) noexcept;
+        static long testex(...) noexcept;
+
+        static constexpr bool value = sizeof(testex(static_cast<T*>(nullptr))) == sizeof(char);
+    };
+
+    template<typename T, bool = false> struct LoggerOutputInserter
+    {
+        static inline LoggerOutputBase& insert(LoggerOutputBase& out, const T& val)
+        {
+            out._stream() << val;
+            return out;
+        }
+    };
+
+    // Partial specialization
+    template<typename T> struct LoggerOutputInserter<T, true>
+    {
+        static inline LoggerOutputBase& insert(LoggerOutputBase& out, const T& ex) { return loggerInsert(out, ex); }
+    };
+
+    template<typename T> inline LoggerOutputBase& operator<<(LoggerOutputBase& out, const T& val)
+    {
+        return LoggerOutputInserter<T, IsException<T>::value>::insert(out, val);
+    }
+
+    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)
+    {
+        return os << (p ? p->ice_toString() : "");
+    }
+
+    inline LoggerOutputBase& operator<<(LoggerOutputBase& os, const ObjectPrx& p) { return os << 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:
+        /// 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)) {}
+
+        ~LoggerOutput() { flush(); }
+
+        /// 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("");
+        }
+
+    private:
+        LPtr _logger;
+    };
+
+    /// Flushes output to Logger::print.
+    using Print = LoggerOutput<Logger, LoggerPtr, &Logger::print>;
+
+    /// Flushes output to Logger::warning.
+    using Warning = LoggerOutput<Logger, LoggerPtr, &Logger::warning>;
+
+    /// 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

@@ -0,0 +1,54 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_NATIVE_PROPERTIES_ADMIN_H
+#define ICE_NATIVE_PROPERTIES_ADMIN_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);
+
+        ~NativePropertiesAdmin() final;
+
+        std::string getProperty(std::string key, const Current& current) final;
+
+        PropertyDict getPropertiesForPrefix(std::string prefix, const Current& current) final;
+
+        void setProperties(PropertyDict newProperties, const Current& current) final;
+
+        /// 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);
+
+    private:
+        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

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

@@ -0,0 +1,168 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_OBJECT_H
+#define ICE_OBJECT_H
+
+#include "IncomingRequest.h"
+#include "ObjectF.h"
+#include "OutgoingResponse.h"
+
+#include <functional>
+#include <string_view>
+
+namespace Ice
+{
+    /// The base class for servants.
+    /// @remark Object is a stateless polymorphic base class. Its copy constructor, move constructor, copy assignment
+    /// operator and move assignment operator are all deleted to prevent accidental slicing. Derived classes can
+    /// define these constructors and assignment operators to reenable copying, moving and slicing.
+    /// @headerfile Ice/Ice.h
+    class ICE_API Object
+    {
+    public:
+        /// Default constructor.
+        Object() noexcept = default;
+
+        virtual ~Object() = default;
+
+        Object(const Object&) = delete;
+        Object& operator=(const Object&) = delete;
+        Object(Object&&) = delete;
+        Object& operator=(Object&&) = delete;
+
+        /// Dispatches an incoming request and returns the corresponding outgoing response.
+        /// @param request The incoming request.
+        /// @param sendResponse A callback that the implementation calls to return the response. @p sendResponse does
+        /// not throw any exception and any @p sendResponse wrapper must not throw any exception. @p sendResponse can be
+        /// called by the thread that called dispatch (the "dispatch thread") or by another thread. The implementation
+        /// must call @p sendResponse exactly once or throw an exception.
+        /// @remark Calling @p sendResponse can be thought as returning the outgoing response. Just like when you return
+        /// a value from a remote operation, you can only return it once and you don't know if the client receives this
+        /// value. In practice, the Ice-provided @p sendResponse attempts to send the response to the client
+        /// synchronously, but may send it asynchronously. It can also silently fail to send the response back to the
+        /// client. This function is the main building block for the Ice dispatch pipeline. The implementation provided
+        /// by the base class (Object) dispatches incoming requests to the four `Object` operations (`ice_isA`,
+        /// `ice_ping`, `ice_ids` and `ice_id`), and throws OperationNotExistException for all other operations. This
+        /// base implementation is trivial and should be overridden and fully replaced by all derived classes.
+        virtual void dispatch(IncomingRequest& request, std::function<void(OutgoingResponse)> sendResponse);
+
+        /// Tests whether this object supports a specific Slice interface.
+        /// @param typeId The type ID of the Slice interface to test against.
+        /// @param current The Current object of the incoming request.
+        /// @return `true` if this object implements the Slice interface specified by @p typeId or implements a derived
+        /// interface, `false` otherwise.
+        [[nodiscard]] virtual bool ice_isA(std::string typeId, const Current& current) const;
+
+        /// @private
+        void _iceD_ice_isA(IncomingRequest&, std::function<void(OutgoingResponse)>);
+
+        /// Tests whether this object can be reached.
+        /// @param current The Current object of the incoming request.
+        virtual void ice_ping(const Current& current) const;
+
+        /// @private
+        void _iceD_ice_ping(IncomingRequest&, std::function<void(OutgoingResponse)>);
+
+        /// Gets the Slice interfaces supported by this object as a list of Slice type IDs.
+        /// @param current The Current object of the incoming request.
+        /// @return The Slice type IDs of the interfaces supported by this object, in alphabetical order.
+        [[nodiscard]] virtual std::vector<std::string> ice_ids(const Current& current) const;
+
+        /// @private
+        void _iceD_ice_ids(IncomingRequest&, std::function<void(OutgoingResponse)>);
+
+        /// Gets the type ID of the most-derived Slice interface supported by this object.
+        /// @param current The Current object of the incoming request.
+        /// @return The Slice type ID of the most-derived interface.
+        [[nodiscard]] virtual std::string ice_id(const Current& current) const;
+
+        /// @private
+        void _iceD_ice_id(IncomingRequest&, std::function<void(OutgoingResponse)>);
+
+        /// Gets the type ID of the associated Slice interface.
+        /// @return The string `"::Ice::Object"`.
+        static const char* ice_staticId() noexcept;
+    };
+
+    /// Base class for dynamic dispatch servants.
+    /// @remark This class is provided for backward compatibility. You should consider deriving directly from Object
+    /// and overriding the Object::dispatch function.
+    /// @headerfile Ice/Ice.h
+    class ICE_API Blobject : public Object
+    {
+    public:
+        /// Dispatches an incoming request.
+        /// @param inEncaps An encapsulation containing the encoded in-parameters for the operation.
+        /// @param outEncaps An encapsulation containing the encoded result for the operation.
+        /// @param current The Current object of the incoming request.
+        /// @return `true` if the dispatch completes successfully, `false` if the dispatch completes with a user
+        /// exception encoded in @p outEncaps.
+        virtual bool
+        ice_invoke(std::vector<std::byte> inEncaps, std::vector<std::byte>& outEncaps, const Current& current) = 0;
+
+        /// @private
+        void dispatch(IncomingRequest& request, std::function<void(OutgoingResponse)> sendResponse) final;
+    };
+
+    /// Base class for dynamic dispatch servants that uses the array mapping.
+    /// @remark This class is provided for backward compatibility. You should consider deriving directly from Object
+    /// and overriding the Object::dispatch function.
+    /// @headerfile Ice/Ice.h
+    class ICE_API BlobjectArray : public Object
+    {
+    public:
+        /// @copydoc Blobject::ice_invoke
+        virtual bool ice_invoke(
+            std::pair<const std::byte*, const std::byte*> inEncaps,
+            std::vector<std::byte>& outEncaps,
+            const Current& current) = 0;
+
+        /// @private
+        void dispatch(IncomingRequest&, std::function<void(OutgoingResponse)>) final;
+    };
+
+    /// Base class for asynchronous dynamic dispatch servants.
+    /// @remark This class is provided for backward compatibility. You should consider deriving directly from Object
+    /// and overriding the Object::dispatch function.
+    /// @headerfile Ice/Ice.h
+    class ICE_API BlobjectAsync : public Object
+    {
+    public:
+        /// Dispatches an incoming request asynchronously.
+        /// @param inEncaps An encapsulation containing the encoded in-parameters for the operation.
+        /// @param response The response callback. It accepts:
+        /// - `returnValue` `true` if the operation completed successfully, `false` if it completed with a user
+        ///   exception encoded in @p outEncaps.
+        /// - `outEncaps` An encapsulation containing the encoded result.
+        /// @param exception The exception callback.
+        /// @param current The Current object of the incoming request.
+        virtual void ice_invokeAsync(
+            std::vector<std::byte> inEncaps,
+            std::function<void(bool, const std::vector<std::byte>&)> response,
+            std::function<void(std::exception_ptr)> exception,
+            const Current& current) = 0;
+
+        /// @private
+        void dispatch(IncomingRequest&, std::function<void(OutgoingResponse)>) final;
+    };
+
+    /// Base class for asynchronous dynamic dispatch servants that uses the array mapping.
+    /// @remark This class is provided for backward compatibility. You should consider deriving directly from Object
+    /// and overriding the Object::dispatch function.
+    /// @headerfile Ice/Ice.h
+    class ICE_API BlobjectArrayAsync : public Object
+    {
+    public:
+        /// @copydoc BlobjectAsync::ice_invokeAsync
+        virtual void ice_invokeAsync(
+            std::pair<const std::byte*, const std::byte*> inEncaps,
+            std::function<void(bool, std::pair<const std::byte*, const std::byte*>)> response,
+            std::function<void(std::exception_ptr)> exception,
+            const Current& current) = 0;
+
+        /// @private
+        void dispatch(IncomingRequest&, std::function<void(OutgoingResponse)>) final;
+    };
+}
+
+#endif