RequestInfoOperations (Java Platform SE 8 )
Keywords: org.omg.PortableInterceptor.RequestInfoOperations interface
Date: 2026-06-25

org.omg.PortableInterceptor

## Interface RequestInfoOperations

- All Known Subinterfaces:
    ClientRequestInfo, ClientRequestInfoOperations, RequestInfo, ServerRequestInfo, ServerRequestInfoOperations

      public interface RequestInfoOperations

  Request Information, accessible to Interceptors.

  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: `ClientRequestInfo` is passed to the client-side interception points and `ServerRequestInfo` 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: `RequestInfo`.

  See Also:
    `ClientRequestInfo`, `ServerRequestInfo`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `Parameter[]` | `arguments()` Returns an array of `Parameter` objects, containing the arguments on the operation being invoked.
    `String[]` | `contexts()` Returns an array of `String` objects describing the contexts that may be passed on this operation invocation.
    `TypeCode[]` | `exceptions()` Returns an array of `TypeCode` objects describing the `TypeCode`s of the user exceptions that this operation invocation may throw.
    `Object` | `forward_reference()` Contains the object to which the request will be forwarded, if the `reply_status` attribute is `LOCATION_FORWARD`.
    `ServiceContext` | `get_reply_service_context(int id)` Returns a copy of the service context with the given ID that is associated with the reply.
    `ServiceContext` | `get_request_service_context(int id)` Returns a copy of the service context with the given ID that is associated with the request.
    `Any` | `get_slot(int id)` Returns the data from the given slot of the `PortableInterceptor.Current` that is in the scope of the request.
    `String[]` | `operation_context()` Returns an array of `String` objects containing the contexts being sent on the request.
    `String` | `operation()` Returns the name of the operation being invoked.
    `short` | `reply_status()` Describes the state of the result of the operation invocation.
    `int` | `request_id()` Returns an id that uniquely identifies an active request/reply sequence.
    `boolean` | `response_expected()` Indicates whether a response is expected.
    `Any` | `result()` Returns an any containing the result of the operation invocation.
    `short` | `sync_scope()` Defines how far the request shall progress before control is returned to the client.

- - ### Method Detail

    - #### request_id

          int request_id()

      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 `request_id`. If GIOP is the transport mechanism used, then these IDs may very well be the same, but this is not guaranteed nor required.

    - #### operation

          String operation()

      Returns the name of the operation being invoked.

    - #### arguments

          Parameter[] arguments()

      Returns an array of `Parameter` objects, containing the arguments on the operation being invoked. If there are no arguments, this attribute will be a zero length array.

      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, `NO_RESOURCES` will be thrown with a standard minor code of 1.

      Note: Arguments are available for DSI/DII calls.

      Throws:
        `NO_RESOURCES` - thrown if arguments are not available.
      See Also:
        `PortableInterceptor` package comments for limitations / unimplemented features

    - #### exceptions

          TypeCode[] exceptions()

      Returns an array of `TypeCode` objects describing the `TypeCode`s of the user exceptions that this operation invocation may throw. If there are no user exceptions, this will return a zero length array.

      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, `NO_RESOURCES` will be thrown with a standard minor code of 1.

      Note: Exceptions are available for DSI/DII calls.

      Throws:
        `NO_RESOURCES` - thrown if exceptions are not available.
      See Also:
        `PortableInterceptor` package comments for limitations / unimplemented features

    - #### contexts

          String[] contexts()

      Returns an array of `String` objects describing the contexts that may be passed on this operation invocation. If there are no contexts, this will return a zero length array.

      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, `NO_RESOURCES` will be thrown with a standard minor code of 1.

      Note: Contexts are available for DSI/DII calls.

      Throws:
        `NO_RESOURCES` - thrown if contexts are not available.
      See Also:
        `PortableInterceptor` package comments for limitations / unimplemented features

    - #### operation_context

          String[] operation_context()

      Returns an array of `String` objects containing the contexts being sent on the request.

      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.

      Note: `operation_context` is available for DSI/DII calls.

      Throws:
        `NO_RESOURCES` - thrown if operation context is not available.
      See Also:
        `PortableInterceptor` package comments for limitations / unimplemented features

    - #### result

          Any result()

      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 `TCKind` value of `tk_void` and no value.

      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, `NO_RESOURCES` will be thrown with a standard minor code of 1.

      Note: Result is available for DSI/DII calls.

      Throws:
        `NO_RESOURCES` - thrown if result is not available.
      See Also:
        `PortableInterceptor` package comments for limitations / unimplemented features

    - #### response_expected

          boolean response_expected()

      Indicates whether a response is expected.

      On the client, a reply is not returned when `response_expected` is false, so `receive_reply` cannot be called. `receive_other` is called unless an exception occurs, in which case `receive_exception` is called.

      On the client, within `send_poll`, this attribute is true.

    - #### sync_scope

          short sync_scope()

      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 `response_expected` is false. If `response_expected` is true, the value of `sync_scope` is undefined. This attribute may have one of the following values:
      - `Messaging.SYNC_NONE`
      - `Messaging.SYNC_WITH_TRANSPORT`
      - `Messaging.SYNC_WITH_SERVER`
      - `Messaging.SYNC_WITH_TARGET`
      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., `receive_request_service_contexts`, `receive_request`, `send_reply` or `send_exception`).

      For `SYNC_WITH_SERVER` and `SYNC_WITH_TARGET`, 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 Also:
        `PortableInterceptor` package comments for limitations / unimplemented features

    - #### reply_status

          short reply_status()

      Describes the state of the result of the operation invocation. The return value can be one of the following:
      - `PortableInterceptor.SUCCESSFUL`
      - `PortableInterceptor.SYSTEM_EXCEPTION`
      - `PortableInterceptor.USER_EXCEPTION`
      - `PortableInterceptor.LOCATION_FORWARD`
      - `PortableInterceptor.TRANSPORT_RETRY`
      On the client:
      - Within the `receive_reply` interception point, this will only return `SUCCESSFUL`
      .
      - Within the `receive_exception` interception point, this will be either `SYSTEM_EXCEPTION` or `USER_EXCEPTION`.
      - Within the `receive_other` interception point, this will be any of: `SUCCESSFUL`, `LOCATION_FORWARD`, or `TRANSPORT_RETRY`. `SUCCESSFUL` means an asynchronous request returned successfully. `LOCATION_FORWARD` means that a reply came back with `LOCATION_FORWARD` as its status. `TRANSPORT_RETRY` means that the transport mechanism indicated a retry - a GIOP reply with a status of `NEEDS_ADDRESSING_MODE`, for instance.
      On the server:
      - Within the `send_reply` interception point, this will only be `SUCCESSFUL`.
      - Within the `send_exception` interception point, this will be either `SYSTEM_EXCEPTION` or `USER_EXCEPTION`.
      - Within the `send_other` interception point, this attribute will be any of: `SUCCESSFUL`, or `LOCATION_FORWARD`. `SUCCESSFUL` means an asynchronous request returned successfully. `LOCATION_FORWARD` means that a reply came back with `LOCATION_FORWARD` as its status.
      See Also:
        `SUCCESSFUL`, `SYSTEM_EXCEPTION`, `USER_EXCEPTION`, `LOCATION_FORWARD`, `TRANSPORT_RETRY`

    - #### forward_reference

          Object forward_reference()

      Contains the object to which the request will be forwarded, if the `reply_status` attribute is `LOCATION_FORWARD`. It is indeterminate whether a forwarded request will actually occur.

    - #### get_slot

          Any get_slot(int id)
                throws InvalidSlot

      Returns the data from the given slot of the `PortableInterceptor.Current` that is in the scope of the request.

      If the given slot has not been set, then an any containing a type code with a `TCKind` value of `tk_null` is returned.

      Parameters:
        `id` - The `SlotId` of the slot which is to be returned.
      Returns:
        The slot data, in the form of an any, obtained with the given identifier.
      Throws:
        `InvalidSlot` - thrown if the ID does not define an allocated slot.
      See Also:
        `Current`

    - #### get_request_service_context

          ServiceContext get_request_service_context(int id)

      Returns a copy of the service context with the given ID that is associated with the request.

      Parameters:
        `id` - The `IOP.ServiceId` of the service context which is to be returned.
      Returns:
        The `IOP.ServiceContext` obtained with the given identifier.
      Throws:
        `BAD_PARAM` - thrown with a standard minor code of 26, if the request's service context does not contain an entry for that ID.

    - #### get_reply_service_context

          ServiceContext get_reply_service_context(int id)

      Returns a copy of the service context with the given ID that is associated with the reply.
      Parameters:
        `id` - The `IOP.ServiceId` of the service context which is to be returned.
      Returns:
        The `IOP.ServiceContext` obtained with the given identifier.
      Throws:
        `BAD_PARAM` - thrown with a standard minor code of 26 if the request's service context does not contain an entry for that ID.

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2026, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.