zeroc-ice-x86-mingw 3.6b1

data/slice/Ice/CommunicatorF.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
+{
+
+local interface Communicator;
+
+};
+

data/slice/Ice/Connection.ice

@@ -0,0 +1,323 @@
+
+// **********************************************************************
+//
+// 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/Identity.ice>
+#include <Ice/Endpoint.ice>
+
+module Ice
+{
+
+/**
+ *
+ * Base class providing access to the connection details.
+ *
+ **/
+local class ConnectionInfo
+{
+    /**
+     *
+     * Whether or not the connection is an incoming or outgoing
+     * connection.
+     *
+     **/
+    bool incoming;
+
+    /**
+     *
+     * The name of the adapter associated with the connection.
+     *
+     **/
+    string adapterName;
+
+    /**
+     *
+     * The connection id.
+     *
+     **/
+    string connectionId;
+};
+
+local interface Connection;
+
+/**
+ *
+ * An application can implement this interface to receive notifications when
+ * a connection closes or receives a heartbeat message.
+ *
+ * @see Connection#setCallback
+ *
+ **/
+local interface ConnectionCallback
+{
+    /**
+     *
+     * This method is called by the the connection when a heartbeat is
+     * received from the peer.
+     *
+     **/
+    void heartbeat(Connection con);
+
+    /**
+     *
+     * This method is called by the the connection when the connection
+     * is closed.
+     *
+     **/
+    void closed(Connection con);
+};
+
+local enum ACMClose
+{
+    CloseOff,
+    CloseOnIdle,
+    CloseOnInvocation,
+    CloseOnInvocationAndIdle,
+    CloseOnIdleForceful
+};
+    
+local enum ACMHeartbeat
+{
+    HeartbeatOff,
+    HeartbeatOnInvocation,
+    HeartbeatOnIdle,
+    HeartbeatAlways
+};
+
+local struct ACM
+{
+    int timeout;
+    ACMClose close;
+    ACMHeartbeat heartbeat;
+};
+
+/**
+ *
+ * The user-level interface to a connection.
+ *
+ **/
+local interface Connection
+{
+    /**
+     *
+     * Close a connection, either gracefully or forcefully. If a
+     * connection is closed forcefully, it closes immediately, without
+     * sending the relevant close connection protocol messages to the
+     * peer and waiting for the peer to acknowledge these protocol
+     * messages.
+     *
+     * @param force If true, close forcefully. Otherwise the
+     * connection is closed gracefully.
+     *
+     **/
+    void close(bool force);
+
+    /**
+     *
+     * Create a special proxy that always uses this connection. This
+     * can be used for callbacks from a server to a client if the
+     * server cannot directly establish a connection to the client,
+     * for example because of firewalls. In this case, the server
+     * would create a proxy using an already established connection
+     * from the client.
+     *
+     * @param id The identity for which a proxy is to be created.
+     *
+     * @return A proxy that matches the given identity and uses this
+     * connection.
+     *
+     * @see #setAdapter
+     **/
+    ["cpp:const"] Object* createProxy(Identity id);
+
+    /**
+     *
+     * Explicitly set an object adapter that dispatches requests that
+     * are received over this connection. A client can invoke an
+     * operation on a server using a proxy, and then set an object
+     * adapter for the outgoing connection that is used by the proxy
+     * in order to receive callbacks. This is useful if the server
+     * cannot establish a connection back to the client, for example
+     * because of firewalls.
+     *
+     * @param adapter The object adapter that should be used by this
+     * connection to dispatch requests. The object adapter must be
+     * activated. When the object adapter is deactivated, it is
+     * automatically removed from the connection.
+     *
+     * @see #createProxy
+     * @see #setAdapter
+     *
+     **/
+    void setAdapter(ObjectAdapter adapter);
+
+    /**
+     *
+     * Get the object adapter that dispatches requests for this
+     * connection.
+     *
+     * @return The object adapter that dispatches requests for the
+     * connection, or null if no adapter is set.
+     *
+     * @see #setAdapter
+     *
+     **/
+    ["cpp:const"] ObjectAdapter getAdapter();
+
+    /**
+     *
+     * Get the endpoint from which the connection was created.
+     *
+     * @return The endpoint from which the connection was created.
+     *
+     **/
+    ["cpp:const"] Endpoint getEndpoint();
+
+    /**
+     *
+     * Flush any pending batch requests for this connection. This
+     * causes all batch requests that were sent via proxies that use
+     * this connection to be sent to the server.
+     *
+     **/
+    ["async"] void flushBatchRequests();
+
+    /**
+     *
+     * Set callback on the connection. The callback is called by the
+     * connection when it's closed. The callback is called from the
+     * Ice thread pool associated with the connection.
+     *
+     * @param callback The connection callback object.
+     *
+     **/
+    void setCallback(ConnectionCallback callback);
+
+    /**
+     *
+     * Set the active connection management parameters.
+     *
+     * @param timeout The timeout value in milliseconds.
+     *
+     * @param close The close condition
+     *
+     * @param heartbeat The hertbeat condition
+     *
+     **/
+    ["java:optional"] 
+    void setACM(optional(1) int timeout, optional(2) ACMClose close, optional(3) ACMHeartbeat heartbeat);
+
+    /**
+     *
+     * Get the ACM parameters.
+     *
+     * @return The ACM parameters.
+     *
+     **/
+    ACM getACM();
+
+    /**
+     *
+     * Return the connection type. This corresponds to the endpoint
+     * type, i.e., "tcp", "udp", etc.
+     *
+     * @return The type of the connection.
+     *
+     **/
+    ["cpp:const"] string type();
+
+    /**
+     *
+     * Get the timeout for the connection.
+     *
+     * @return The connection's timeout.
+     *
+     **/
+    ["cpp:const"] int timeout();
+
+    /**
+     *
+     * Return a description of the connection as human readable text,
+     * suitable for logging or error messages.
+     *
+     * @return The description of the connection as human readable
+     * text.
+     *
+     **/
+    ["cpp:const"] string toString();
+
+    /**
+     *
+     * Returns the connection information.
+     *
+     * @return The connection information.
+     *
+     **/
+    ["cpp:const"] ConnectionInfo getInfo();
+};
+
+/**
+ *
+ * Provides access to the connection details of an IP connection
+ *
+ **/
+local class IPConnectionInfo extends ConnectionInfo
+{
+    /** The local address. */
+    string localAddress = "";
+
+    /** The local port. */
+    int localPort = -1;
+
+    /** The remote address. */
+    string remoteAddress = "";
+
+    /** The remote port. */
+    int remotePort = -1;
+};
+
+/**
+ *
+ * Provides access to the connection details of a TCP connection
+ *
+ **/
+local class TCPConnectionInfo extends IPConnectionInfo
+{
+};
+
+/**
+ *
+ * Provides access to the connection details of a UDP connection
+ *
+ **/
+local class UDPConnectionInfo extends IPConnectionInfo
+{
+    /** The multicast address. */
+    string mcastAddress;
+
+    /** The multicast port. */
+    int mcastPort = -1;
+};
+
+/**
+ *
+ * Provides access to the connection details of a WebSocket connection
+ *
+ **/
+local class WSConnectionInfo extends IPConnectionInfo
+{
+};
+
+};
+

data/slice/Ice/ConnectionF.ice

@@ -0,0 +1,22 @@
+// **********************************************************************
+//
+// 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 class ConnectionInfo;
+local class WSConnectionInfo;
+local interface Connection;
+
+};
+

data/slice/Ice/Current.ice

@@ -0,0 +1,160 @@
+// **********************************************************************
+//
+// 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/ConnectionF.ice>
+#include <Ice/Identity.ice>
+#include <Ice/Version.ice>
+
+module Ice
+{
+
+/**
+ *
+ * A request context. <tt>Context</tt> is used to transmit metadata about a
+ * request from the server to the client, such as Quality-of-Service
+ * (QoS) parameters. Each operation on the client has a <tt>Context</tt> as
+ * its implicit final parameter.
+ *
+ **/
+dictionary<string, string> Context;
+
+/**
+ *
+ * The {@link OperationMode} determines the retry behavior an
+ * invocation in case of a (potentially) recoverable error.
+ *
+ **/
+//
+// Note: The order of definitions here *must* match the order of
+// definitions for ::Slice::Operation::Mode in include/Slice/Parser.h!
+//
+enum OperationMode
+{
+    /**
+     * Ordinary operations have <tt>Normal</tt> mode.  These operations
+     * modify object state; invoking such an operation twice in a row
+     * has different semantics than invoking it once. The Ice run time
+     * guarantees that it will not violate at-most-once semantics for
+     * <tt>Normal</tt> operations.
+     */
+    Normal,
+
+    /**
+     * Operations that use the Slice <tt>nonmutating</tt> keyword must not
+     * modify object state. For C++, nonmutating operations generate
+     * <tt>const</tt> member functions in the skeleton. In addition, the Ice
+     * run time will attempt to transparently recover from certain
+     * run-time errors by re-issuing a failed request and propagate
+     * the failure to the application only if the second attempt
+     * fails.
+     *
+     * <p class="Deprecated"><tt>Nonmutating</tt> is deprecated; Use the
+     * <tt>idempotent</tt> keyword instead. For C++, to retain the mapping
+     * of <tt>nonmutating</tt> operations to C++ <tt>const</tt>
+     * member functions, use the <tt>\["cpp:const"]</tt> metadata
+     * directive.
+     */
+    \Nonmutating,
+
+    /**
+     * Operations that use the Slice <tt>idempotent</tt> keyword can modify
+     * object state, but invoking an operation twice in a row must
+     * result in the same object state as invoking it once.  For
+     * example, <tt>x = 1</tt> is an idempotent statement,
+     * whereas <tt>x += 1</tt> is not. For idempotent
+     * operations, the Ice run-time uses the same retry behavior
+     * as for nonmutating operations in case of a potentially
+     * recoverable error.
+     */
+    \Idempotent
+};
+
+/**
+ *
+ * Information about the current method invocation for servers. Each
+ * operation on the server has a <tt>Current</tt> as its implicit final
+ * parameter. <tt>Current</tt> is mostly used for Ice services. Most
+ * applications ignore this parameter.
+ *
+ **/
+local struct Current
+{
+    /**
+     *
+     * The object adapter.
+     *
+     **/
+    ObjectAdapter adapter;
+    
+    /**
+     *
+     * Information about the connection over which the current method
+     * invocation was received. If the invocation is direct due to
+     * collocation optimization, this value is set to null.
+     *
+     **/
+    Connection con;
+
+    /**
+     *
+     * The Ice object identity.
+     *
+     **/
+    Identity id;
+
+    /**
+     *
+     * The facet.
+     *
+     ***/
+    string facet;
+
+    /**
+     *
+     * The operation name.
+     *
+     **/
+    string operation;
+
+    /**
+     *
+     * The mode of the operation.
+     *
+     **/
+    OperationMode mode;
+
+    /**
+     *
+     * The request context, as received from the client.
+     *
+     **/
+    Context ctx;
+
+    /**
+     *
+     * The request id unless oneway (0) or collocated (-1).
+     *
+     **/
+    int requestId;
+
+    /**
+     *
+     * The encoding version used to encode the input and output parameters.
+     *
+     **/
+    Ice::EncodingVersion encoding;
+};
+
+};
+