zeroc-ice 3.7.11__cp314-cp314-win_amd64.whl

slice/Ice/PropertiesF.ice

@@ -0,0 +1,32 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["ice-prefix"]]
+
+[["js:module:ice"]]
+[["js:cjs-module"]]
+
+[["objc:dll-export:ICE_API"]]
+[["objc:header-dir:objc"]]
+
+[["python:pkgdir:Ice"]]
+
+#ifndef __SLICE2JAVA_COMPAT__
+[["java:package:com.zeroc"]]
+#endif
+
+["objc:prefix:ICE"]
+module Ice
+{
+
+local interface Properties;
+interface PropertiesAdmin;
+
+}

slice/Ice/RemoteLogger.ice

@@ -0,0 +1,226 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#pragma once
+
+#include <Ice/BuiltinSequences.ice>
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+[["cpp:include:list"]]
+
+[["ice-prefix"]]
+
+[["js:module:ice"]]
+[["js:cjs-module"]]
+
+[["objc:dll-export:ICE_API"]]
+[["objc:header-dir:objc"]]
+
+[["python:pkgdir:Ice"]]
+
+#ifndef __SLICE2JAVA_COMPAT__
+[["java:package:com.zeroc"]]
+#endif
+
+["objc:prefix:ICE"]
+module Ice
+{
+
+/**
+ *
+ * An enumeration representing the different types of log messages.
+ *
+ **/
+enum LogMessageType
+{
+    /**
+     *
+     * The {@link Logger} received a print message.
+     *
+     **/
+    PrintMessage,
+
+    /**
+     *
+     * The {@link Logger} received a trace message.
+     *
+     **/
+    TraceMessage,
+
+    /**
+     *
+     * The {@link Logger} received a warning message.
+     *
+     **/
+    WarningMessage,
+
+    /**
+     *
+     * The {@link Logger} received an error message.
+     *
+     **/
+    ErrorMessage
+}
+
+/**
+ *
+ * A sequence of {@link LogMessageType}
+ *
+ **/
+sequence<LogMessageType> LogMessageTypeSeq;
+
+/**
+ *
+ * A complete log message.
+ *
+ **/
+struct LogMessage
+{
+    /**
+     *
+     * The type of message sent to the {@link Logger}.
+     *
+     **/
+    LogMessageType type;
+
+    /**
+     *
+     * The date and time when the {@link Logger} received this message, expressed
+     * as the number of microseconds since the Unix Epoch (00:00:00 UTC on 1 January 1970)
+     *
+     **/
+    long timestamp;
+
+    /**
+     *
+     * For a message of type trace, the trace category of this log message;
+     * otherwise, the empty string.
+     *
+     **/
+    string traceCategory;
+
+     /**
+     *
+     * The log message itself.
+     *
+     **/
+    string message;
+}
+
+/**
+ *
+ * A sequence of {@link LogMessage}.
+ *
+ **/
+["cpp:type:std::list<LogMessage>"]
+sequence<LogMessage> LogMessageSeq;
+
+/**
+ *
+ * The Ice remote logger interface. An application can implement a
+ * RemoteLogger to receive the log messages sent to the local {@link Logger}
+ * of another Ice application.
+ *
+ **/
+interface RemoteLogger
+{
+    /**
+     *
+     * init is called by attachRemoteLogger when a RemoteLogger proxy is attached.
+     *
+     * @param prefix The prefix of the associated local Logger.
+     *
+     * @param logMessages Old log messages generated before "now".
+     *
+     **/
+    void init(string prefix, LogMessageSeq logMessages);
+
+    /**
+     *
+     * Log a LogMessage. Note that log may be called by LoggerAdmin before init.
+     *
+     * @param message The message to log.
+     *
+     **/
+    void log(LogMessage message);
+}
+
+/**
+ *
+ * Thrown when the provided RemoteLogger was previously attached to a LoggerAdmin.
+ *
+ **/
+exception RemoteLoggerAlreadyAttachedException
+{
+}
+
+/**
+ *
+ * The interface of the admin object that allows an Ice application the attach its
+ * {@link RemoteLogger} to the {@link Logger} of this admin object's Ice communicator.
+ *
+ **/
+interface LoggerAdmin
+{
+    /**
+     *
+     * Attaches a RemoteLogger object to the local logger.
+     * attachRemoteLogger calls init on the provided RemoteLogger proxy.
+     *
+     * @param prx A proxy to the remote logger.
+     *
+     * @param messageTypes The list of message types that the remote logger wishes to receive.
+     * An empty list means no filtering (send all message types).
+     *
+     * @param traceCategories The categories of traces that the remote logger wishes to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     *
+     * @param messageMax The maximum number of log messages (of all types) to be provided
+     * to init. A negative value requests all messages available.
+     *
+     * @throws RemoteLoggerAlreadyAttachedException Raised if this remote logger is already
+     * attached to this admin object.
+     *
+     **/
+    void attachRemoteLogger(RemoteLogger* prx, LogMessageTypeSeq messageTypes, StringSeq traceCategories,
+                            int messageMax)
+        throws RemoteLoggerAlreadyAttachedException;
+
+    /**
+     *
+     * Detaches a RemoteLogger object from the local logger.
+     *
+     * @param prx A proxy to the remote logger.
+     *
+     * @return True if the provided remote logger proxy was detached, and false otherwise.
+     *
+     **/
+    bool detachRemoteLogger(RemoteLogger* prx);
+
+    /**
+     *
+     * Retrieves log messages recently logged.
+     *
+     * @param messageTypes The list of message types that the caller wishes to receive.
+     * An empty list means no filtering (send all message types).
+     *
+     * @param traceCategories The categories of traces that caller wish to receive.
+     * This parameter is ignored if messageTypes is not empty and does not include trace.
+     * An empty list means no filtering (send all trace categories).
+     *
+     * @param messageMax The maximum number of log messages (of all types) to be returned.
+     * A negative value requests all messages available.
+     *
+     * @param prefix The prefix of the associated local logger.
+     *
+     * @return The Log messages.
+     *
+     **/
+    LogMessageSeq getLog(LogMessageTypeSeq messageTypes, StringSeq traceCategories, int messageMax, out string prefix);
+}
+
+}

slice/Ice/Router.ice

@@ -0,0 +1,103 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["ice-prefix"]]
+
+[["js:module:ice"]]
+[["js:cjs-module"]]
+
+[["objc:dll-export:ICE_API"]]
+[["objc:header-dir:objc"]]
+
+[["python:pkgdir:Ice"]]
+
+#include <Ice/BuiltinSequences.ice>
+
+#ifndef __SLICE2JAVA_COMPAT__
+[["java:package:com.zeroc"]]
+#endif
+
+["objc:prefix:ICE"]
+module Ice
+{
+
+/**
+ *
+ * The Ice router interface. Routers can be set either globally with
+ * {@link Communicator#setDefaultRouter}, or with <code>ice_router</code> on specific
+ * proxies.
+ *
+ **/
+interface Router
+{
+    /**
+     *
+     * Get the router's client proxy, i.e., the proxy to use for
+     * forwarding requests from the client to the router.
+     *
+     * If a null proxy is returned, the client will forward requests
+     * to the router's endpoints.
+     *
+     * @param hasRoutingTable Indicates whether or not the router supports a routing
+     * table. If it is supported, the Ice runtime will call addProxies to populate the
+     * routing table. This out parameter is only supported starting with Ice 3.7.
+     * The Ice runtime assumes the router has a routing table if the optional is not
+     * set.
+     *
+     * @return The router's client proxy.
+     *
+     **/
+    ["nonmutating", "cpp:const"] idempotent Object* getClientProxy(out optional(1) bool hasRoutingTable);
+
+    /**
+     *
+     * Get the router's server proxy, i.e., the proxy to use for
+     * forwarding requests from the server to the router.
+     *
+     * @return The router's server proxy.
+     *
+     **/
+    ["nonmutating", "cpp:const"] idempotent Object* getServerProxy();
+
+    /**
+     *
+     * Add new proxy information to the router's routing table.
+     *
+     * @param proxies The proxies to add.
+     *
+     * @return Proxies discarded by the router.
+     *
+     **/
+    idempotent ObjectProxySeq addProxies(ObjectProxySeq proxies);
+}
+
+/**
+ *
+ * This interface should be implemented by services implementing the
+ * Ice::Router interface. It should be advertised through an Ice
+ * object with the identity `Ice/RouterFinder'. This allows clients to
+ * retrieve the router proxy with just the endpoint information of the
+ * service.
+ *
+ **/
+interface RouterFinder
+{
+    /**
+     *
+     * Get the router proxy implemented by the process hosting this
+     * finder object. The proxy might point to several replicas.
+     *
+     * @return The router proxy.
+     *
+     **/
+    Router* getRouter();
+}
+
+}

slice/Ice/RouterF.ice

@@ -0,0 +1,31 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["ice-prefix"]]
+
+[["js:module:ice"]]
+[["js:cjs-module"]]
+
+[["objc:dll-export:ICE_API"]]
+[["objc:header-dir:objc"]]
+
+[["python:pkgdir:Ice"]]
+
+#ifndef __SLICE2JAVA_COMPAT__
+[["java:package:com.zeroc"]]
+#endif
+
+["objc:prefix:ICE"]
+module Ice
+{
+
+interface Router;
+
+}

slice/Ice/ServantLocator.ice

@@ -0,0 +1,136 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["ice-prefix"]]
+
+[["js:module:ice"]]
+[["js:cjs-module"]]
+
+[["objc:dll-export:ICE_API"]]
+[["objc:header-dir:objc"]]
+
+[["python:pkgdir:Ice"]]
+
+#include <Ice/ObjectAdapterF.ice>
+#include <Ice/Current.ice>
+
+#ifndef __SLICE2JAVA_COMPAT__
+[["java:package:com.zeroc"]]
+#endif
+
+["objc:prefix:ICE"]
+module Ice
+{
+
+/**
+ *
+ * A servant locator is called by an object adapter to
+ * locate a servant that is not found in its active servant map.
+ *
+ * @see ObjectAdapter
+ * @see ObjectAdapter#addServantLocator
+ * @see ObjectAdapter#findServantLocator
+ *
+ **/
+local interface ServantLocator
+{
+    /**
+     *
+     * Called before a request is dispatched if a
+     * servant cannot be found in the object adapter's active servant
+     * map. Note that the object adapter does not automatically insert
+     * the returned servant into its active servant map. This must be
+     * done by the servant locator implementation, if this is desired.
+     *
+     * <code>locate</code> can throw any user exception. If it does, that exception
+     * is marshaled back to the client. If the Slice definition for the
+     * corresponding operation includes that user exception, the client
+     * receives that user exception; otherwise, the client receives
+     * {@link UnknownUserException}.
+     *
+     * If <code>locate</code> throws any exception, the Ice run time does <em>not</em>
+     * call <code>finished</code>.
+     *
+     * <p class="Note">If you call <code>locate</code> from your own code, you
+     * must also call <code>finished</code> when you have finished using the
+     * servant, provided that <code>locate</code> returned a non-null servant;
+     * otherwise, you will get undefined behavior if you use
+     * servant locators such as the Freeze Evictor.
+     *
+     * @param curr Information about the current operation for which
+     * a servant is required.
+     *
+     * @param cookie A "cookie" that will be passed to <code>finished</code>.
+     *
+     * @return The located servant, or null if no suitable servant has
+     * been found.
+     *
+     * @throws UserException The implementation can raise a UserException
+     * and the run time will marshal it as the result of the invocation.
+     *
+     * @see ObjectAdapter
+     * @see Current
+     * @see #finished
+     *
+     **/
+    ["java:UserException"] Object locate(Current curr, out LocalObject cookie);
+
+    /**
+     *
+     * Called by the object adapter after a request has been
+     * made. This operation is only called if <code>locate</code> was called
+     * prior to the request and returned a non-null servant. This
+     * operation can be used for cleanup purposes after a request.
+     *
+     * <code>finished</code> can throw any user exception. If it does, that exception
+     * is marshaled back to the client. If the Slice definition for the
+     * corresponding operation includes that user exception, the client
+     * receives that user exception; otherwise, the client receives
+     * {@link UnknownUserException}.
+     *
+     * If both the operation and <code>finished</code> throw an exception, the
+     * exception thrown by <code>finished</code> is marshaled back to the client.
+     *
+     * @param curr Information about the current operation call for
+     * which a servant was located by <code>locate</code>.
+     *
+     * @param servant The servant that was returned by <code>locate</code>.
+     *
+     * @param cookie The cookie that was returned by <code>locate</code>.
+     *
+     * @throws UserException The implementation can raise a UserException
+     * and the run time will marshal it as the result of the invocation.
+     *
+     * @see ObjectAdapter
+     * @see Current
+     * @see #locate
+     *
+     **/
+    ["java:UserException"] void finished(Current curr,
+                                         ["swift:nonnull"] Object servant,
+                                         LocalObject cookie);
+
+    /**
+     *
+     * Called when the object adapter in which this servant locator is
+     * installed is destroyed.
+     *
+     * @param category Indicates for which category the servant locator
+     * is being deactivated.
+     *
+     * @see ObjectAdapter#destroy
+     * @see Communicator#shutdown
+     * @see Communicator#destroy
+     *
+     **/
+    ["swift:noexcept"] void deactivate(string category);
+}
+
+}

slice/Ice/ServantLocatorF.ice

@@ -0,0 +1,31 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["ice-prefix"]]
+
+[["js:module:ice"]]
+[["js:cjs-module"]]
+
+[["objc:dll-export:ICE_API"]]
+[["objc:header-dir:objc"]]
+
+[["python:pkgdir:Ice"]]
+
+#ifndef __SLICE2JAVA_COMPAT__
+[["java:package:com.zeroc"]]
+#endif
+
+["objc:prefix:ICE"]
+module Ice
+{
+
+local interface ServantLocator;
+
+}

slice/Ice/SliceChecksumDict.ice

@@ -0,0 +1,36 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#pragma once
+
+[["cpp:dll-export:ICE_API"]]
+[["cpp:doxygen:include:Ice/Ice.h"]]
+[["cpp:header-ext:h"]]
+
+[["ice-prefix"]]
+
+[["js:module:ice"]]
+[["js:cjs-module"]]
+
+[["objc:dll-export:ICE_API"]]
+[["objc:header-dir:objc"]]
+
+[["python:pkgdir:Ice"]]
+
+#ifndef __SLICE2JAVA_COMPAT__
+[["java:package:com.zeroc"]]
+#endif
+
+["objc:prefix:ICE"]
+module Ice
+{
+
+/**
+ * A mapping from type IDs to Slice checksums. The dictionary
+ * allows verification at run time that client and server
+ * use matching Slice definitions.
+ **/
+dictionary<string, string> SliceChecksumDict;
+
+}