| /* |
| * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * Differences from original: |
| * |
| * - do not include orb.idl |
| * - include IOP.idl, Messaging.idl and CORBAX.idl |
| * - renamed component parameter names to tagged_component (so that they |
| * do not conflict with the CORBA 3.0 "component" keyword). |
| * - javadocs added (synchronized with orbos/00-08-06) |
| * |
| * NOTE: After compilation of this IDL file, all Helper and Holder classes |
| * that are not needed are removed. |
| */ |
| #include "IOP.idl" |
| #include "Messaging.idl" |
| #include "CORBAX.idl" |
| #include "corba.idl" |
| |
| #pragma prefix "omg.org" |
| |
| #ifndef CORBA3 |
| #define local |
| #endif |
| |
| module Dynamic { |
| |
| /** |
| * <code>NVList</code> PIDL represented by <code>ParameterList</code> IDL. |
| * This exists in order to keep the Portable Interceptor IDL from becoming |
| * PIDL. |
| */ |
| struct Parameter { |
| any argument; |
| CORBA::ParameterMode mode; |
| }; |
| |
| /** |
| * <code>NVList</code> PIDL represented by <code>ParameterList</code> IDL. |
| * This exists in order to keep the Portable Interceptor IDL from becoming |
| * PIDL. |
| */ |
| typedef sequence<Parameter> ParameterList; |
| |
| /** |
| * <code>ContextList</code> PIDL represented by <code>ContextList</code> |
| * IDL. This exists in order to keep the Portable Interceptor IDL from |
| * becoming PIDL. |
| */ |
| typedef CORBA::StringSeq ContextList; |
| |
| /** |
| * <code>ExceptionList</code> PIDL represented by <code>ExceptionList</code> |
| * IDL. This exists in order to keep the Portable Interceptor IDL from |
| * becoming PIDL. |
| */ |
| typedef sequence<CORBA::TypeCode> ExceptionList; |
| |
| /** |
| * <code>Context</code> PIDL represented by <code>RequestContext</code> |
| * IDL. This exists in order to keep the Portable Interceptor IDL from o |
| * becoming PIDL. |
| * <p> |
| * <code>Context</code> objects are encoded as <code>String[]</code>. The |
| * <code>Strings</code> occur in pairs. The first <code>String</code> in |
| * each pair is the context property name and the second <code>String</code> |
| * in each pair is the associated value. |
| */ |
| typedef CORBA::StringSeq RequestContext; |
| }; |
| |
| module PortableInterceptor { |
| /** |
| * All Portable Interceptors implement Interceptor. |
| */ |
| local interface Interceptor { |
| /** |
| * Returns the name of the interceptor. |
| * <p> |
| * Each Interceptor may have a name that may be used administratively |
| * to order the lists of Interceptors. Only one Interceptor of a given |
| * name can be registered with the ORB for each Interceptor type. An |
| * Interceptor may be anonymous, i.e., have an empty string as the name |
| * attribute. Any number of anonymous Interceptors may be registered with |
| * the ORB. |
| * |
| * @return the name of the interceptor. |
| */ |
| readonly attribute string name; |
| |
| // Added in ptc/00-08-06 |
| /** |
| * Provides an opportunity to destroy this interceptor. |
| * The destroy method is called during <code>ORB.destroy</code>. When an |
| * application calls <code>ORB.destroy</code>, the ORB: |
| * <ol> |
| * <li>waits for all requests in progress to complete</li> |
| * <li>calls the <code>Interceptor.destroy</code> operation for each |
| * interceptor</li> |
| * <li>completes destruction of the ORB</li> |
| * </ol> |
| * Method invocations from within <code>Interceptor.destroy</code> on |
| * object references for objects implemented on the ORB being destroyed |
| * result in undefined behavior. However, method invocations on objects |
| * implemented on an ORB other than the one being destroyed are |
| * permitted. (This means that the ORB being destroyed is still capable |
| * of acting as a client, but not as a server.) |
| */ |
| void destroy(); |
| }; |
| |
| |
| /** |
| * The <code>ForwardRequest</code> exception is the means by which an |
| * Interceptor can indicate to the ORB that a retry of the request should |
| * occur with the new object given in the exception. This behavior of |
| * causing a retry only occurs if the ORB receives a ForwardRequest from |
| * an interceptor. If <code>ForwardRequest</code> is thrown anywhere else |
| * it is passed through the ORB as is normal for a user exception. |
| * <p> |
| * If an Interceptor throws a <code>ForwardRequest</code> exception in |
| * response to a call of an interceptor, no other Interceptors are called |
| * for that interception point. The remaining Interceptors in the Flow Stack |
| * shall have their appropriate ending interception point called: |
| * <code>receive_other</code> on the client, or <code>send_other</code> on |
| * the server. The <code>reply_status</code> in the |
| * <code>receive_other</code> or <code>send_other</code> would be |
| * <code>LOCATION_FORWARD</code>. |
| */ |
| exception ForwardRequest { |
| /** |
| * The new object to forward the request to. |
| */ |
| Object forward; |
| // Change in ptc/00-08-06 |
| // boolean permanent; |
| }; |
| |
| /** Reply status, represented as an int */ |
| typedef short ReplyStatus; |
| |
| // Valid reply_status values: |
| |
| /** |
| * Indicates a successful Reply Status. One possible value for |
| * <code>RequestInfo.reply_status</code>. |
| * @see RequestInfo#reply_status |
| * @see SYSTEM_EXCEPTION |
| * @see USER_EXCEPTION |
| * @see LOCATION_FORWARD |
| * @see TRANSPORT_RETRY |
| */ |
| const ReplyStatus SUCCESSFUL = 0; |
| |
| /** |
| * Indicates a SystemException reply status. One possible value for |
| * <code>RequestInfo.reply_status</code>. |
| * @see RequestInfo#reply_status |
| * @see SUCCESSFUL |
| * @see USER_EXCEPTION |
| * @see LOCATION_FORWARD |
| * @see TRANSPORT_RETRY |
| */ |
| const ReplyStatus SYSTEM_EXCEPTION = 1; |
| |
| /** |
| * Indicates a UserException reply status. One possible value for |
| * <code>RequestInfo.reply_status</code>. |
| * @see RequestInfo#reply_status |
| * @see SUCCESSFUL |
| * @see SYSTEM_EXCEPTION |
| * @see LOCATION_FORWARD |
| * @see TRANSPORT_RETRY |
| */ |
| const ReplyStatus USER_EXCEPTION = 2; |
| |
| /** |
| * Indicates a LocationForward reply status. One possible value for |
| * <code>RequestInfo.reply_status</code>. |
| * @see RequestInfo#reply_status |
| * @see SUCCESSFUL |
| * @see SYSTEM_EXCEPTION |
| * @see USER_EXCEPTION |
| * @see TRANSPORT_RETRY |
| */ |
| const ReplyStatus LOCATION_FORWARD = 3; |
| |
| // Changes in ptc/00-08-06 |
| // const ReplyStatus LOCATION_FORWARD_PERMANENT = 4; |
| |
| /** |
| * Indicates a Transport Retry reply status. One possible value for |
| * <code>RequestInfo.reply_status</code>. |
| * @see RequestInfo#reply_status |
| * @see SUCCESSFUL |
| * @see SYSTEM_EXCEPTION |
| * @see USER_EXCEPTION |
| * @see LOCATION_FORWARD |
| */ |
| const ReplyStatus TRANSPORT_RETRY = 4; |
| |
| /** |
| * XXX |
| */ |
| const ReplyStatus UNKNOWN = 5; |
| |
| /** Slot id, represented as an int */ |
| typedef unsigned long SlotId; |
| |
| /** |
| * This exception is thrown when <code>get_slot</code> or |
| * <code>set_slot</code> is called on a slot that has not been allocated. |
| */ |
| exception InvalidSlot {}; |
| |
| /** |
| * Portable Interceptors Current (also known as <code>PICurrent</code>) |
| * is merely a slot table, the slots of which are used by each service to |
| * transfer their context data between their context and the request's or |
| * reply's service context. Each service which wishes to use PICurrent |
| * reserves a slot or slots at initialization time and uses those slots |
| * during the processing of requests and replies. |
| * <p> |
| * Before an invocation is made, PICurrent is obtained via a call to |
| * <code>ORB.resolve_initial_references( "PICurrent" )</code>. From within |
| * the interception points, the data on PICurrent that has moved from the |
| * thread scope to the request scope is available via the |
| * <code>get_slot</code> operation on the <code>RequestInfo</code> object. |
| * A PICurrent can still be obtained via |
| * <code>resolve_initial_references</code>, but that is the Interceptor's |
| * thread scope PICurrent. |
| */ |
| local interface Current : CORBA::Current { |
| |
| /** |
| * Retrieves the slot data the application set in PICurrent via |
| * <code>get_slot</code>. The data is in the form of an Any. |
| * <p> |
| * If the given slot has not been set, an Any containing a type code |
| * with a <code>TCKind</code> value of <code>tk_null</code> and no value |
| * is returned. |
| * |
| * @param id The <code>SlotId</code> of the slot from which the data will |
| * be returned. |
| * @return The data, in the form of an Any, of the given slot identifier. |
| * @exception InvalidSlot thrown if get_slot is called on a slot that |
| * has not been allocated. |
| * @exception BAD_INV_ORDER thrown if <code>get_slot</code> is called |
| * from within an ORB initializer |
| */ |
| any get_slot (in SlotId id) raises (InvalidSlot); |
| |
| /** |
| * Sets data in a slot. The data is in the form of an Any. If data |
| * already exists in that slot, it is overridden. |
| * |
| * @param id The <code>SlotId</code> of the slot to which the data will |
| * be set. |
| * @param data The data, in the form of an Any, which will be set |
| * to the identified slot. |
| * @exception InvalidSlot thrown if <code>set_slot</code> is called on |
| * a slot that has not been allocated. |
| * @exception BAD_INV_ORDER thrown if <code>set_slot</code> is called |
| * from within an ORB initializer. |
| */ |
| void set_slot (in SlotId id, in any data) raises (InvalidSlot); |
| }; |
| |
| /** |
| * Request Information, accessible to Interceptors. |
| * <p> |
| * Each interception point is given an object through which the |
| * Interceptor can access request information. Client-side and server-side |
| * interception points are concerned with different information, so there |
| * are two information objects: <code>ClientRequestInfo</code> is passed |
| * to the client-side interception points and <code>ServerRequestInfo</code> |
| * is passed to the server-side interception points. But there is |
| * information that is common to both, so they both inherit from a common |
| * interface: <code>RequestInfo</code>. |
| * |
| * @see ClientRequestInfo |
| * @see ServerRequestInfo |
| */ |
| local interface RequestInfo { |
| /** |
| * Returns an id that uniquely identifies an active request/reply |
| * sequence. Once a request/reply sequence is concluded this ID may be |
| * reused. Note that this id is not the same as the GIOP |
| * <code>request_id</code>. If GIOP is the transport mechanism used, |
| * then these IDs may very well be the same, but this is not guaranteed |
| * nor required. |
| */ |
| readonly attribute unsigned long request_id; |
| |
| /** |
| * Returns the name of the operation being invoked. |
| */ |
| readonly attribute string operation; |
| |
| /** |
| * Returns an array of <code>Parameter</code> objects, containing the |
| * arguments on the operation being invoked. If there are no arguments, |
| * this attribute will be a zero length array. |
| * <p> |
| * Not all environments provide access to the arguments. With the Java |
| * portable bindings, for example, the arguments are not available. |
| * In these environments, when this attribute is accessed, |
| * <code>NO_RESOURCES</code> will be thrown with a standard minor code |
| * of 1. |
| * <p> |
| * <i>Note: Arguments are available for DSI/DII calls.</i> |
| * |
| * @exception NO_RESOURCES thrown if arguments are not available. |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| readonly attribute Dynamic::ParameterList arguments; |
| |
| /** |
| * Returns an array of <code>TypeCode</code> objects describing the |
| * <code>TypeCode</code>s of the user exceptions that this operation |
| * invocation may throw. If there are no user exceptions, this |
| * will return a zero length array. |
| * <p> |
| * Not all environments provide access to the exception list. With |
| * the Java portable bindings, for example, the exception list is |
| * not available. In these environments, when this attribute is |
| * accessed, <code>NO_RESOURCES</code> will be thrown with a |
| * standard minor code of 1. |
| * <p> |
| * <i>Note: Exceptions are available for DSI/DII calls.</i> |
| * |
| * @exception NO_RESOURCES thrown if exceptions are not available. |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| readonly attribute Dynamic::ExceptionList exceptions; |
| |
| /** |
| * Returns an array of <code>String</code> objects describing the |
| * contexts that may be passed on this operation invocation. If there |
| * are no contexts, this will return a zero length array. |
| * <p> |
| * Not all environments provide access to the context list. With the |
| * Java portable bindings, for example, the context list is not |
| * available. In these environments, when this attribute is accessed, |
| * <code>NO_RESOURCES</code> will be thrown with a standard minor code |
| * of 1. |
| * <p> |
| * <i>Note: Contexts are available for DSI/DII calls.</i> |
| * |
| * @exception NO_RESOURCES thrown if contexts are not available. |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| readonly attribute Dynamic::ContextList contexts; |
| |
| /** |
| * Returns an array of <code>String</code> objects containing the |
| * contexts being sent on the request. |
| * <p> |
| * Not all environments provide access to the context. With the Java |
| * portable bindings, for example, the context is not available. In |
| * these environments, when this attribute is accessed, NO_RESOURCES will |
| * be thrown with standard minor code of 1. |
| * <p> |
| * <i>Note: <code>operation_context</code> is available for |
| * DSI/DII calls.</i> |
| * |
| * @exception NO_RESOURCES thrown if operation context is not available. |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| readonly attribute Dynamic::RequestContext operation_context; |
| |
| /** |
| * Returns an any containing the result of the operation invocation. |
| * If the operation return type is void, this attribute will be an any |
| * containing a type code with a <code>TCKind</code> value of |
| * <code>tk_void</code> and no value. |
| * <p> |
| * Not all environments provide access to the result. With the Java |
| * portable bindings, for example, the result is not available. In |
| * these environments, when this attribute is accessed, |
| * <code>NO_RESOURCES</code> will be thrown with a standard minor code of |
| * 1. |
| * <p> |
| * <i>Note: Result is available for DSI/DII calls.</i> |
| * |
| * @exception NO_RESOURCES thrown if result is not available. |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| readonly attribute any result; |
| |
| /** |
| * Indicates whether a response is expected. |
| * <p> |
| * On the client, a reply is not returned when |
| * <code>response_expected</code> is false, so <code>receive_reply</code> |
| * cannot be called. <code>receive_other</code> is called unless an |
| * exception occurs, in which case <code>receive_exception</code> is |
| * called. |
| * <p> |
| * On the client, within <code>send_poll</code>, this attribute is true. |
| */ |
| readonly attribute boolean response_expected; |
| |
| /** |
| * Defines how far the request shall progress before control is returned |
| * to the client. This is defined in the Messaging specification, and |
| * is pertinent only when <code>response_expected</code> is false. If |
| * <code>response_expected</code> is true, the value of |
| * <code>sync_scope</code> is undefined. This attribute may have one of |
| * the following values: |
| * <ul> |
| * <li><code>Messaging.SYNC_NONE</code></li> |
| * <li><code>Messaging.SYNC_WITH_TRANSPORT</code></li> |
| * <li><code>Messaging.SYNC_WITH_SERVER</code></li> |
| * <li><code>Messaging.SYNC_WITH_TARGET</code></li> |
| * </ul> |
| * On the server, for all scopes, a reply will be created from the |
| * return of the target operation call, but the reply will not return |
| * to the client. Although it does not return to the client, it does |
| * occur, so the normal server-side interception points are |
| * followed (i.e., <code>receive_request_service_contexts</code>, |
| * <code>receive_request</code>, <code>send_reply</code> or |
| * <code>send_exception</code>). |
| * <p> |
| * For <code>SYNC_WITH_SERVER</code> and <code>SYNC_WITH_TARGET</code>, |
| * the server does send an empty reply back to the client before the |
| * target is invoked. This reply is not intercepted by server-side |
| * Interceptors. |
| * |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| readonly attribute Messaging::SyncScope sync_scope; |
| |
| /** |
| * Describes the state of the result of the operation invocation. The |
| * return value can be one of the following: |
| * <ul> |
| * <li><code>PortableInterceptor.SUCCESSFUL</code></li> |
| * <li><code>PortableInterceptor.SYSTEM_EXCEPTION</code></li> |
| * <li><code>PortableInterceptor.USER_EXCEPTION</code></li> |
| * <li><code>PortableInterceptor.LOCATION_FORWARD</code></li> |
| * <li><code>PortableInterceptor.TRANSPORT_RETRY</code></li> |
| * </ul> |
| * On the client: |
| * <ul> |
| * <li>Within the <code>receive_reply</code> interception point, this |
| * will only return <code>SUCCESSFUL</code></li>. |
| * <li>Within the <code>receive_exception</code> interception point, |
| * this will be either <code>SYSTEM_EXCEPTION</code> or |
| * <code>USER_EXCEPTION</code>.</li> |
| * <li>Within the <code>receive_other</code> interception point, this |
| * will be any of: <code>SUCCESSFUL</code>, |
| * <code>LOCATION_FORWARD</code>, or <code>TRANSPORT_RETRY</code>. |
| * <code>SUCCESSFUL</code> means an asynchronous request returned |
| * successfully. <code>LOCATION_FORWARD</code> means that a reply |
| * came back with <code>LOCATION_FORWARD</code> as its status. |
| * <code>TRANSPORT_RETRY</code> means that the transport |
| * mechanism indicated a retry - a GIOP reply with a status of |
| * <code>NEEDS_ADDRESSING_MODE</code>, for instance. </li> |
| * </ul> |
| * On the server: |
| * <ul> |
| * <li>Within the <code>send_reply</code> interception point, this |
| * will only be <code>SUCCESSFUL</code>.</li> |
| * <li>Within the <code>send_exception</code> interception point, |
| * this will be either <code>SYSTEM_EXCEPTION</code> or |
| * <code>USER_EXCEPTION</code>.</li> |
| * <li>Within the <code>send_other</code> interception point, this |
| * attribute will be any of: <code>SUCCESSFUL</code>, or |
| * <code>LOCATION_FORWARD</code>. <code>SUCCESSFUL</code> means |
| * an asynchronous request returned successfully. |
| * <code>LOCATION_FORWARD</code> means that a reply came back |
| * with <code>LOCATION_FORWARD</code> as its status.</li> |
| * </ul> |
| * |
| * @see SUCCESSFUL |
| * @see SYSTEM_EXCEPTION |
| * @see USER_EXCEPTION |
| * @see LOCATION_FORWARD |
| * @see TRANSPORT_RETRY |
| */ |
| readonly attribute ReplyStatus reply_status; |
| |
| /** |
| * Contains the object to which the request will be forwarded, if the |
| * <code>reply_status</code> attribute is <code>LOCATION_FORWARD</code>. |
| * It is indeterminate whether a forwarded request will actually occur. |
| */ |
| readonly attribute Object forward_reference; |
| |
| /** |
| * Returns the data from the given slot of the |
| * <code>PortableInterceptor.Current</code> that is in the scope of |
| * the request. |
| * <p> |
| * If the given slot has not been set, then an any containing a |
| * type code with a <code>TCKind</code> value of <code>tk_null</code> is |
| * returned. |
| * |
| * @param id The <code>SlotId</code> of the slot which is to be |
| * returned. |
| * @return The slot data, in the form of an any, obtained with the |
| * given identifier. |
| * @exception InvalidSlot thrown if the ID does not define an |
| * allocated slot. |
| * @see Current |
| */ |
| any get_slot (in SlotId id) raises (InvalidSlot); |
| |
| /** |
| * Returns a copy of the service context with the given ID that |
| * is associated with the request. |
| * <p> |
| * @param id The <code>IOP.ServiceId</code> of the service context |
| * which is to be returned. |
| * @return The <code>IOP.ServiceContext</code> obtained with the |
| * given identifier. |
| * @exception BAD_PARAM thrown with a standard minor code of 26, if the |
| * request's service context does not contain an entry for that ID. |
| */ |
| IOP::ServiceContext get_request_service_context |
| (in IOP::ServiceId id); |
| |
| /** |
| * Returns a copy of the service context with the given ID that |
| * is associated with the reply. |
| * |
| * @param id The <code>IOP.ServiceId</code> of the service context |
| * which is to be returned. |
| * @return The <code>IOP.ServiceContext</code> obtained with the given |
| * identifier. |
| * @exception BAD_PARAM thrown with a standard minor code of 26 if the |
| * request's service context does not contain an entry for that ID. |
| */ |
| IOP::ServiceContext get_reply_service_context |
| (in IOP::ServiceId id); |
| }; |
| |
| /** |
| * Request Information, accessible to client-side request interceptors. |
| * <p> |
| * Some attributes and operations on <code>ClientRequestInfo</code> are |
| * not valid at all interception points. The following table shows the |
| * validity of each attribute or operation. If it is not valid, attempting |
| * to access it will result in a <code>BAD_INV_ORDER</code> being thrown |
| * with a standard minor code of 14. |
| * <p> |
| * |
| * <table border=1 summary="Shows the validity of each attribute or operation"> |
| * <thead> |
| * <tr> |
| * <th> </th> |
| * <th id="send_req">send_request</th> |
| * <th id="send_poll">send_poll</th> |
| * <th id="rec_reply">receive_reply</th> |
| * <th id="rec_ex">receive_exception</th> |
| * <th id="rec_oth">receive_other</th> |
| * </tr> |
| * </thead> |
| * <tbody> |
| * |
| * <tr> |
| * <td id="ri" colspan=6><i>Inherited from RequestInfo:</i></td> |
| * </tr> |
| * |
| * <tr><th id="req_id"><p align="left">request_id</p></th> |
| * <td headers="ri req_id send_req">yes</td> |
| * <td headers="ri req_id send_poll">yes</td> |
| * <td headers="ri req_id rec_reply">yes</td> |
| * <td headers="ri req_id rec_ex">yes</td> |
| * <td headers="ri req_id rec_oth">yes</td></tr> |
| * |
| * <tr><th id="op"><p align="left">operation</p></th> |
| * <td headers="ri op send_req">yes</td> |
| * <td headers="ri op send_poll">yes</td> |
| * <td headers="ri op rec_reply">yes</td> |
| * <td headers="ri op rec_ex">yes</td> |
| * <td headers="ri op rec_oth">yes</td></tr> |
| * |
| * <tr><th id="arg"><p align="left">arguments</p></th> |
| * <td headers="ri arg send_req">yes<sub>1</sub></td> |
| * <td headers="ri arg send_poll">no </td> |
| * <td headers="ri arg rec_reply">yes</td> |
| * <td headers="ri arg rec_ex">no </td> |
| * <td headers="ri arg rec_oth">no </td></tr> |
| * |
| * <tr><th id="exc"><p align="left">exceptions</p></th> |
| * <td headers="ri exc send_req">yes</td> |
| * <td headers="ri exc send_poll">no </td> |
| * <td headers="ri exc rec_reply">yes</td> |
| * <td headers="ri exc rec_ex">yes</td> |
| * <td headers="ri exc rec_oth">yes</td></tr> |
| * |
| * <tr><th id="con"><p align="left">contexts</p></th> |
| * <td headers="ri con send_req">yes</td> |
| * <td headers="ri con send_poll">no </td> |
| * <td headers="ri con rec_reply">yes</td> |
| * <td headers="ri con rec_ex">yes</td> |
| * <td headers="ri con rec_oth">yes</td></tr> |
| * |
| * <tr><th id="op_con"><p align="left">operation_context</p></th> |
| * <td headers="ri op_con send_req">yes</td> |
| * <td headers="ri op_con send_poll">no </td> |
| * <td headers="ri op_con rec_reply">yes</td> |
| * <td headers="ri op_con rec_ex">yes</td> |
| * <td headers="ri op_con rec_oth">yes</td> |
| * </tr> |
| * |
| * <tr><th id="result"><p align="left">result</p></th> |
| * <td headers="ri result send_req">no </td> |
| * <td headers="ri result send_poll">no </td> |
| * <td headers="ri result rec_reply">yes</td> |
| * <td headers="ri result rec_ex">no </td> |
| * <td headers="ri result rec_oth">no </td> |
| * </tr> |
| * |
| * <tr><th id="res_exp"><p align="left">response_expected</p></th> |
| * <td headers="ri res_exp send_req">yes</td> |
| * <td headers="ri res_exp send_poll">yes</td> |
| * <td headers="ri res_exp rec_reply">yes</td> |
| * <td headers="ri res_exp rec_ex">yes</td> |
| * <td headers="ri res_exp rec_oth">yes</td></tr> |
| * |
| * <tr><th id="sync_sco"><p align="left">sync_scope</p></th> |
| * <td headers="ri sync_sco send_req">yes</td> |
| * <td headers="ri sync_sco send_poll">no </td> |
| * <td headers="ri sync_sco rec_reply">yes</td> |
| * <td headers="ri sync_sco rec_ex">yes</td> |
| * <td headers="ri sync_sco rec_oth">yes</td> |
| * </tr> |
| * |
| * <tr><th id="rep_stat"><p align="left">reply_status</p></th> |
| * <td headers="ri rep_stat send_req">no </td> |
| * <td headers="ri rep_stat send_poll">no </td> |
| * <td headers="ri rep_stat rec_reply">yes</td> |
| * <td headers="ri rep_stat rec_ex">yes</td> |
| * <td headers="ri rep_stat rec_oth">yes</td></tr> |
| * |
| * <tr><th id="for_ref"><p align="left">forward_reference</p></th> |
| * <td headers="ri for_ref send_req">no </td> |
| * <td headers="ri for_ref send_poll">no </td> |
| * <td headers="ri for_ref rec_reply">no </td> |
| * <td headers="ri for_ref rec_ex">no </td> |
| * <td headers="ri for_ref rec_oth">yes<sub>2</sub> |
| * </td></tr> |
| * |
| * <tr><th id="get_slot"><p align="left">get_slot</p></th> |
| * <td headers="ri get_slot send_req">yes</td> |
| * <td headers="ri get_slot send_poll">yes</td> |
| * <td headers="ri get_slot rec_reply">yes</td> |
| * <td headers="ri get_slot rec_ex">yes</td> |
| * <td headers="ri get_slot rec_oth">yes</td></tr> |
| * |
| * <tr><th id="grsc"><p align="left">get_request_service_context</p></th> |
| * <td headers="ri grsc send_req">yes</td> |
| * <td headers="ri grsc send_poll">no </td> |
| * <td headers="ri grsc rec_reply">yes</td> |
| * <td headers="ri grsc rec_ex">yes</td> |
| * <td headers="ri grsc rec_oth">yes</td></tr> |
| * |
| * <tr><th id="gpsc"><p align="left">get_reply_service_context</p></th> |
| * <td headers="ri gpsc send_req">no </td> |
| * <td headers="ri gpsc send_poll">no </td> |
| * <td headers="ri gpsc rec_reply">yes</td> |
| * <td headers="ri gpsc rec_ex">yes</td> |
| * <td headers="ri gpsc rec_oth">yes</td> |
| * </tr> |
| * |
| * <tr> |
| * <td id="cri" colspan=6><i>ClientRequestInfo-specific:</i></td> |
| * </tr> |
| * |
| * <tr><th id="target"><p align="left">target</p></th> |
| * <td headers="cri target send_req">yes</td> |
| * <td headers="cri target send_poll">yes</td> |
| * <td headers="cri target rec_reply">yes</td> |
| * <td headers="cri target rec_ex">yes</td> |
| * <td headers="cri target rec_oth">yes</td></tr> |
| * |
| * <tr><th id="eftarget"><p align="left">effective_target</p></th> |
| * <td headers="cri eftarget send_req">yes</td> |
| * <td headers="cri eftarget send_poll">yes</td> |
| * <td headers="cri eftarget rec_reply">yes</td> |
| * <td headers="cri eftarget rec_ex">yes</td> |
| * <td headers="cri eftarget rec_oth">yes</td> |
| * </tr> |
| * |
| * <tr><th id="efprof"><p align="left">effective_profile</p></th> |
| * <td headers="cri efprof send_req">yes</td> |
| * <td headers="cri efprof send_poll">yes</td> |
| * <td headers="cri efprof rec_reply">yes</td> |
| * <td headers="cri efprof rec_ex">yes</td> |
| * <td headers="cri efprof rec_oth">yes</td></tr> |
| * |
| * <tr><th id="rxp"><p align="left">received_exception</p></th> |
| * <td headers="cri rxp send_req">no </td> |
| * <td headers="cri rxp send_poll">no </td> |
| * <td headers="cri rxp rec_reply">no </td> |
| * <td headers="cri rxp rec_ex">yes</td> |
| * <td headers="cri rxp rec_oth">no </td></tr> |
| * |
| * <tr><th id="rei"><p align="left">received_exception_id</p></th> |
| * <td headers="cri rei send_req">no </td> |
| * <td headers="cri rei send_poll">no </td> |
| * <td headers="cri rei rec_reply">no </td> |
| * <td headers="cri rei rec_ex">yes</td> |
| * <td headers="cri rei rec_oth">no </td></tr> |
| * |
| * <tr><th id="gec"><p align="left">get_effective_component</p></th> |
| * <td headers="cri gec send_req">yes</td> |
| * <td headers="cri gec send_poll">no </td> |
| * <td headers="cri gec rec_reply">yes</td> |
| * <td headers="cri gec rec_ex">yes</td> |
| * <td headers="cri gec rec_oth">yes</td></tr> |
| * |
| * <tr><th id="gecs"><p align="left">get_effective_components</p></th> |
| * <td headers="cri gecs send_req">yes</td> |
| * <td headers="cri gecs send_poll">no </td> |
| * <td headers="cri gecs rec_reply">yes</td> |
| * <td headers="cri gecs rec_ex">yes</td> |
| * <td headers="cri gecs rec_oth">yes</td></tr> |
| * |
| * <tr><th id="grpcy"><p align="left">get_request_policy</p></th> |
| * <td headers="cri grpcy send_req">yes</td> |
| * <td headers="cri grpcy send_poll">no </td> |
| * <td headers="cri grpcy rec_reply">yes</td> |
| * <td headers="cri grpcy rec_ex">yes</td> |
| * <td headers="cri grpcy rec_oth">yes</td></tr> |
| * |
| * <tr><th id="arsc"><p align="left">add_request_service_context</p></th> |
| * <td headers="cri arsc send_req">yes</td> |
| * <td headers="cri arsc send_poll">no </td> |
| * <td headers="cri arsc rec_reply">no </td> |
| * <td headers="cri arsc rec_ex">no </td> |
| * <td headers="cri arsc rec_oth">no </td></tr> |
| * |
| * </tbody> |
| * </table> |
| * |
| * <ol> |
| * <li>When <code>ClientRequestInfo</code> is passed to |
| * <code>send_request</code>, there is an entry in the list for every |
| * argument, whether in, inout, or out. But only the in and inout |
| * arguments will be available.</li> |
| * <li>If the <code>reply_status</code> atribute is not |
| * <code>LOCATION_FORWARD</code>, accessing this attribute will |
| * throw <code>BAD_INV_ORDER</code> with a standard minor code of |
| * 14.</li> |
| * </ol> |
| * |
| * @see ClientRequestInterceptor |
| */ |
| local interface ClientRequestInfo : RequestInfo { |
| |
| /** |
| * Returns the object which the client called to perform the |
| * operation. |
| * |
| * @see #effective_target |
| */ |
| readonly attribute Object target; |
| |
| /** |
| * Returns the actual object on which the operation will be invoked. |
| * If the <code>reply_status</code> is <code>LOCATION_FORWARD</code>, |
| * then on subsequent requests, <code>effective_target</code> will |
| * contain the forwarded IOR while target will remain unchanged. |
| * |
| * @see #target |
| */ |
| readonly attribute Object effective_target; |
| |
| /** |
| * Returns the profile that will be used to send the request. If a |
| * location forward has occurred for this operation's object and |
| * that object's profile changed accordingly, then this profile will |
| * be that located profile. |
| */ |
| readonly attribute IOP::TaggedProfile effective_profile; |
| |
| /** |
| * Returns an any which contains the exception to be returned to |
| * the client. |
| * <p> |
| * If the exception is a user exception which cannot be inserted |
| * into an any (e.g., it is unknown or the bindings don t provide |
| * the <code>TypeCode</code>), then this attribute will be an any |
| * containing the system exception <code>UNKNOWN</code> with a |
| * standard minor code of 1. However, the repository id of |
| * the exception is available in the <code>received_exception_id</code> |
| * attribute. |
| * |
| * @see #received_exception_id |
| */ |
| readonly attribute any received_exception; |
| |
| /** |
| * Returns the repository id of the exception to be returned to |
| * the client. |
| * |
| * @see #received_exception |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| readonly attribute CORBA::RepositoryId received_exception_id; |
| |
| /** |
| * Returns the <code>IOP.TaggedComponent</code> with the given ID from |
| * the profile selected for this request. |
| * <p> |
| * If there is more than one component for a given component ID, it |
| * is undefined which component this operation returns. If there is |
| * more than one component for a given component ID, |
| * <code>get_effective_components</code> should be called instead. |
| * |
| * @param id The component id of the component which |
| * is to be returned. |
| * @return The <code>IOP.TaggedComponent</code> obtained with the |
| * given identifier. |
| * @exception BAD_PARAM thrown, with a standard minor code of 28, if |
| * no component exists for the given component ID. |
| * @see #get_effective_components |
| */ |
| IOP::TaggedComponent get_effective_component |
| (in IOP::ComponentId id); |
| |
| /** |
| * Returns an array of all tagged components with the given ID from the |
| * profile selected for this request. |
| * |
| * @param id The component id of the components which are to be returned. |
| * @return An array of <code>TaggedComponent</code> objects, each of |
| * which contains the given identifier. |
| * @exception BAD_PARAM thrown, with a standard minor code of 28, if |
| * no component exists for the given component ID. |
| * @see #get_effective_component |
| */ |
| IOP::TaggedComponentSeq get_effective_components |
| (in IOP::ComponentId id); |
| |
| /** |
| * Returns the given policy in effect for this operation. |
| * |
| * @exception INV_POLICY thrown, with a standard minor code of 1, if the |
| * policy type is not valid either because the specified type is |
| * not supported by this ORB or because a policy object of that type |
| * is not associated with this Object |
| * @param type The policy type which specifies the policy to be |
| * returned. |
| * @return The <code>CORBA.Policy</code> obtained with the given type. |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| CORBA::Policy get_request_policy |
| (in CORBA::PolicyType type); |
| |
| /** |
| * Allows Interceptors to add service contexts to the request. |
| * <p> |
| * There is no declaration of the order of the service contexts. |
| * They may or may not appear in the order that they are added. |
| * |
| * @param service_context The <code>IOP.ServiceContext</code> to be |
| * added to the request. |
| * @param replace Indicates the behavior of this operation when a |
| * service context already exists with the given ID. If false, |
| * then <code>BAD_INV_ORDER</code> with a standard minor code of 15 |
| * is thrown. If true, then the existing service context is |
| * replaced by the new one. |
| */ |
| void add_request_service_context ( |
| in IOP::ServiceContext service_context, |
| in boolean replace); |
| }; |
| |
| // Should be type string |
| typedef string ServerId ; |
| |
| // This should actually be the CORBA::ORBid type once that is available |
| typedef string ORBId ; |
| |
| /** The name of an object adapter. This is unique only within |
| * the scope of the ORB that created the object adapter. |
| */ |
| typedef org::omg::CORBA::StringSeq AdapterName ; |
| |
| /** Type of an object id. This provides the identity of a particular |
| * object that was created by an object adapter. |
| */ |
| typedef org::omg::CORBA::OctetSeq ObjectId ; |
| |
| /** |
| * Request Information, accessible to server-side request interceptors. |
| * <p> |
| * Some attributes and operations on <code>ServerRequestInfo</code> are not |
| * valid at all interception points. The following table shows the validity |
| * of each attribute or operation. If it is not valid, attempting to access |
| * it will result in a <code>BAD_INV_ORDER</code> being thrown with a |
| * standard minor code of 14. |
| * <p> |
| * |
| * |
| * <table border=1 summary="Shows the validity of each attribute or operation"> |
| * <thead> |
| * <tr> |
| * <th> </th> |
| * <th id="rec_req_ser_con" valign="bottom">receive_request_<br>service_contexts</th> |
| * <th id="rec_req" valign="bottom">receive_request</th> |
| * <th id="send_rep" valign="bottom">send_reply</th> |
| * <th id="send_exc" valign="bottom">send_exception</th> |
| * <th id="send_oth" valign="bottom">send_other</th> |
| * </tr> |
| * </thead> |
| * <tbody> |
| * |
| * |
| * <tr> |
| * <td id="ri" colspan=6><i>Inherited from RequestInfo:</i></td> |
| * </tr> |
| * |
| * <tr><th id="req_id"><p align="left">request_id</p></th> |
| * <td headers="ri req_id rec_req_ser_con">yes</td> |
| * <td headers="ri req_id rec_req">yes</td> |
| * <td headers="ri req_id send_rep">yes</td> |
| * <td headers="ri req_id send_exc">yes</td> |
| * <td headers="ri req_id send_oth">yes</td></tr> |
| * |
| * <tr><th id="op"><p align="left">operation</p></th> |
| * <td headers="ri op rec_req_ser_con">yes</td> |
| * <td headers="ri op rec_req">yes</td> |
| * <td headers="ri op send_rep">yes</td> |
| * <td headers="ri op send_exc">yes</td> |
| * <td headers="ri op send_oth">yes</td></tr> |
| * |
| * <tr><th id="args"><p align="left">arguments</p></th> |
| * <td headers="ri args rec_req_ser_con">no </td> |
| * <td headers="ri args rec_req">yes<sub>1</sub></td> |
| * <td headers="ri args send_rep">yes</td> |
| * <td headers="ri args send_exc">no<sub>2</sub></td> |
| * <td headers="ri args send_oth">no<sub>2</sub> |
| * </td></tr> |
| * |
| * <tr><th id="exps"><p align="left">exceptions</p></th> |
| * <td headers="ri exps rec_req_ser_con">no </td> |
| * <td headers="ri exps rec_req">yes</td> |
| * <td headers="ri exps send_rep">yes</td> |
| * <td headers="ri exps send_exc">yes</td> |
| * <td headers="ri exps send_oth">yes</td></tr> |
| * |
| * <tr><th id="contexts"><p align="left">contexts</p></th> |
| * <td headers="ri contexts rec_req_ser_con">no </td> |
| * <td headers="ri contexts rec_req">yes</td> |
| * <td headers="ri contexts send_rep">yes</td> |
| * <td headers="ri contexts send_exc">yes</td> |
| * <td headers="ri contexts send_oth">yes</td></tr> |
| * |
| * <tr><th id="op_con"><p align="left">operation_context</p></th> |
| * <td headers="ri op_con rec_req_ser_con">no </td> |
| * <td headers="ri op_con rec_req">yes</td> |
| * <td headers="ri op_con send_rep">yes</td> |
| * <td headers="ri op_con send_exc">no </td> |
| * <td headers="ri op_con send_oth">no </td> |
| * </tr> |
| * |
| * <tr><th id="result"><p align="left">result</p></th> |
| * <td headers="ri result rec_req_ser_con">no </td> |
| * <td headers="ri result rec_req">no </td> |
| * <td headers="ri result send_rep">yes</td> |
| * <td headers="ri result send_exc">no </td> |
| * <td headers="ri result send_oth">no </td> |
| * </tr> |
| * |
| * <tr><th id="res_ex"><p align="left">response_expected</p></th> |
| * <td headers="ri res_ex rec_req_ser_con">yes</td> |
| * <td headers="ri res_ex rec_req">yes</td> |
| * <td headers="ri res_ex send_rep">yes</td> |
| * <td headers="ri res_ex send_exc">yes</td> |
| * <td headers="ri res_ex send_oth">yes</td></tr> |
| * |
| * <tr><th id="syn_scp"><p align="left">sync_scope</p></th> |
| * <td headers="ri syn_scp rec_req_ser_con">yes</td> |
| * <td headers="ri syn_scp rec_req">yes</td> |
| * <td headers="ri syn_scp send_rep">yes</td> |
| * <td headers="ri syn_scp send_exc">yes</td> |
| * <td headers="ri syn_scp send_oth">yes</td></tr> |
| * |
| * <tr><td><b>request_id</b></td> |
| * <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>operation</b></td> |
| * <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>arguments</b></td> |
| * <td>no </td> <td>yes<sub>1</sub</td> |
| * <td>yes</td> <td>no<sub>2</sub></td> |
| * <td>no<sub>2</sub> |
| * </td></tr> |
| * |
| * <tr><td><b>exceptions</b></td> |
| * <td>no </td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>contexts</b></td> |
| * <td>no </td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>operation_context</b></td> |
| * <td>no </td> <td>yes</td> <td>yes</td> <td>no </td> <td>no </td></tr> |
| * |
| * <tr><td><b>result</b></td> |
| * <td>no </td> <td>no </td> <td>yes</td> <td>no </td> <td>no </td></tr> |
| * |
| * <tr><td><b>response_expected</b></td> |
| * <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>sync_scope</b></td> |
| * <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>reply_status</b></td> |
| * <td>no </td> <td>no </td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>forward_reference</b></td> |
| * <td>no </td> <td>no </td> <td>no </td> <td>no </td> <td>yes<sub>2</sub> |
| * </td></tr> |
| * |
| * <tr><td><b>get_slot</b></td> |
| * <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>get_request_service_context</b></td> |
| * <td>yes</td> <td>no </td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>get_reply_service_context</b></td> |
| * <td>no </td> <td>no </td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr> |
| * <td colspan=6><i>ServerRequestInfo-specific:</i></td> |
| * </tr> |
| * |
| * <tr><td><b>sending_exception</b></td> |
| * <td>no </td> <td>no </td> <td>no </td> <td>yes</td> <td>no </td></tr> |
| * |
| * <tr><td><b>object_id</b></td> |
| * <td>no </td> <td>yes</td> <td>yes</td> <td>yes<sub>3</sub></td> |
| * <td>yes<sub>3</sub> |
| * </td></tr> |
| * |
| * <tr><td><b>adapter_id</b></td> |
| * <td>no </td> <td>yes</td> <td>yes</td> <td>yes<sub>3</sub></td> |
| * <td>yes<sub>3</sub> |
| * </td></tr> |
| * |
| * <tr><td><b>server_id</b></td> |
| * <td>no </td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>orb_id</b></td> |
| * <td>no </td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>adapter_name</b></td> |
| * <td>no </td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>target_most_derived_interface</b></td> |
| * <td>no </td> <td>yes</td> <td>no<sub>4</sub></td> |
| * <td>no<sub>4</sub></td> |
| * <td>no<sub>4</sub> |
| * </td></tr> |
| * |
| * <tr><td><b>get_server_policy</b></td> |
| * <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>set_slot</b></td> |
| * <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * |
| * <tr><td><b>target_is_a</b></td> |
| * <td>no </td> <td>yes</td> <td>no<sub>4</sub></td> |
| * <td>no<sub>4</sub></td> |
| * <td>no<sub>4</sub> |
| * </td></tr> |
| * |
| * <tr><td><b>add_reply_service_context</b></td> |
| * <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td> <td>yes</td></tr> |
| * </tbody> |
| * </table> |
| * |
| * <ol> |
| * <li>When <code>ServerRequestInfo</code> is passed to |
| * <code>receive_request</code>, there is an entry in the list for |
| * every argument, whether in, inout, or out. But only the in and |
| * inout arguments will be available.</li> |
| * <li>If the <code>reply_status</code> attribute is not |
| * <code>LOCATION_FORWARD</code>, accessing this attribute will throw |
| * <code>BAD_INV_ORDER</code> with a standard minor code of 14.</li> |
| * <li>If the servant locator caused a location forward, or thrown an |
| * exception, this attribute/operation may not be available in this |
| * interception point. <code>NO_RESOURCES</code> with a standard minor |
| * code of 1 will be thrown if it is not available.</li> |
| * <li>The operation is not available in this interception point because |
| * the necessary information requires access to the target object's |
| * servant, which may no longer be available to the ORB. For example, |
| * if the object's adapter is a POA that uses a |
| * <code>ServantLocator</code>, then the ORB invokes the interception |
| * point after it calls <code>ServantLocator.postinvoke()</code></li>. |
| * </ol> |
| * |
| * @see ServerRequestInterceptor |
| */ |
| local interface ServerRequestInfo : RequestInfo { |
| |
| /** |
| * Returns an any which contains the exception to be returned to |
| * the client. |
| * <p> |
| * If the exception is a user exception which cannot be inserted into |
| * an any (e.g., it is unknown or the bindings don't provide the |
| * <code>TypeCode</code>), then this attribute will be an any |
| * containing the system exception <code>UNKNOWN</code> with a |
| * standard minor code of 1. |
| * |
| * @see <a href="package-summary.html#unimpl"> |
| * <code>PortableInterceptor</code> package comments for |
| * limitations / unimplemented features</a> |
| */ |
| readonly attribute any sending_exception; |
| |
| /** |
| * Returns the opaque <code>object_id</code> describing the target of |
| * the operation invocation. |
| */ |
| readonly attribute ObjectId object_id; |
| |
| /** |
| * Returns the opaque identifier for the object adapter. |
| */ |
| readonly attribute CORBA::OctetSeq adapter_id; |
| |
| /** |
| * Returns the server ID that was specified on ORB::init using the -ORBServerId |
| * argument. |
| */ |
| readonly attribute ServerId server_id ; |
| |
| /** |
| * Returns the ID that was used to create the ORB. |
| */ |
| readonly attribute ORBId orb_id ; |
| |
| /** |
| * Returns the sequence of strings that identifies the object |
| * adapter instance that is handling this request. |
| */ |
| readonly attribute AdapterName adapter_name ; |
| |
| /** |
| * Returns the repository id for the most derived interface of the |
| * servant. |
| */ |
| readonly attribute CORBA::RepositoryId |
| target_most_derived_interface; |
| |
| /** |
| * Returns the policy in effect for this operation for the given |
| * policy type. The returned <code>CORBA.Policy</code> object shall |
| * only be a policy whose type was registered via |
| * <code>register_policy_factory</code>. |
| * |
| * @param type The <code>CORBA.PolicyType</code> which specifies the |
| * policy to be returned. |
| * @return The <code>CORBA.Policy</code> obtained with the given |
| * policy type. |
| * @exception INV_POLICY thrown, with a standard minor code of 2, if |
| * a policy for the given type was not registered via |
| * <code>register_policy_factory</code>. |
| * @see ORBInitInfo#register_policy_factory |
| */ |
| CORBA::Policy get_server_policy |
| (in CORBA::PolicyType type); |
| |
| /** |
| * Allows an Interceptor to set a slot in the |
| * <code>PortableInterceptor.Current</code> that is in the scope of |
| * the request. If data already exists in that slot, it will be |
| * overwritten. |
| * |
| * @param id The id of the slot. |
| * @param data The data, in the form of an any, to store in that slot. |
| * @exception InvalidSlot thrown if the ID does not define an allocated |
| * slot. |
| * @see Current |
| */ |
| void set_slot (in SlotId id, in any data) raises (InvalidSlot); |
| |
| /** |
| * Returns true if the servant is the given repository id, |
| * false if it is not. |
| * |
| * @param id The caller wants to know if the servant is this |
| * repository id. |
| * @return Is the servant the given RepositoryId? |
| */ |
| boolean target_is_a (in CORBA::RepositoryId id); |
| |
| /** |
| * Allows Interceptors to add service contexts to the request. |
| * <p> |
| * There is no declaration of the order of the service contexts. |
| * They may or may not appear in the order that they are added. |
| * |
| * @param service_context The <code>IOP.ServiceContext</code> to add to |
| * the reply. |
| * @param replace Indicates the behavior of this operation when a |
| * service context already exists with the given ID. If false, |
| * then <code>BAD_INV_ORDER</code> with a standard minor code of 15 |
| * is thrown. If true, then the existing service context is |
| * replaced by the new one. |
| * @exception BAD_INV_ORDER thrown, with a standard minor code of 15, if |
| * replace is false and a service context already exists with the |
| * given ID. |
| */ |
| void add_reply_service_context ( |
| in IOP::ServiceContext service_context, |
| in boolean replace); |
| }; |
| |
| /** |
| * Client-side request interceptor. |
| * <p> |
| * A request Interceptor is designed to intercept the flow of a |
| * request/reply sequence through the ORB at specific points so that |
| * services can query the request information and manipulate the service |
| * contexts which are propagated between clients and servers. The primary |
| * use of request Interceptors is to enable ORB services to transfer |
| * context information between clients and servers. There are two types |
| * of request Interceptors: client-side and server-side. |
| * <p> |
| * To write a client-side Interceptor, implement the |
| * <code>ClientRequestInterceptor</code> interface. |
| * |
| * @see ClientRequestInfo |
| */ |
| local interface ClientRequestInterceptor : Interceptor { |
| /** |
| * Allows an Interceptor to query request information and modify the |
| * service context before the request is sent to the server. |
| * <p> |
| * This interception point may throw a system exception. If it does, |
| * no other Interceptors' <code>send_request</code> operations are called. |
| * Those Interceptors on the Flow Stack are popped and their |
| * <code>receive_exception</code> interception points are called. This |
| * interception point may also throw a <code>ForwardRequest</code> |
| * exception. If an Interceptor throws this exception, no other |
| * Interceptors' <code>send_request</code> operations are |
| * called. Those Interceptors on the Flow Stack are popped and their |
| * <code>receive_other</code> interception points are called. |
| * <p> |
| * Compliant Interceptors shall properly follow completion_status |
| * semantics if they throw a system exception from this interception |
| * point. The <code>completion_status</code> shall be |
| * <code>COMPLETED_NO</code>. |
| * |
| * @param ri Information about the current request being intercepted. |
| * @exception ForwardRequest If thrown, indicates to the ORB that a |
| * retry of the request should occur with the new object given in |
| * the exception. |
| */ |
| void send_request (in ClientRequestInfo ri) raises (ForwardRequest); |
| |
| /** |
| * Allows an Interceptor to query information during a Time-Independent |
| * Invocation (TII) polling get reply sequence. |
| * <p> |
| * With TII, an application may poll for a response to a request sent |
| * previously by the polling client or some other client. This poll is |
| * reported to Interceptors through the <code>send_poll</code> |
| * interception point and the response is returned through the |
| * <code>receive_reply</code> or <code>receive_exception</code> |
| * interception points. If the response is not available before the |
| * poll time-out expires, the system exception <code>TIMEOUT</code> is |
| * thrown and <code>receive_exception</code> is called with this |
| * exception. |
| * <p> |
| * This interception point may throw a system exception. If it does, |
| * no other Interceptors' <code>send_poll</code> operations are |
| * called. Those Interceptors on the Flow Stack are popped and their |
| * <code>receive_exception</code> interception points are called. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a system |
| * exception from this interception point. The completion_status shall be |
| * <code>COMPLETED_NO</code>. |
| * |
| * @param ri Information about the current request being intercepted. |
| * @exception TIMEOUT thrown if the response is not available before |
| * the poll time-out expires |
| */ |
| void send_poll (in ClientRequestInfo ri); |
| |
| /** |
| * Allows an Interceptor to query the information on a reply after it |
| * is returned from the server and before control is returned to the |
| * client. |
| * <p> |
| * This interception point may throw a system exception. If it does, |
| * no other Interceptors' <code>receive_reply</code> operations are |
| * called. The remaining Interceptors in the Flow Stack shall have |
| * their <code>receive_exception</code> interception point called. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a system |
| * exception from this interception point. The |
| * <code>completion_status</code> shall be <code>COMPLETED_YES</code>. |
| * |
| * @param ri Information about the current request being intercepted. |
| */ |
| void receive_reply (in ClientRequestInfo ri); |
| |
| /** |
| * Indicates to the interceptor that an exception occurred. Allows |
| * an Interceptor to query the exception's information before it is |
| * thrown to the client. |
| * <p> |
| * This interception point may throw a system exception. This has the |
| * effect of changing the exception which successive Interceptors |
| * popped from the Flow Stack receive on their calls to |
| * <code>receive_exception</code>. The exception thrown to the client |
| * will be the last exception thrown by an Interceptor, or the original |
| * exception if no Interceptor changes the exception. |
| * <p> |
| * This interception point may also throw a <code>ForwardRequest</code> |
| * exception. If an Interceptor throws this exception, no other |
| * Interceptors' <code>receive_exception</code> operations are called. |
| * The remaining Interceptors in the Flow Stack are popped and have their |
| * <code>receive_other</code> interception point called. |
| * <p> |
| * If the <code>completion_status</code> of the exception is not |
| * <code>COMPLETED_NO</code>, then it is inappropriate for this |
| * interception point to throw a <code>ForwardRequest</code> exception. |
| * The request s at-most-once semantics would be lost. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a system |
| * exception from this interception point. If the original exception is |
| * a system exception, the <code>completion_status</code> of the new |
| * exception shall be the same as on the original. If the original |
| * exception is a user exception, then the <code>completion_status</code> |
| * of the new exception shall be <code>COMPLETED_YES</code>. |
| * <p> |
| * Under some conditions, depending on what policies are in effect, an |
| * exception (such as <code>COMM_FAILURE</code>) may result in a retry |
| * of the request. While this retry is a new request with respect to |
| * Interceptors, there is one point of correlation between the original |
| * request and the retry: because control has not returned to the |
| * client, the <code>PortableInterceptor.Current</code> for both the |
| * original request and the retrying request is the same. |
| * |
| * @param ri Information about the current request being intercepted. |
| * @exception ForwardRequest If thrown, indicates to the ORB that a |
| * retry of the request should occur with the new object given in |
| * the exception. |
| */ |
| void receive_exception (in ClientRequestInfo ri) raises (ForwardRequest); |
| |
| /** |
| * Allows an Interceptor to query the information available when a |
| * request results in something other than a normal reply or an |
| * exception. For example, a request could result in a retry |
| * (e.g., a GIOP Reply with a <code>LOCATION_FORWARD</code> status was |
| * received); or on asynchronous calls, the reply does not immediately |
| * follow the request, but control shall return to the client and an |
| * ending interception point shall be called. |
| * <p> |
| * For retries, depending on the policies in effect, a new request may or |
| * may not follow when a retry has been indicated. If a new request does |
| * follow, while this request is a new request, with respect to |
| * Interceptors, there is one point of correlation between the original |
| * request and the retry: because control has not returned to the client, |
| * the request scoped <code>PortableInterceptor.Current</code> for both |
| * the original request and the retrying request is the same. |
| * <p> |
| * This interception point may throw a system exception. If it does, no |
| * other Interceptors' <code>receive_other</code> operations are called. |
| * The remaining Interceptors in the Flow Stack are popped and have |
| * their <code>receive_exception</code> interception point called. |
| * <p> |
| * This interception point may also throw a <code>ForwardRequest</code> |
| * exception. If an Interceptor throws this exception, successive |
| * Interceptors' <code>receive_other</code> operations are called with |
| * the new information provided by the <code>ForwardRequest</code> |
| * exception. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a system |
| * exception from this interception point. The |
| * <code>completion_status</code> shall be <code>COMPLETED_NO</code>. |
| * If the target invocation had completed, this interception point |
| * would not be called. |
| * |
| * @param ri Information about the current request being intercepted. |
| * @exception ForwardRequest If thrown, indicates to the ORB that a |
| * retry of the request should occur with the new object given in |
| * the exception. |
| */ |
| void receive_other (in ClientRequestInfo ri) raises (ForwardRequest); |
| }; |
| |
| /** |
| * Server-side request interceptor. |
| * <p> |
| * A request Interceptor is designed to intercept the flow of a |
| * request/reply sequence through the ORB at specific points so that |
| * services can query the request information and manipulate the service |
| * contexts which are propagated between clients and servers. The primary |
| * use of request Interceptors is to enable ORB services to transfer |
| * context information between clients and servers. There are two types |
| * of request Interceptors: client-side and server-side. |
| * <p> |
| * To write a server-side Interceptor, implement the |
| * ServerRequestInterceptor interface. |
| * |
| * @see ServerRequestInfo |
| */ |
| local interface ServerRequestInterceptor : Interceptor { |
| /** |
| * Allows the interceptor to process service context information. |
| * <p> |
| * At this interception point, Interceptors must get their service |
| * context information from the incoming request transfer it to |
| * <code>PortableInterceptor.Current</code>'s slots. |
| * <p> |
| * This interception point is called before the servant manager is called. |
| * Operation parameters are not yet available at this point. This |
| * interception point may or may not execute in the same thread as |
| * the target invocation. |
| * <p> |
| * This interception point may throw a system exception. If it does, |
| * no other Interceptors' <code>receive_request_service_contexts</code> |
| * operations are called. Those Interceptors on the Flow Stack are |
| * popped and their <code>send_exception</code> interception points are |
| * called. |
| * <p> |
| * This interception point may also throw a <code>ForwardRequest</code> |
| * exception. If an Interceptor throws this exception, no other |
| * Interceptors' <code>receive_request_service_contexts</code> operations |
| * are called. Those Interceptors on the Flow Stack are popped and |
| * their <code>send_other</code> interception points are called. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a system |
| * exception from this interception point. The |
| * <code>completion_status</code> shall be COMPLETED_NO. |
| * |
| * @param ri Information about the current request being intercepted. |
| * @exception ForwardRequest If thrown, indicates to the ORB that a |
| * retry of the request should occur with the new object given in |
| * the exception. |
| */ |
| void receive_request_service_contexts (in ServerRequestInfo ri) |
| raises (ForwardRequest); |
| |
| /** |
| * Allows an Interceptor to query request information after all the |
| * information, including operation parameters, are available. This |
| * interception point shall execute in the same thread as the target |
| * invocation. |
| * <p> |
| * In the DSI model, since the parameters are first available when |
| * the user code calls <code>arguments</code>, <code>receive_request</code> |
| * is called from within <code>arguments</code>. It is possible that |
| * <code>arguments</code> is not called in the DSI model. The target |
| * may call <code>set_exception</code> before calling |
| * <code>arguments</code>. The ORB shall guarantee that |
| * <code>receive_request</code> is called once, either through |
| * <code>arguments</code> or through <code>set_exception</code>. If it |
| * is called through <code>set_exception</code>, requesting the |
| * arguments will result in <code>NO_RESOURCES</code> being thrown with |
| * a standard minor code of 1. |
| * <p> |
| * This interception point may throw a system exception. If it does, no |
| * other Interceptors' <code>receive_request</code> operations are |
| * called. Those Interceptors on the Flow Stack are popped and their |
| * <code>send_exception</code> interception points are called. |
| * <p> |
| * This interception point may also throw a <code>ForwardRequest</code> |
| * exception. If an Interceptor throws this exception, no other |
| * Interceptors' <code>receive_request</code> operations are called. |
| * Those Interceptors on the Flow Stack are popped and their |
| * <code>send_other</code> interception points are called. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a system |
| * exception from this interception point. The |
| * <code>completion_status</code> shall be <code>COMPLETED_NO</code>. |
| * |
| * @param ri Information about the current request being intercepted. |
| * @exception ForwardRequest If thrown, indicates to the ORB that a |
| * retry of the request should occur with the new object given in |
| * the exception. |
| */ |
| void receive_request (in ServerRequestInfo ri) raises (ForwardRequest); |
| |
| /** |
| * Allows an Interceptor to query reply information and modify the |
| * reply service context after the target operation has been invoked |
| * and before the reply is returned to the client. This interception |
| * point shall execute in the same thread as the target invocation. |
| * <p> |
| * This interception point may throw a system exception. If it does, |
| * no other Interceptors' <code>send_reply</code> operations are called. |
| * The remaining Interceptors in the Flow Stack shall have their |
| * <code>send_exception</code> interception point called. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a |
| * system exception from this interception point. The |
| * <code>completion_status</code> shall be <code>COMPLETED_YES</code>. |
| * |
| * @param ri Information about the current request being intercepted. |
| */ |
| void send_reply (in ServerRequestInfo ri); |
| |
| /** |
| * Allows an Interceptor to query the exception information and modify |
| * the reply service context before the exception is thrown to the client. |
| * When an exception occurs, this interception point is called. This |
| * interception point shall execute in the same thread as the target |
| * invocation. |
| * <p> |
| * This interception point may throw a system exception. This has the |
| * effect of changing the exception which successive Interceptors |
| * popped from the Flow Stack receive on their calls to |
| * <code>send_exception</code>. The exception thrown to the client will |
| * be the last exception thrown by an Interceptor, or the original |
| * exception if no Interceptor changes the exception. |
| * <p> |
| * This interception point may also throw a <code>ForwardRequest</code> |
| * exception. If an Interceptor throws this exception, no other |
| * Interceptors' <code>send_exception</code> operations are called. The |
| * remaining Interceptors in the Flow Stack shall have their |
| * <code>send_other</code> interception points called. |
| * <p> |
| * If the <code>completion_status</code> of the exception is not |
| * <code>COMPLETED_NO</code>, then it is inappropriate for this |
| * interception point to throw a <code>ForwardRequest</code> exception. |
| * The request's at-most-once semantics would be lost. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a system |
| * exception from this interception point. If the original exception |
| * is a system exception, the <code>completion_status</code> of the new |
| * exception shall be the same as on the original. If the original |
| * exception is a user exception, then the <code>completion_status</code> |
| * of the new exception shall be <code>COMPLETED_YES</code>. |
| * |
| * @param ri Information about the current request being intercepted. |
| * @exception ForwardRequest If thrown, indicates to the ORB that a |
| * retry of the request should occur with the new object given in |
| * the exception. |
| */ |
| void send_exception (in ServerRequestInfo ri) raises (ForwardRequest); |
| |
| /** |
| * Allows an Interceptor to query the information available when a |
| * request results in something other than a normal reply or an |
| * exception. For example, a request could result in a retry |
| * (e.g., a GIOP Reply with a <code>LOCATION_FORWARD</code> status was |
| * received). This interception point shall execute in the same thread |
| * as the target invocation. |
| * <p> |
| * This interception point may throw a system exception. If it does, |
| * no other Interceptors' <code>send_other</code> operations are called. |
| * The remaining Interceptors in the Flow Stack shall have their |
| * <code>send_exception</code> interception points called. |
| * <p> |
| * This interception point may also throw a <code>ForwardRequest</code> |
| * exception. If an Interceptor throws this exception, successive |
| * Interceptors' <code>send_other</code> operations are called with |
| * the new information provided by the <code>ForwardRequest</code> |
| * exception. |
| * <p> |
| * Compliant Interceptors shall properly follow |
| * <code>completion_status</code> semantics if they throw a system |
| * exception from this interception point. The |
| * <code>completion_status</code> shall be <code>COMPLETED_NO</code>. |
| * |
| * @param ri Information about the current request being intercepted. |
| * @exception ForwardRequest If thrown, indicates to the ORB that a |
| * retry of the request should occur with the new object given in |
| * the exception. |
| */ |
| void send_other (in ServerRequestInfo ri) raises (ForwardRequest); |
| }; |
| |
| /** The object reference factory. This provides the capability of |
| * creating an object reference. |
| */ |
| abstract valuetype ObjectReferenceFactory { |
| /** make_object creates a CORBA object reference according |
| * to the data in this template, with the given repository ID and |
| * object ID. |
| */ |
| Object make_object( in string repositoryId, in ObjectId object_id ) ; |
| } ; |
| |
| /** The object reference template. An instance of this must |
| * exist for each object adapter created in an ORB. The server_id, |
| * orb_id, and adapter_name attributes uniquely identify this template |
| * within the scope of an IMR. Note that adapter_id is similarly unique |
| * within the same scope, but it is opaque, and less useful in many |
| * cases. |
| */ |
| abstract valuetype ObjectReferenceTemplate : ObjectReferenceFactory { |
| |
| readonly attribute ServerId server_id ; |
| |
| readonly attribute ORBId orb_id ; |
| |
| readonly attribute AdapterName adapter_name ; |
| } ; |
| |
| /** Sequence of object reference templates is used for reporting state |
| * changes that do not occur on the adapter manager. |
| */ |
| typedef sequence<ObjectReferenceTemplate> ObjectReferenceTemplateSeq ; |
| |
| /** Adapter manager identifier. Every object adapter has an adapter manager, |
| * indicated in this API only through the ID. A group of object adapter |
| * instances may share the same adapter manager, in which case state transitions |
| * reported for the adapter manager are observed by all object adapters with the |
| * same adapter manager ID. |
| */ |
| typedef long AdapterManagerId ; |
| |
| /** Type of object adapter state. State changes are reported either to |
| * the object adapter or to the adapter manager. |
| */ |
| typedef short AdapterState ; |
| |
| /** Object adapter state that holds requests temporarily until the |
| * state is changed. |
| */ |
| const AdapterState HOLDING = 0 ; |
| |
| /** Object adapter state that indicates normal request processing. |
| */ |
| const AdapterState ACTIVE = 1 ; |
| |
| /** Object adapter state that causes all requests to be discarded. |
| */ |
| const AdapterState DISCARDING = 2 ; |
| |
| /** Object adapter state that causes all requests to be discarded. |
| * This state indicates that the adapter is shutting down. |
| */ |
| const AdapterState INACTIVE = 3 ; |
| |
| /** Object adapter state indicating that the adapter has been destroyed. |
| */ |
| const AdapterState NON_EXISTENT = 4 ; |
| |
| /** |
| * Provides the server-side ORB service with access to the applicable |
| * policies during IOR construction and the ability to add components. |
| * The ORB passes an instance of its implementation of this interface as |
| * a parameter to <code>IORInterceptor.establish_components</code>. |
| * |
| * @see IORInterceptor |
| */ |
| local interface IORInfo { |
| |
| /** |
| * Allows an ORB service implementation to determine what server side |
| * policy of a particular type is in effect for an IOR being |
| * constructed. When the IOR being constructed is for an object |
| * implemented using a POA, all Policy objects passed to the |
| * <code>PortableServer.POA.create_POA</code> call that created that |
| * POA are accessable via <code>get_effective_policy</code>. |
| * <p> |
| * If a policy for the given type is not known to the ORB, then this |
| * operation will throw <code>INV_POLICY</code> with a standard minor |
| * code of 2. |
| * |
| * @param type an int specifying the type of policy to return. |
| * @return The effective <code>CORBA.Policy</code> object of the |
| * requested type. If the given policy type is known, but no policy |
| * of that type is in effect, then this operation will return a |
| * nil object reference. |
| */ |
| CORBA::Policy get_effective_policy |
| (in CORBA::PolicyType type); |
| |
| /** |
| * A portable ORB service implementation calls |
| * <code>add_ior_component</code> from its implementation of |
| * <code>establish_components</code> to add a tagged component to the |
| * set which will be included when constructing IORs. The components in |
| * this set will be included in all profiles. |
| * <p> |
| * Any number of components may exist with the same component ID. |
| * |
| * @param tagged_component The IOP.TaggedComponent to add. |
| */ |
| void add_ior_component |
| (in IOP::TaggedComponent tagged_component); |
| |
| /** |
| * A portable ORB service implementation calls |
| * <code>add_ior_component_to_profile</code> from its implementation of |
| * <code>establish_components</code> to add a tagged component to the |
| * set which will be included when constructing IORs. The components in |
| * this set will be included in the specified profile. |
| * <p> |
| * Any number of components may exist with the same component ID. |
| * |
| * @param tagged_component The <code>IOP.TaggedComponent</code> to add. |
| * @param profile_id The profile id of the profile to |
| * which this component will be added. |
| * @exception BAD_PARAM thrown, with a standard minor code of 29, if the |
| * given profile ID does not define a known profile or it is |
| * impossible to add components to that profile. |
| */ |
| void add_ior_component_to_profile ( |
| in IOP::TaggedComponent tagged_component, |
| in IOP::ProfileId profile_id); |
| |
| /** Return the adapter manager id of the object adapter |
| * that was just created and is running IOR interceptors. |
| */ |
| readonly attribute AdapterManagerId manager_id ; |
| |
| /** Return the adapter state of the object adapter |
| * that was just created and is running IOR interceptors. |
| */ |
| readonly attribute AdapterState state ; |
| |
| /** Return the object reference template of the object adapter |
| * that was just created and is running IOR interceptors. |
| */ |
| readonly attribute ObjectReferenceTemplate adapter_template ; |
| |
| /** On read, returns the current factory that will be used to create |
| * object references for the object adapter that was just created |
| * and is running IOR interceptors. By default, this factory is the same |
| * as the value of the adapter_template attribute. The current_factory |
| * may also be set to another object reference template inside an |
| * IORInterceptor_3_0. |
| */ |
| attribute ObjectReferenceFactory current_factory ; |
| }; |
| |
| /** |
| * Interceptor used to establish tagged components in the profiles within |
| * an IOR. |
| * <p> |
| * In some cases, a portable ORB service implementation may need to add |
| * information describing the server's or object's ORB service related |
| * capabilities to object references in order to enable the ORB service |
| * implementation in the client to function properly. |
| * <p> |
| * This is supported through the <code>IORInterceptor</code> and |
| * <code>IORInfo</code> interfaces. |
| * |
| * @see IORInfo |
| */ |
| local interface IORInterceptor : Interceptor { |
| /** |
| * A server side ORB calls the <code>establish_components</code> |
| * operation on all registered <code>IORInterceptor</code> instances |
| * when it is assembling the list of components that will be included |
| * in the profile or profiles of an object reference. This operation |
| * is not necessarily called for each individual object reference. |
| * In the case of the POA, this operation is called each time POA::create_POA |
| * is called. In any case, <code>establish_components</code> is |
| * guaranteed to be called at least once for each distinct set of |
| * server policies. |
| * <p> |
| * An implementation of <code>establish_components</code> must not |
| * throw exceptions. If it does, the ORB shall ignore the exception |
| * and proceed to call the next IOR Interceptor's |
| * <code>establish_components</code> operation. |
| * |
| * @param info The <code>IORInfo</code> instance used by the ORB |
| * service to query applicable policies and add components to be |
| * included in the generated IORs. |
| */ |
| void establish_components (in IORInfo info); |
| }; |
| |
| local interface IORInterceptor_3_0 : IORInterceptor { |
| /** The components_established method is invoked on all registered |
| * IORInterceptor_3_0 instances after establish_components |
| * has been invoked on all registered IORInterceptor instances. |
| * The adapter_template is available in info during this call. |
| * The current_factory may be get or set in info during this call. |
| * <p> |
| * Any exception thrown from this method is handled by the Object |
| * Adapter that called this interceptor. In the case of the POA, |
| * an exception results in a OBJ_ADAPTER exception with an OMG |
| * standard minor code of 6. |
| * @param info The IORInfo for the object adapter being created. |
| */ |
| void components_established( in IORInfo info ) ; |
| |
| /** Called whenever the state of an adapter manager changes. |
| * For the POA, that is the POAManager. If the state change |
| * is reported through <code>adapter_manager_state_changed</code>, |
| * it is not reported through <code>adapter_state_changed</code>. |
| * @param id the adapter manager id of the adapter manager that |
| * changed state |
| * @param state the new state of the adapter manager |
| */ |
| void adapter_manager_state_changed( in AdapterManagerId id, |
| in AdapterState state ) ; |
| |
| /** Called whenever the state of an object adapter changes, and |
| * the state change is not caused by an adapter manager. Such |
| * changes are reported to all registered <code>IORInterceptor_3_0</code> |
| * instances. |
| * @param templates the sequence of <code>ObjectReferenceTemplate</code> instances |
| * on which this state change occurred. |
| * @param state the new <code>AdapterState</code> shared by all of the templates. |
| */ |
| void adapter_state_changed( in ObjectReferenceTemplateSeq templates, |
| in AdapterState state ) ; |
| }; |
| |
| /** |
| * Enables policy types to be constructed using |
| * <code>CORBA.ORB.create_policy</code>. |
| * <p> |
| * A portable ORB service implementation registers an instance of the |
| * <code>PolicyFactory</code> interface during ORB initialization in order |
| * to enable its policy types to be constructed using |
| * <code>CORBA.ORB.create_policy</code>. The POA is required to preserve |
| * any policy which is registered with <code>ORBInitInfo</code> in this |
| * manner. |
| * |
| * @see ORBInitInfo#register_policy_factory |
| */ |
| local interface PolicyFactory |
| { |
| /** |
| * Returns an instance of the appropriate interface derived from |
| * <code>CORBA.Policy</code> whose value corresponds to the |
| * specified any. |
| * <p> |
| * The ORB calls <code>create_policy</code> on a registered |
| * <code>PolicyFactory</code> instance when |
| * <code>CORBA.ORB.create_policy</code> is called for the |
| * <code>PolicyType</code> under which the <code>PolicyFactory</code> has |
| * been registered. The <code>create_policy</code> operation then |
| * returns an instance of the appropriate interface derived from |
| * <code>CORBA.Policy</code> whose value corresponds to the specified |
| * any. If it cannot, it shall throw an exception as described for |
| * <code>CORBA.ORB.create_policy</code>. |
| * |
| * @param type An int specifying the type of policy being created. |
| * @param value An any containing data with which to construct the |
| * <code>CORBA.Policy</code>. |
| * @return A <code>CORBA.Policy<code> object of the specified type and |
| * value. |
| */ |
| CORBA::Policy create_policy |
| (in CORBA::PolicyType type, in any value) |
| raises (CORBA::PolicyError); |
| }; |
| |
| /** |
| * Passed to each <code>ORBInitializer</code>, allowing it to |
| * to register interceptors and perform other duties while the ORB is |
| * initializing. |
| * <p> |
| * The <code>ORBInitInfo</code> object is only valid during |
| * <code>ORB.init</code>. If a service keeps a reference to its |
| * <code>ORBInitInfo</code> object and tries to use it after |
| * <code>ORB.init</code> returns, the object no longer exists and an |
| * <code>OBJECT_NOT_EXIST</code> exception shall be thrown. |
| * |
| * @see ORBInitializer |
| */ |
| local interface ORBInitInfo { |
| |
| /** Object id, represented as a String */ |
| typedef string ObjectId; |
| |
| /** |
| * Only one Interceptor of a given name can be registered with the |
| * ORB for each Interceptor type. If an attempt is made to register a |
| * second Interceptor with the same name, DuplicateName is thrown. |
| * <p> |
| * An Interceptor may be anonymous, i.e., have an empty string as the |
| * name attribute. Any number of anonymous Interceptors may be |
| * registered with the ORB so, if the Interceptor being registered |
| * is anonymous, the registration operation will not throw |
| * <code>DuplicateName</code>. |
| */ |
| exception DuplicateName { |
| /** |
| * The name for which there was already an interceptor registered. |
| */ |
| string name; |
| }; |
| |
| /** |
| * This exception is thrown by |
| * <code>register_initial_reference</code> and |
| * <code>resolve_initial_references</code>. |
| * <code>register_initial_reference</code> throws <code>InvalidName</code> |
| * if: |
| * <ul> |
| * <li>this operation is called with an empty string id; or</li> |
| * <li>this operation is called with an id that is already registered, |
| * including the default names defined by OMG.</li> |
| * </ul> |
| * <code>resolve_initial_references</code> throws |
| * <code>InvalidName</code> if the name to be resolved is invalid. |
| */ |
| exception InvalidName {}; |
| |
| /** |
| * Returns the arguments passed to <code>ORB.init</code>. They may or |
| * may not contain the ORB's arguments. |
| */ |
| readonly attribute CORBA::StringSeq arguments; |
| |
| /** |
| * Returns the ID of the ORB being initialized. |
| */ |
| readonly attribute string orb_id; |
| |
| /** |
| * Returns the <code>IOP.CodecFactory</code>. The |
| * <code>CodecFactory</code> is normally obtained via a call to |
| * <code>ORB.resolve_initial_references( "CodecFactory" )</code>, but |
| * since the ORB is not yet available and Interceptors, particularly when |
| * processing service contexts, will require a <code>Codec</code>, a |
| * means of obtaining a <code>Codec</code> is necessary during ORB |
| * initialization. |
| */ |
| readonly attribute IOP::CodecFactory codec_factory; |
| |
| /** |
| * Identical to <code>ORB.register_initial_reference</code>. This same |
| * functionality exists here because the ORB, not yet fully initialized, |
| * is not yet available but initial references may need to be |
| * registered as part of Interceptor registration. The only difference |
| * is that the version of this operation on the ORB uses PIDL |
| * (<code>CORBA.ORB.ObjectId</code>) and |
| * (<code>CORBA.ORB.InvalidName</code>) whereas the version in this |
| * interface uses IDL defined in this interface; the semantics are |
| * identical. |
| */ |
| void register_initial_reference (in ObjectId id, in Object obj) |
| raises (InvalidName); |
| |
| // This was incorrectly returning void in orbos/99-12-02, correction |
| // from errata in orbos/00-01-01 |
| /** |
| * Identical to <code>ORB.resolve_initial_references</code>. This same |
| * functionality exists here because the ORB, not yet fully initialized, |
| * is not yet available but initial references may be required from the |
| * ORB as part of Interceptor registration. The only difference is that |
| * the version of this operation on the ORB uses PIDL |
| * (<code>CORBA::ORB::ObjectId</code> and |
| * <code>CORBA::ORB::InvalidName</code>) whereas the version in this |
| * interface uses IDL defined in this interface; the semantics |
| * are identical. |
| * <p> |
| * This operation is only valid during post_init. |
| */ |
| Object resolve_initial_references (in ObjectId id) raises (InvalidName); |
| |
| /** |
| * Used to add a client-side request Interceptor to the list of |
| * client-side request Interceptors. |
| * |
| * @param interceptor The <code>ClientRequestInterceptor</code> to be |
| * added. |
| * @exception DuplicateName thrown if a client-side request Interceptor |
| * has already been registered with this Interceptor's name. |
| */ |
| void add_client_request_interceptor |
| (in ClientRequestInterceptor interceptor) |
| raises (DuplicateName); |
| |
| /** |
| * Used to add a server-side request Interceptor to the list of |
| * server-side request Interceptors. |
| * |
| * @param interceptor The ServerRequestInterceptor to be added. |
| * @exception DuplicateName thrown if a server-side request Interceptor |
| * has already been registered with this Interceptor's name |
| */ |
| void add_server_request_interceptor ( |
| in ServerRequestInterceptor interceptor) |
| raises (DuplicateName); |
| |
| /** |
| * Used to add an IOR Interceptor to the list of IOR Interceptors. |
| * |
| * @param interceptor The IORInterceptor to be added. |
| * @exception DuplicateName thrown if an IOR Interceptor has already |
| * been registered with this Interceptor's name. |
| */ |
| void add_ior_interceptor (in IORInterceptor interceptor) |
| raises (DuplicateName); |
| |
| /** |
| * Called to allocate a slot on <code>PortableInterceptor.Current</code>. |
| * <p> |
| * Note that while slot id's can be allocated within an ORB initializer, |
| * the slots themselves cannot be initialized. |
| * |
| * @return The index to the slot which has been allocated. |
| * @exception BAD_INV_ORDER thrown, with a standard minor code of 14, if |
| * <code>set_slot</code> or <code>get_slot</code> is called on the |
| * <code>PICurrent</code> within an ORB initializer. |
| * @see Current |
| */ |
| SlotId allocate_slot_id (); |
| |
| /** |
| * Registers a <code>PolicyFactory</code> for the given |
| * <code>PolicyType</code>. |
| * |
| * @param type The policy type that the given <code>PolicyFactory</code> |
| * serves. |
| * @param policy_factory The factory for the given policy type. |
| * @exception BAD_INV_ORDER thrown, with a standard minor code of 16, if |
| * a <code>PolicyFactory</code> already exists for the given |
| * <code>PolicyType</code>. |
| */ |
| void register_policy_factory ( |
| in CORBA::PolicyType type, |
| in PolicyFactory policy_factory); |
| }; |
| |
| /** |
| * Facilitates interceptor registration and ORB initialization. |
| * <p> |
| * Interceptors are intended to be a means by which ORB services gain |
| * access to ORB processing, effectively becoming part of the ORB. |
| * Since Interceptors are part of the ORB, when <code>ORB.init</code> |
| * returns an ORB, the Interceptors shall have been registered. |
| * Interceptors cannot be registered on an ORB after it has been |
| * returned by a call to <code>ORB.init</code>. |
| * <p> |
| * An Interceptor is registered by registering an associated |
| * <code>ORBInitializer</code> object which implements the |
| * <code>ORBInitializer</code> interface. When an ORB is initializing, |
| * it shall call each registered <code>ORBInitializer</code>, passing it |
| * an <code>ORBInitInfo</code> object which is used to register its |
| * Interceptor. |
| * <p> |
| * <b>Registering ORB Initializers in Java</b> |
| * <p> |
| * ORBInitializers are registered via Java ORB properties. |
| * <p> |
| * The property names are of the form: |
| * <blockquote><code> |
| * org.omg.PortableInterceptor.ORBInitializerClass.<Service> |
| * </code></blockquote> |
| * where <code><Service></code> is the string name of a class |
| * which implements |
| * <blockquote><code> |
| * org.omg.PortableInterceptor.ORBInitializer |
| * </code></blockquote> |
| * To avoid name collisions, the reverse DNS name convention should be |
| * used. For example, if company X has three initializers, it could define |
| * the following properties: |
| * <ul> |
| * <li><code> |
| * org.omg.PortableInterceptor.ORBInitializerClass.com.x.Init1 |
| * </code></li> |
| * <li><code> |
| * org.omg.PortableInterceptor.ORBInitializerClass.com.x.Init2 |
| * </code></li> |
| * <li><code> |
| * org.omg.PortableInterceptor.ORBInitializerClass.com.x.Init3 |
| * </code></li> |
| * </ul> |
| * During ORB.init, these ORB properties which begin with |
| * <code>org.omg.PortableInterceptor.ORBInitializerClass</code> shall be |
| * collected, the <code><Service></code> portion of each property |
| * shall be extracted, an object shall be instantiated with the |
| * <code><Service></code> string as its class name, and the |
| * <code>pre_init</code> and <code>post_init</code> methods shall be |
| * called on that object. If there are any exceptions, the ORB shall |
| * ignore them and proceed. |
| * <p> |
| * <b><i>Example</i></b> |
| * <p> |
| * A client-side logging service written by company X, for example, may |
| * have the following ORBInitializer implementation: |
| * <code><pre> |
| * package com.x.logging; |
| * |
| * import org.omg.PortableInterceptor.Interceptor; |
| * import org.omg.PortableInterceptor.ORBInitializer; |
| * import org.omg.PortableInterceptor.ORBInitInfo; |
| * |
| * public class LoggingService implements ORBInitializer { |
| * void pre_init( ORBInitInfo info ) { |
| * // Instantiate the Logging Service s Interceptor. |
| * Interceptor interceptor = new LoggingInterceptor(); |
| * |
| * // Register the Logging Service s Interceptor. |
| * info.add_client_request_interceptor( interceptor ); |
| * } |
| * |
| * void post_init( ORBInitInfo info ) { |
| * // This service does not need two init points. |
| * } |
| * } |
| * </pre></code> |
| * To run a program called <code>MyApp</code> using this logging |
| * service, the user could type: |
| * <blockquote><code> |
| * java |
| *-Dorg.omg.PortableInterceptor.ORBInitializerClass.com.x.Logging.LoggingService |
| * MyApp |
| * </code></blockquote> |
| * <p> |
| * <b>Notes about Registering Interceptors</b> |
| * <p> |
| * Request Interceptors are registered on a per-ORB basis. |
| * <p> |
| * To achieve virtual per-object Interceptors, query the policies on the |
| * target from within the interception points to determine whether they |
| * should do any work. |
| * <p> |
| * To achieve virtual per-POA Interceptors, instantiate each POA with a |
| * different ORB. While Interceptors may be ordered administratively, |
| * there is no concept of order with respect to the registration of |
| * Interceptors. Request Interceptors are concerned with service contexts. |
| * Service contexts have no order, so there is no purpose for request |
| * Interceptors to have an order. IOR Interceptors are concerned with |
| * tagged components. Tagged components also have no order, so there |
| * is no purpose for IOR Interceptors to have an order. |
| * <p> |
| * Registration code should avoid using the ORB (i.e., calling |
| * <code>ORB.init</code> with the provided <code>orb_id</code>). Since |
| * registration occurs during ORB initialization, results of invocations |
| * on this ORB while it is in this state are undefined. |
| * |
| * @see ORBInitInfo |
| */ |
| local interface ORBInitializer { |
| |
| /** |
| * Called during ORB initialization. If it is expected that initial |
| * services registered by an interceptor will be used by other |
| * interceptors, then those initial services shall be registered at |
| * this point via calls to |
| * <code>ORBInitInfo.register_initial_reference</code>. |
| * |
| * @param info provides initialization attributes and operations by |
| * which Interceptors can be registered. |
| */ |
| void pre_init (in ORBInitInfo info); |
| |
| /** |
| * Called during ORB initialization. If a service must resolve initial |
| * references as part of its initialization, it can assume that all |
| * initial references will be available at this point. |
| * <p> |
| * Calling the <code>post_init</code> operations is not the final |
| * task of ORB initialization. The final task, following the |
| * <code>post_init</code> calls, is attaching the lists of registered |
| * interceptors to the ORB. Therefore, the ORB does not contain the |
| * interceptors during calls to <code>post_init</code>. If an |
| * ORB-mediated call is made from within <code>post_init</code>, no |
| * request interceptors will be invoked on that call. |
| * Likewise, if an operation is performed which causes an IOR to be |
| * created, no IOR interceptors will be invoked. |
| * |
| * @param info provides initialization attributes and |
| * operations by which Interceptors can be registered. |
| */ |
| void post_init (in ORBInitInfo info); |
| }; |
| }; |