zeroc-ice 3.6b1

data/slice/Ice/PropertiesAdmin.ice

@@ -0,0 +1,75 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+#include <Ice/BuiltinSequences.ice>
+
+module Ice
+{
+
+/**
+ *
+ * A simple collection of properties, represented as a dictionary of
+ * key/value pairs. Both key and value are strings.
+ *
+ * @see Properties#getPropertiesForPrefix
+ *
+ **/
+dictionary<string, string> PropertyDict;
+
+/**
+ *
+ * The PropertiesAdmin interface provides remote access to the properties
+ * of a communicator.
+ *
+ **/
+interface PropertiesAdmin
+{
+    /**
+     *
+     * Get a property by key. If the property is not set, an empty
+     * string is returned.
+     *
+     * @param key The property key.
+     *
+     * @return The property value.
+     *
+     **/
+    string getProperty(string key);
+
+    /**
+     *
+     * Get all properties whose keys begin with <em>prefix</em>. If
+     * <em>prefix</em> is an empty string then all properties are returned.
+     *
+     * @param prefix The prefix to search for (empty string if none).
+     * @return The matching property set.
+     *
+     **/
+    ["java:type:java.util.TreeMap<String, String>"] PropertyDict getPropertiesForPrefix(string prefix);
+
+    /**
+     *
+     * Update the communicator's properties with the given property set.
+     *
+     * @param newProperties Properties to be added, changed, or removed.
+     * If an entry in <em>newProperties</em> matches the name of an existing property,
+     * that property's value is replaced with the new value. If the new value
+     * is an empty string, the property is removed. Any existing properties
+     * that are not modified or removed by the entries in newProperties are
+     * retained with their original values.
+     *
+     **/
+    ["amd"] void setProperties(PropertyDict newProperties);
+};
+
+};

data/slice/Ice/PropertiesF.ice

@@ -0,0 +1,21 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+module Ice
+{
+
+local interface Properties;
+interface PropertiesAdmin;
+
+};
+

data/slice/Ice/RemoteLogger.ice

@@ -0,0 +1,232 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#pragma once
+
+#include <Ice/BuiltinSequences.ice>
+
+[["cpp:header-ext:h"]]
+[["cpp:include:list"]]
+
+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 {@link LoggerAdmin#attachRemoteLogger} when a
+     * RemoteLogger proxy is attached. 
+     *
+     * @param prefix The prefix of the associated local {@link Logger}
+     * 
+     * @param logMessages Old log messages generated before "now".
+     *
+     * @see LoggerAdmin#attachRemoteLogger
+     *
+     *
+     **/
+    void init(string prefix, LogMessageSeq logMessages); 
+
+    
+    /**
+     *
+     * log a {@link LogMessage}. Note that log may be called by {@link LoggerAdmin}
+     * before {@link init}.
+     * 
+     * @param message The message to log.
+     *
+     * @see Logger
+     *
+     **/
+    void log(LogMessage message);
+};
+
+
+/**
+ *
+ * An exception thrown by {@link LoggerAdmin#attachRemoteLogger} to report
+ * that the provided {@link RemoteLogger} was previously attached to this
+ * {@link 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
+{
+    /**
+     *
+     * attachRemoteLogger is called to attach a {@link RemoteLogger} object to 
+     * the local {@link Logger}. 
+     * attachRemoteLogger calls init on the provided {@link 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 {@link RemoteLogger#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;
+
+    /**
+     *
+     * detachRemoteLogger is called to detach a {@link RemoteLogger} object from
+     * the local {@link 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);
+
+    /**
+     *
+     * getLog 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 {@link Logger}.
+     *
+     * @return The Log messages.
+     *
+     **/
+    LogMessageSeq getLog(LogMessageTypeSeq messageTypes, StringSeq traceCategories, int messageMax, out string prefix);
+};
+
+};
+

data/slice/Ice/Router.ice

@@ -0,0 +1,83 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+#include <Ice/BuiltinSequences.ice>
+
+module Ice
+{
+
+/**
+ *
+ * The Ice router interface. Routers can be set either globally with
+ * {@link Communicator.setDefaultRouter}, or with <tt>ice_router</tt> 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.
+     *
+     * @return The router's client proxy.
+     *
+     **/
+    ["nonmutating", "cpp:const"] idempotent Object* getClientProxy();
+
+    /**
+     *
+     * 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 inferface 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();
+};
+
+};
+

data/slice/Ice/RouterF.ice

@@ -0,0 +1,20 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+module Ice
+{
+
+interface Router;
+
+};
+

data/slice/Ice/ServantLocator.ice

@@ -0,0 +1,117 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+#include <Ice/ObjectAdapterF.ice>
+#include <Ice/Current.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.
+     *
+     * {@link #locate} 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 {@link #locate} throws any exception, the Ice run time does <em>not</em>
+     * call {@link finished}.
+     *
+     * <p class="Note">If you call {@link #locate} from your own code, you
+     * must also call {@link #finished} when you have finished using the
+     * servant, provided that {@link #locate} returned a non-null servant;
+     * otherwise, you will get undefined behavior if you use
+     * servant locators such as the {@link Freeze.Evictor}.
+     *
+     * @param curr Information about the current operation for which
+     * a servant is required.
+     *
+     * @param cookie A "cookie" that will be passed to {@link #finished}.
+     *
+     * @return The located servant, or null if no suitable servant has
+     * been found.
+     *
+     * @see ObjectAdapter
+     * @see Current
+     * @see #finished
+     *
+     **/
+    ["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 {@link #locate} was called
+     * prior to the request and returned a non-null servant. This
+     * operation can be used for cleanup purposes after a request.
+     *
+     * {@link finished} 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 {@link #finished} throw an exception, the
+     * exception thrown by {@link #finished} is marshaled back to the client.
+     *
+     * @param curr Information about the current operation call for
+     * which a servant was located by {@link #locate}.
+     *
+     * @param servant The servant that was returned by {@link #locate}.
+     *
+     * @param cookie The cookie that was returned by {@link #locate}.
+     *
+     * @see ObjectAdapter
+     * @see Current
+     * @see #locate
+     *
+     **/
+    ["UserException"] void finished(Current curr, 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
+     *
+     **/
+    void deactivate(string category);
+};
+
+};
+