zeroc-ice 3.7.10 → 3.8.0

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

@@ -0,0 +1,219 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_SERVICE_H
+#define ICE_SERVICE_H
+
+#include "Ice.h"
+
+#ifdef _WIN32
+#    ifndef NOMINMAX
+#        define NOMINMAX
+#    endif
+#    include <windows.h>
+#    include <winsvc.h>
+#endif
+
+namespace Ice
+{
+    /// A singleton class that helps you write Windows services and Unix daemons using Ice.
+    /// @headerfile Ice/Ice.h
+    class ICE_API Service
+    {
+    public:
+        /// Default constructor.
+        Service();
+
+        virtual ~Service();
+
+        /// Shuts down the service. The default implementation calls Communicator::shutdown.
+        virtual bool shutdown();
+
+        /// Notifies the service that the program received a signal. The default implementation calls #shutdown.
+        /// @see Ice::CtrlCHandler
+        virtual void interrupt();
+
+        /// The primary entry point for services. This function examines @p argv for reserved options and takes the
+        /// appropriate action. The reserved options are shown below.
+        ///
+        /// Win32:
+        ///
+        /// --service NAME
+        ///
+        /// Unix:
+        ///
+        /// --daemon [--nochdir] [--noclose]
+        ///
+        /// If --service or --daemon are specified, the program runs as a service, otherwise the program runs as a
+        /// regular foreground process. Any service-specific (and Ice-specific) options are stripped from @p argv (just
+        /// as for ::Ice::initialize).
+        /// @param argc The number of arguments in @p argv.
+        /// @param argv The command-line arguments.
+        /// @param initData Configuration data for the new communicator.
+        /// @return The application's exit status: EXIT_FAILURE or EXIT_SUCCESS.
+        int main(int argc, const char* const argv[], InitializationData initData = {});
+
+#if defined(_WIN32) || defined(ICE_DOXYGEN)
+        /// @copydoc main(int, const char* const[], InitializationData)
+        /// @remarks Windows only.
+        int main(int argc, const wchar_t* const argv[], InitializationData initData = {});
+#endif
+
+        /// The primary entry point for services. This function examines @p args for reserved options and takes the
+        /// appropriate action. The reserved options are shown below.
+        ///
+        /// Win32:
+        ///
+        /// --service NAME
+        ///
+        /// Unix:
+        ///
+        /// --daemon [--nochdir] [--noclose]
+        ///
+        /// If --service or --daemon are specified, the program runs as a service, otherwise the program runs as a
+        /// regular foreground process. Any service-specific (and Ice-specific) options are stripped from @p args (just
+        /// as for ::Ice::initialize).
+        /// @param args The command-line arguments.
+        /// @param initData Configuration data for the new communicator.
+        /// @return The application's exit status: EXIT_FAILURE or EXIT_SUCCESS.
+        int main(const StringSeq& args, InitializationData initData = {});
+
+        /// Gets the communicator created by the service.
+        /// @return The service's communicator.
+        [[nodiscard]] Ice::CommunicatorPtr communicator() const;
+
+        /// Gets the Service singleton.
+        /// @return A pointer to this service.
+        static Service* instance();
+
+        /// Indicates whether the program is running as a Win32 service or Unix daemon.
+        /// @return `true` if the program is running as a service, `false` otherwise.
+        [[nodiscard]] bool service() const;
+
+        /// Gets the program name. If the program is running as a Win32 service, the return value is the service name.
+        /// Otherwise the return value is the executable name (i.e., argv[0]).
+        /// @return The service name.
+        [[nodiscard]] std::string name() const;
+
+        /// Handles a signal.
+        /// @remarks The default implementation calls #interrupt unless the signal is SIGHUP or CTRL_LOGOFF_EVENT and
+        /// the property `Ice.Nohup` is greater than 0 (or not set at all).
+        /// @param sig The signal that was caught.
+        virtual void handleInterrupt(int sig);
+
+#ifdef _WIN32
+        /// @private
+        static void setModuleHandle(HMODULE);
+
+        /// @private
+        void serviceMain(int, const wchar_t* const[]);
+
+        /// @private
+        void control(int);
+#endif
+
+    protected:
+        /// Prepares a service for execution, including the creation and activation of object adapters and servants.
+        /// @param argc The number of arguments in @p argv.
+        /// @param argv The command-line arguments.
+        /// @param[out] status The exit status, which is returned by #main when `start` or `stop` returns `false`.
+        /// @return `true` if startup was successful, `false` otherwise.
+        virtual bool start(int argc, char* argv[], int& status) = 0;
+
+        /// Blocks until the service shuts down. The default implementation calls Communicator::waitForShutdown.
+        virtual void waitForShutdown();
+
+        /// Cleans up resources after shutting down.
+        virtual bool stop();
+
+        /// Initializes a communicator.
+        /// @param argc The number of arguments in @p argv.
+        /// @param argv The command-line arguments.
+        /// @param initData Configuration data for the new communicator.
+        /// @return The new communicator instance.
+        virtual Ice::CommunicatorPtr initializeCommunicator(int& argc, char* argv[], InitializationData initData);
+
+        /// Logs a system error, which includes a description of the current system error code.
+        /// @param msg The log message.
+        virtual void syserror(const std::string& msg);
+
+        /// Logs an error.
+        /// @param msg The log message.
+        virtual void error(const std::string& msg);
+
+        /// Logs a warning.
+        /// @param msg The log message.
+        virtual void warning(const std::string& msg);
+
+        /// Logs trace information.
+        /// @param msg The log message.
+        virtual void trace(const std::string& msg);
+
+        /// Logs a literal message.
+        /// @param msg The log message.
+        virtual void print(const std::string& msg);
+
+        /// Makes this service call #handleInterrupt when it receives a signal.
+        void enableInterrupt();
+
+        /// Ignores signals.
+        void disableInterrupt();
+
+        /// Logger utility class for a system error.
+        using ServiceSysError = LoggerOutput<Service, Service*, &Service::syserror>;
+
+        /// Logger utility class for an error.
+        using ServiceError = LoggerOutput<Service, Service*, &Service::error>;
+
+        /// Logger utility class for a warning.
+        using ServiceWarning = LoggerOutput<Service, Service*, &Service::warning>;
+
+        /// Logger utility class for a trace message.
+        using ServiceTrace = LoggerOutput<Service, Service*, &Service::trace>;
+
+        /// Logger utility class for a literal message.
+        using ServicePrint = LoggerOutput<Service, Service*, &Service::print>;
+
+    private:
+        Ice::LoggerPtr _logger;
+        Ice::CommunicatorPtr _communicator;
+        bool _nohup = true;
+        bool _service = false;
+        std::string _name;
+
+        static Service* _instance;
+
+        int run(int argc, const char* const argv[], InitializationData initData = {});
+
+#ifdef _WIN32
+        /// Configures the program to run as a Windows service.
+        void configureService(const std::string& name);
+
+        int runService(int, const char* const[], InitializationData);
+        void terminateService(DWORD);
+        bool waitForServiceState(SC_HANDLE, DWORD, SERVICE_STATUS&);
+        void showServiceStatus(const std::string&, SERVICE_STATUS&);
+
+        SERVICE_STATUS_HANDLE _statusHandle;
+        std::vector<std::string> _serviceArgs;
+        InitializationData _initData;
+#else
+        /// Configures the program to run as a Unix daemon.
+        /// @param changeDirectory `true` if the daemon should change its working directory to the root directory,
+        /// `false` otherwise.
+        /// @param closeFiles `true` if the daemon should close unnecessary file descriptors (i.e., stdin, stdout,
+        /// etc.), `false` otherwise.
+        /// @param pidFile If a non-empty string is provided, the daemon writes its process ID to the given file.
+        /// @remarks Linux and macOS only.
+        void configureDaemon(bool changeDirectory, bool closeFiles, const std::string& pidFile);
+
+        int runDaemon(int, char*[], InitializationData);
+
+        bool _changeDirectory = true;
+        bool _closeFiles = true;
+        std::string _pidFile;
+#endif
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,67 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_SLICE_LOADER_H
+#define ICE_SLICE_LOADER_H
+
+#include "Config.h"
+#include "ValueF.h"
+
+#include <exception>
+#include <memory>
+#include <string_view>
+#include <vector>
+
+namespace Ice
+{
+    /// Creates class and exception instances from Slice type IDs.
+    /// @remark The implementation of newClassInstance and newExceptionInstance in the base class always returns
+    /// nullptr.
+    /// @headerfile Ice/Ice.h
+    class ICE_API SliceLoader
+    {
+    public:
+        virtual ~SliceLoader();
+
+        /// Creates an instance of a class mapped from a Slice class based on a Slice type ID.
+        /// @param typeId The Slice type ID or compact type ID.
+        /// @return A new instance of the class identified by @p typeId, or nullptr if the implementation cannot find
+        /// the corresponding class.
+        /// @throws MarshalException Thrown when the corresponding class was found but its instantiation failed.
+        [[nodiscard]] virtual ValuePtr newClassInstance(std::string_view typeId) const;
+
+        /// Creates an instance of a class mapped from a Slice exception based on a Slice type ID.
+        /// @param typeId The Slice type ID.
+        /// @return A new instance of the exception class identified by @p typeId, or nullptr if the implementation
+        /// cannot find the corresponding class.
+        /// @throws MarshalException Thrown when the corresponding class was found but its instantiation failed.
+        [[nodiscard]] virtual std::exception_ptr newExceptionInstance(std::string_view typeId) const;
+
+    protected:
+        SliceLoader() = default;
+    };
+
+    /// A shared pointer to a SliceLoader.
+    using SliceLoaderPtr = std::shared_ptr<SliceLoader>;
+
+    /// Implements SliceLoader by combining multiple SliceLoader instances.
+    class ICE_API CompositeSliceLoader final : public SliceLoader
+    {
+    public:
+        ~CompositeSliceLoader() final;
+
+        /// Adds a SliceLoader instance to this CompositeSliceLoader.
+        /// @param loader The SliceLoader to add.
+        void add(SliceLoaderPtr loader) noexcept;
+
+        [[nodiscard]] ValuePtr newClassInstance(std::string_view typeId) const final;
+        [[nodiscard]] std::exception_ptr newExceptionInstance(std::string_view typeId) const final;
+
+    private:
+        std::vector<SliceLoaderPtr> _loaders;
+    };
+
+    /// A shared pointer to a CompositeSliceLoaderPtr.
+    using CompositeSliceLoaderPtr = std::shared_ptr<CompositeSliceLoader>;
+}
+
+#endif

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

@@ -0,0 +1,125 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_SLICED_DATA_H
+#define ICE_SLICED_DATA_H
+
+#include "Config.h"
+#include "SlicedDataF.h"
+#include "Value.h"
+
+#include <cassert>
+#include <string>
+
+#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
+{
+    /// Encapsulates the details of a class slice with an unknown type.
+    /// @headerfile Ice/Ice.h
+    struct SliceInfo
+    {
+        /// The Slice type ID for this slice. It's empty when the compact ID is set (not `-1`).
+        const std::string typeId;
+
+        /// The Slice compact type ID for this slice, or `-1` if the slice has no compact ID.
+        const int compactId;
+
+        /// The encoded bytes for this slice, including the leading size integer.
+        const std::vector<std::byte> bytes;
+
+        /// The class instances referenced by this slice.
+        std::vector<ValuePtr> instances;
+
+        /// Whether or not the slice contains optional members.
+        const bool hasOptionalMembers;
+
+        /// Whether or not this is the last slice.
+        const bool isLastSlice;
+
+        /// Constructs a new SliceInfo instance.
+        /// @param typeId The Slice type ID for this slice.
+        /// @param compactId The Slice compact type ID for this slice.
+        /// @param bytes The encoded bytes for this slice.
+        /// @param hasOptionalMembers Whether or not the slice contains optional members.
+        /// @param isLastSlice Whether or not this is the last slice.
+        SliceInfo(
+            std::string typeId,
+            int compactId,
+            std::vector<std::byte> bytes,
+            bool hasOptionalMembers,
+            bool isLastSlice) noexcept
+            : typeId(std::move(typeId)),
+              compactId(compactId),
+              bytes(std::move(bytes)),
+              hasOptionalMembers(hasOptionalMembers),
+              isLastSlice(isLastSlice)
+        {
+            if (compactId == -1)
+            {
+                assert(!this->typeId.empty());
+            }
+            else
+            {
+                assert(this->typeId.empty());
+            }
+        }
+    };
+
+    /// Holds class slices that cannot be unmarshaled because their types are not known locally.
+    /// @headerfile Ice/Ice.h
+    class ICE_API SlicedData final
+    {
+    public:
+        /// Constructs a SlicedData instance with the given slices.
+        /// @param slices The slices of the unknown class.
+        SlicedData(SliceInfoSeq slices) noexcept;
+
+        /// The slices of the unknown class.
+        const SliceInfoSeq slices;
+
+        /// Clears the slices to break potential cyclic references.
+        void clear();
+    };
+
+    /// Represents an instance of an unknown class.
+    /// @headerfile Ice/Ice.h
+    class ICE_API UnknownSlicedValue final : public Value
+    {
+    public:
+        /// Constructs the placeholder instance.
+        /// @param unknownTypeId The Slice type ID of the unknown value.
+        UnknownSlicedValue(std::string unknownTypeId) noexcept;
+
+        /// Returns the Slice type ID associated with this instance.
+        /// @return The type ID supplied to the constructor.
+        [[nodiscard]] const char* ice_id() const noexcept final;
+
+        /// Clones this object.
+        /// @return A new instance.
+        [[nodiscard]] UnknownSlicedValuePtr ice_clone() const
+        {
+            return std::static_pointer_cast<UnknownSlicedValue>(_iceCloneImpl());
+        }
+
+        void ice_printFields(std::ostream& os) const final;
+
+    private:
+        [[nodiscard]] ValuePtr _iceCloneImpl() const final;
+
+        std::string _unknownTypeId;
+    };
+}
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+
+#endif

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

@@ -0,0 +1,30 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_SLICED_DATA_F_H
+#define ICE_SLICED_DATA_F_H
+
+#include <memory>
+#include <vector>
+
+namespace Ice
+{
+    struct SliceInfo;
+
+    /// A shared pointer to a SliceInfo.
+    using SliceInfoPtr = std::shared_ptr<SliceInfo>;
+
+    /// The slices of unknown types.
+    using SliceInfoSeq = std::vector<SliceInfoPtr>;
+
+    class SlicedData;
+
+    /// A shared pointer to a SlicedData.
+    using SlicedDataPtr = std::shared_ptr<SlicedData>;
+
+    class UnknownSlicedValue;
+
+    /// A shared pointer to an UnknownSlicedValue.
+    using UnknownSlicedValuePtr = std::shared_ptr<UnknownSlicedValue>;
+}
+
+#endif