ORB (Java Platform SE 8 )
Keywords: org.omg.CORBA.ORB class
Date: 2016-12-09

org.omg.CORBA

## Class ORB

- java.lang.Object
- - org.omg.CORBA.ORB

- Direct Known Subclasses:
    ORB

      public abstract class ORB
      extends Object

  A class providing APIs for the CORBA Object Request Broker features. The `ORB` class also provides "pluggable ORB implementation" APIs that allow another vendor's ORB implementation to be used.

  An ORB makes it possible for CORBA objects to communicate with each other by connecting objects making requests (clients) with objects servicing requests (servers).

  The `ORB` class, which encapsulates generic CORBA functionality, does the following: (Note that items 5 and 6, which include most of the methods in the class `ORB`, are typically used with the `Dynamic Invocation Interface` (DII) and the `Dynamic Skeleton Interface` (DSI). These interfaces may be used by a developer directly, but most commonly they are used by the ORB internally and are not seen by the general programmer.)

  1. initializes the ORB implementation by supplying values for predefined properties and environmental parameters
  2. obtains initial object references to services such as the NameService using the method `resolve_initial_references`
  3. converts object references to strings and back
  4. connects the ORB to a servant (an instance of a CORBA object implementation) and disconnects the ORB from a servant
  5. creates objects such as
     - `TypeCode`
     - `Any`
     - `NamedValue`
     - `Context`
     - `Environment`
     - lists (such as `NVList`) containing these objects
  6. sends multiple messages in the DII

  The `ORB` class can be used to obtain references to objects implemented anywhere on the network.

  An application or applet gains access to the CORBA environment by initializing itself into an `ORB` using one of three `init` methods. Two of the three methods use the properties (associations of a name with a value) shown in the table below.

  Property Name | Property Value
  --- | ---
  Standard Java CORBA Properties:
  org.omg.CORBA.ORBClass | class name of an ORB implementation
  org.omg.CORBA.ORBSingletonClass | class name of the ORB returned by `init()`

  These properties allow a different vendor's `ORB` implementation to be "plugged in."

  When an ORB instance is being created, the class name of the ORB implementation is located using the following standard search order:

  1. check in Applet parameter or application string array, if any
  2. check in properties parameter, if any
  3. check in the System properties
  4. check in the orb.properties file located in the user.home directory (if any)
  5. check in the orb.properties file located in the java.home/lib directory (if any)
  6. fall back on a hardcoded default behavior (use the Java IDL implementation)

  Note that Java IDL provides a default implementation for the fully-functional ORB and for the Singleton ORB. When the method `init` is given no parameters, the default Singleton ORB is returned. When the method `init` is given parameters but no ORB class is specified, the Java IDL ORB implementation is returned.

  The following code fragment creates an `ORB` object initialized with the default ORB Singleton. This ORB has a restricted implementation to prevent malicious applets from doing anything beyond creating typecodes. It is called a singleton because there is only one instance for an entire virtual machine.

          ORB orb = ORB.init();

  The following code fragment creates an `ORB` object for an application. The parameter `args` represents the arguments supplied to the application's `main` method. Since the property specifies the ORB class to be "SomeORBImplementation", the new ORB will be initialized with that ORB implementation. If p had been null, and the arguments had not specified an ORB class, the new ORB would have been initialized with the default Java IDL implementation.

          Properties p = new Properties();
          p.put("org.omg.CORBA.ORBClass", "SomeORBImplementation");
          ORB orb = ORB.init(args, p);

  The following code fragment creates an `ORB` object for the applet supplied as the first parameter. If the given applet does not specify an ORB class, the new ORB will be initialized with the default Java IDL implementation.

          ORB orb = ORB.init(myApplet, null);

  An application or applet can be initialized in one or more ORBs. ORB initialization is a bootstrap call into the CORBA world.

  Since:
    JDK1.2

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ORB()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `connect(Object obj)` Connects the given servant object (a Java object that is an instance of the server implementation class) to the ORB.
    `TypeCode` | `create_abstract_interface_tc(String id, String name)` Create a `TypeCode` object for an IDL abstract interface.
    `abstract TypeCode` | `create_alias_tc(String id, String name, TypeCode original_type)` Creates a `TypeCode` object representing an IDL `alias` (`typedef`).
    `abstract Any` | `create_any()` Creates an IDL `Any` object initialized to contain a `Typecode` object whose `kind` field is set to `TCKind.tc_null`.
    `abstract TypeCode` | `create_array_tc(int length, TypeCode element_type)` Creates a `TypeCode` object representing an IDL `array`.
    `DynAny` | `create_basic_dyn_any(TypeCode type)` Deprecated. Use the new DynAnyFactory API instead
    `abstract ContextList` | `create_context_list()` Creates an empty `ContextList` object.
    `DynAny` | `create_dyn_any(Any value)` Deprecated. Use the new DynAnyFactory API instead
    `DynArray` | `create_dyn_array(TypeCode type)` Deprecated. Use the new DynAnyFactory API instead
    `DynEnum` | `create_dyn_enum(TypeCode type)` Deprecated. Use the new DynAnyFactory API instead
    `DynSequence` | `create_dyn_sequence(TypeCode type)` Deprecated. Use the new DynAnyFactory API instead
    `DynStruct` | `create_dyn_struct(TypeCode type)` Deprecated. Use the new DynAnyFactory API instead
    `DynUnion` | `create_dyn_union(TypeCode type)` Deprecated. Use the new DynAnyFactory API instead
    `abstract TypeCode` | `create_enum_tc(String id, String name, String[] members)` Creates a `TypeCode` object representing an IDL `enum`.
    `abstract Environment` | `create_environment()` Creates an `Environment` object.
    `abstract ExceptionList` | `create_exception_list()` Creates an empty `ExceptionList` object.
    `abstract TypeCode` | `create_exception_tc(String id, String name, StructMember[] members)` Creates a `TypeCode` object representing an IDL `exception`.
    `TypeCode` | `create_fixed_tc(short digits, short scale)` Create a `TypeCode` object for an IDL fixed type.
    `abstract TypeCode` | `create_interface_tc(String id, String name)` Creates a `TypeCode` object representing an IDL `interface`.
    `abstract NVList` | `create_list(int count)` Allocates an `NVList` with (probably) enough space for the specified number of `NamedValue` objects.
    `abstract NamedValue` | `create_named_value(String s, Any any, int flags)` Creates a `NamedValue` object using the given name, value, and argument mode flags.
    `TypeCode` | `create_native_tc(String id, String name)` Create a `TypeCode` object for an IDL native type.
    `NVList` | `create_operation_list(Object oper)` Creates an `NVList` initialized with argument descriptions for the operation described in the given `OperationDef` object.
    `abstract OutputStream` | `create_output_stream()` Creates a new `org.omg.CORBA.portable.OutputStream` into which IDL method parameters can be marshalled during method invocation.
    `Policy` | `create_policy(int type, Any val)` Can be invoked to create new instances of policy objects of a specific type with specified initial state.
    `abstract TypeCode` | `create_recursive_sequence_tc(int bound, int offset)` Deprecated. Use a combination of create_recursive_tc and create_sequence_tc instead
    `TypeCode` | `create_recursive_tc(String id)` Create a recursive `TypeCode` object which serves as a placeholder for a concrete TypeCode during the process of creating TypeCodes which contain recursion.
    `abstract TypeCode` | `create_sequence_tc(int bound, TypeCode element_type)` Creates a `TypeCode` object representing an IDL `sequence`.
    `abstract TypeCode` | `create_string_tc(int bound)` Creates a `TypeCode` object representing a bounded IDL `string`.
    `abstract TypeCode` | `create_struct_tc(String id, String name, StructMember[] members)` Creates a `TypeCode` object representing an IDL `struct`.
    `abstract TypeCode` | `create_union_tc(String id, String name, TypeCode discriminator_type, UnionMember[] members)` Creates a `TypeCode` object representing an IDL `union`.
    `TypeCode` | `create_value_box_tc(String id, String name, TypeCode boxed_type)` Creates a `TypeCode` object for an IDL value box.
    `TypeCode` | `create_value_tc(String id, String name, short type_modifier, TypeCode concrete_base, ValueMember[] members)` Create a `TypeCode` object for an IDL value type.
    `abstract TypeCode` | `create_wstring_tc(int bound)` Creates a `TypeCode` object representing a bounded IDL `wstring` (wide string).
    `void` | `destroy()` Destroys the ORB so that its resources can be reclaimed.
    `void` | `disconnect(Object obj)` Disconnects the given servant object from the ORB.
    `Current` | `get_current()` Deprecated. use `resolve_initial_references`.
    `abstract Context` | `get_default_context()` Gets the default `Context` object.
    `abstract Request` | `get_next_response()` Gets the next `Request` instance for which a response has been received.
    `abstract TypeCode` | `get_primitive_tc(TCKind tcKind)` Retrieves the `TypeCode` object that represents the given primitive IDL type.
    `boolean` | `get_service_information(short service_type, ServiceInformationHolder service_info)` Used to obtain information about CORBA facilities and services that are supported by this ORB.
    `static ORB` | `init()` Returns the `ORB` singleton object.
    `static ORB` | `init(Applet app, Properties props)` Creates a new `ORB` instance for an applet.
    `static ORB` | `init(String[] args, Properties props)` Creates a new `ORB` instance for a standalone application.
    `abstract String[]` | `list_initial_services()` Returns a list of the initially available CORBA object references, such as "NameService" and "InterfaceRepository".
    `abstract String` | `object_to_string(Object obj)` Converts the given CORBA object reference to a string.
    `void` | `perform_work()` Performs an implementation-dependent unit of work if called by the main thread.
    `abstract boolean` | `poll_next_response()` Finds out if any of the deferred (asynchronous) invocations have a response yet.
    `abstract Object` | `resolve_initial_references(String object_name)` Resolves a specific object reference from the set of available initial service names.
    `void` | `run()` This operation blocks the current thread until the ORB has completed the shutdown process, initiated when some thread calls `shutdown`.
    `abstract void` | `send_multiple_requests_deferred(Request[] req)` Sends multiple dynamic (DII) requests asynchronously.
    `abstract void` | `send_multiple_requests_oneway(Request[] req)` Sends multiple dynamic (DII) requests asynchronously without expecting any responses.
    `protected abstract void` | `set_parameters(Applet app, Properties props)` Allows the ORB implementation to be initialized with the given applet and parameters.
    `protected abstract void` | `set_parameters(String[] args, Properties props)` Allows the ORB implementation to be initialized with the given parameters and properties.
    `void` | `shutdown(boolean wait_for_completion)` Instructs the ORB to shut down, which causes all object adapters to shut down, in preparation for destruction. If the `wait_for_completion` parameter is true, this operation blocks until all ORB processing (including processing of currently executing requests, object deactivation, and other object adapter operations) has completed.
    `abstract Object` | `string_to_object(String str)` Converts a string produced by the method `object_to_string` back to a CORBA object reference.
    `boolean` | `work_pending()` Returns `true` if the ORB needs the main thread to perform some work, and `false` if the ORB does not need the main thread.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ORB

          public ORB()

  - ### Method Detail

    - #### init

          public static ORB init()

      Returns the `ORB` singleton object. This method always returns the same ORB instance, which is an instance of the class described by the `org.omg.CORBA.ORBSingletonClass` system property.

      This no-argument version of the method `init` is used primarily as a factory for `TypeCode` objects, which are used by `Helper` classes to implement the method `type`. It is also used to create `Any` objects that are used to describe `union` labels (as part of creating a `TypeCode` object for a `union`).

      This method is not intended to be used by applets, and in the event that it is called in an applet environment, the ORB it returns is restricted so that it can be used only as a factory for `TypeCode` objects. Any `TypeCode` objects it produces can be safely shared among untrusted applets.

      If an ORB is created using this method from an applet, a system exception will be thrown if methods other than those for creating `TypeCode` objects are invoked.

      Returns:
        the singleton ORB

    - #### init

          public static ORB init(String[] args,
                                 Properties props)

      Creates a new `ORB` instance for a standalone application. This method may be called from applications only and returns a new fully functional `ORB` object each time it is called.
      Parameters:
        `args` - command-line arguments for the application's `main` method; may be `null`
        `props` - application-specific properties; may be `null`
      Returns:
        the newly-created ORB instance

    - #### init

          public static ORB init(Applet app,
                                 Properties props)

      Creates a new `ORB` instance for an applet. This method may be called from applets only and returns a new fully-functional `ORB` object each time it is called.
      Parameters:
        `app` - the applet; may be `null`
        `props` - applet-specific properties; may be `null`
      Returns:
        the newly-created ORB instance

    - #### set_parameters

          protected abstract void set_parameters(String[] args,
                                                 Properties props)

      Allows the ORB implementation to be initialized with the given parameters and properties. This method, used in applications only, is implemented by subclass ORB implementations and called by the appropriate `init` method to pass in its parameters.
      Parameters:
        `args` - command-line arguments for the application's `main` method; may be `null`
        `props` - application-specific properties; may be `null`

    - #### set_parameters

          protected abstract void set_parameters(Applet app,
                                                 Properties props)

      Allows the ORB implementation to be initialized with the given applet and parameters. This method, used in applets only, is implemented by subclass ORB implementations and called by the appropriate `init` method to pass in its parameters.
      Parameters:
        `app` - the applet; may be `null`
        `props` - applet-specific properties; may be `null`

    - #### connect

          public void connect(Object obj)

      Connects the given servant object (a Java object that is an instance of the server implementation class) to the ORB. The servant class must extend the `ImplBase` class corresponding to the interface that is supported by the server. The servant must thus be a CORBA object reference, and inherit from `org.omg.CORBA.Object`. Servants created by the user can start receiving remote invocations after the method `connect` has been called. A servant may also be automatically and implicitly connected to the ORB if it is passed as an IDL parameter in an IDL method invocation on a non-local object, that is, if the servant object has to be marshalled and sent outside of the process address space.

      Calling the method `connect` has no effect when the servant object is already connected to the ORB.

      Deprecated by the OMG in favor of the Portable Object Adapter APIs.

      Parameters:
        `obj` - The servant object reference

    - #### destroy

          public void destroy()

      Destroys the ORB so that its resources can be reclaimed. Any operation invoked on a destroyed ORB reference will throw the `OBJECT_NOT_EXIST` exception. Once an ORB has been destroyed, another call to `init` with the same ORBid will return a reference to a newly constructed ORB.

      If `destroy` is called on an ORB that has not been shut down, it will start the shut down process and block until the ORB has shut down before it destroys the ORB.
      If an application calls `destroy` in a thread that is currently servicing an invocation, the `BAD_INV_ORDER` system exception will be thrown with the OMG minor code 3, since blocking would result in a deadlock.

      For maximum portability and to avoid resource leaks, an application should always call `shutdown` and `destroy` on all ORB instances before exiting.

      Throws:
        `BAD_INV_ORDER` - if the current thread is servicing an invocation

    - #### disconnect

          public void disconnect(Object obj)

      Disconnects the given servant object from the ORB. After this method returns, the ORB will reject incoming remote requests for the disconnected servant and will send the exception `org.omg.CORBA.OBJECT_NOT_EXIST` back to the remote client. Thus the object appears to be destroyed from the point of view of remote clients. Note, however, that local requests issued using the servant directly do not pass through the ORB; hence, they will continue to be processed by the servant.

      Calling the method `disconnect` has no effect if the servant is not connected to the ORB.

      Deprecated by the OMG in favor of the Portable Object Adapter APIs.

      Parameters:
        `obj` - The servant object to be disconnected from the ORB

    - #### list_initial_services

          public abstract String[] list_initial_services()

      Returns a list of the initially available CORBA object references, such as "NameService" and "InterfaceRepository".
      Returns:
        an array of `String` objects that represent the object references for CORBA services that are initially available with this ORB

    - #### resolve_initial_references

          public abstract Object resolve_initial_references(String object_name)
                                                     throws InvalidName

      Resolves a specific object reference from the set of available initial service names.
      Parameters:
        `object_name` - the name of the initial service as a string
      Returns:
        the object reference associated with the given name
      Throws:
        `InvalidName` - if the given name is not associated with a known service

    - #### object_to_string

          public abstract String object_to_string(Object obj)

      Converts the given CORBA object reference to a string. Note that the format of this string is predefined by IIOP, allowing strings generated by a different ORB to be converted back into an object reference.

      The resulting `String` object may be stored or communicated in any way that a `String` object can be manipulated.

      Parameters:
        `obj` - the object reference to stringify
      Returns:
        the string representing the object reference

    - #### string_to_object

          public abstract Object string_to_object(String str)

      Converts a string produced by the method `object_to_string` back to a CORBA object reference.
      Parameters:
        `str` - the string to be converted back to an object reference. It must be the result of converting an object reference to a string using the method `object_to_string`.
      Returns:
        the object reference

    - #### create_list

          public abstract NVList create_list(int count)

      Allocates an `NVList` with (probably) enough space for the specified number of `NamedValue` objects. Note that the specified size is only a hint to help with storage allocation and does not imply the maximum size of the list.
      Parameters:
        `count` - suggested number of `NamedValue` objects for which to allocate space
      Returns:
        the newly-created `NVList`
      See Also:
        `NVList`

    - #### create_operation_list

          public NVList create_operation_list(Object oper)

      Creates an `NVList` initialized with argument descriptions for the operation described in the given `OperationDef` object. This `OperationDef` object is obtained from an Interface Repository. The arguments in the returned `NVList` object are in the same order as in the original IDL operation definition, which makes it possible for the list to be used in dynamic invocation requests.
      Parameters:
        `oper` - the `OperationDef` object to use to create the list
      Returns:
        a newly-created `NVList` object containing descriptions of the arguments to the method described in the given `OperationDef` object
      See Also:
        `NVList`

    - #### create_named_value

          public abstract NamedValue create_named_value(String s,
                                                        Any any,
                                                        int flags)

      Creates a `NamedValue` object using the given name, value, and argument mode flags.

      A `NamedValue` object serves as (1) a parameter or return value or (2) a context property. It may be used by itself or as an element in an `NVList` object.

      Parameters:
        `s` - the name of the `NamedValue` object
        `any` - the `Any` value to be inserted into the `NamedValue` object
        `flags` - the argument mode flags for the `NamedValue`: one of `ARG_IN.value`, `ARG_OUT.value`, or `ARG_INOUT.value`.
      Returns:
        the newly-created `NamedValue` object
      See Also:
        `NamedValue`

    - #### create_exception_list

          public abstract ExceptionList create_exception_list()

      Creates an empty `ExceptionList` object.
      Returns:
        the newly-created `ExceptionList` object

    - #### create_context_list

          public abstract ContextList create_context_list()

      Creates an empty `ContextList` object.
      Returns:
        the newly-created `ContextList` object
      See Also:
        `ContextList`, `Context`

    - #### get_default_context

          public abstract Context get_default_context()

      Gets the default `Context` object.
      Returns:
        the default `Context` object
      See Also:
        `Context`

    - #### create_environment

          public abstract Environment create_environment()

      Creates an `Environment` object.
      Returns:
        the newly-created `Environment` object
      See Also:
        `Environment`

    - #### create_output_stream

          public abstract OutputStream create_output_stream()

      Creates a new `org.omg.CORBA.portable.OutputStream` into which IDL method parameters can be marshalled during method invocation.
      Returns:
        the newly-created `org.omg.CORBA.portable.OutputStream` object

    - #### send_multiple_requests_oneway

          public abstract void send_multiple_requests_oneway(Request[] req)

      Sends multiple dynamic (DII) requests asynchronously without expecting any responses. Note that oneway invocations are not guaranteed to reach the server.
      Parameters:
        `req` - an array of request objects

    - #### send_multiple_requests_deferred

          public abstract void send_multiple_requests_deferred(Request[] req)

      Sends multiple dynamic (DII) requests asynchronously.
      Parameters:
        `req` - an array of `Request` objects

    - #### poll_next_response

          public abstract boolean poll_next_response()

      Finds out if any of the deferred (asynchronous) invocations have a response yet.
      Returns:
        `true` if there is a response available; `false` otherwise

    - #### get_next_response

          public abstract Request get_next_response()
                                             throws WrongTransaction

      Gets the next `Request` instance for which a response has been received.
      Returns:
        the next `Request` object ready with a response
      Throws:
        `WrongTransaction` - if the method `get_next_response` is called from a transaction scope different from the one from which the original request was sent. See the OMG Transaction Service specification for details.

    - #### get_primitive_tc

          public abstract TypeCode get_primitive_tc(TCKind tcKind)

      Retrieves the `TypeCode` object that represents the given primitive IDL type.
      Parameters:
        `tcKind` - the `TCKind` instance corresponding to the desired primitive type
      Returns:
        the requested `TypeCode` object

    - #### create_struct_tc

          public abstract TypeCode create_struct_tc(String id,
                                                    String name,
                                                    StructMember[] members)

      Creates a `TypeCode` object representing an IDL `struct`. The `TypeCode` object is initialized with the given id, name, and members.
      Parameters:
        `id` - the repository id for the `struct`
        `name` - the name of the `struct`
        `members` - an array describing the members of the `struct`
      Returns:
        a newly-created `TypeCode` object describing an IDL `struct`

    - #### create_union_tc

          public abstract TypeCode create_union_tc(String id,
                                                   String name,
                                                   TypeCode discriminator_type,
                                                   UnionMember[] members)

      Creates a `TypeCode` object representing an IDL `union`. The `TypeCode` object is initialized with the given id, name, discriminator type, and members.
      Parameters:
        `id` - the repository id of the `union`
        `name` - the name of the `union`
        `discriminator_type` - the type of the `union` discriminator
        `members` - an array describing the members of the `union`
      Returns:
        a newly-created `TypeCode` object describing an IDL `union`

    - #### create_enum_tc

          public abstract TypeCode create_enum_tc(String id,
                                                  String name,
                                                  String[] members)

      Creates a `TypeCode` object representing an IDL `enum`. The `TypeCode` object is initialized with the given id, name, and members.
      Parameters:
        `id` - the repository id for the `enum`
        `name` - the name for the `enum`
        `members` - an array describing the members of the `enum`
      Returns:
        a newly-created `TypeCode` object describing an IDL `enum`

    - #### create_alias_tc

          public abstract TypeCode create_alias_tc(String id,
                                                   String name,
                                                   TypeCode original_type)

      Creates a `TypeCode` object representing an IDL `alias` (`typedef`). The `TypeCode` object is initialized with the given id, name, and original type.
      Parameters:
        `id` - the repository id for the alias
        `name` - the name for the alias
        `original_type` - the `TypeCode` object describing the original type for which this is an alias
      Returns:
        a newly-created `TypeCode` object describing an IDL `alias`

    - #### create_exception_tc

          public abstract TypeCode create_exception_tc(String id,
                                                       String name,
                                                       StructMember[] members)

      Creates a `TypeCode` object representing an IDL `exception`. The `TypeCode` object is initialized with the given id, name, and members.
      Parameters:
        `id` - the repository id for the `exception`
        `name` - the name for the `exception`
        `members` - an array describing the members of the `exception`
      Returns:
        a newly-created `TypeCode` object describing an IDL `exception`

    - #### create_interface_tc

          public abstract TypeCode create_interface_tc(String id,
                                                       String name)

      Creates a `TypeCode` object representing an IDL `interface`. The `TypeCode` object is initialized with the given id and name.
      Parameters:
        `id` - the repository id for the interface
        `name` - the name for the interface
      Returns:
        a newly-created `TypeCode` object describing an IDL `interface`

    - #### create_string_tc

          public abstract TypeCode create_string_tc(int bound)

      Creates a `TypeCode` object representing a bounded IDL `string`. The `TypeCode` object is initialized with the given bound, which represents the maximum length of the string. Zero indicates that the string described by this type code is unbounded.
      Parameters:
        `bound` - the bound for the `string`; cannot be negative
      Returns:
        a newly-created `TypeCode` object describing a bounded IDL `string`
      Throws:
        `BAD_PARAM` - if bound is a negative value

    - #### create_wstring_tc

          public abstract TypeCode create_wstring_tc(int bound)

      Creates a `TypeCode` object representing a bounded IDL `wstring` (wide string). The `TypeCode` object is initialized with the given bound, which represents the maximum length of the wide string. Zero indicates that the string described by this type code is unbounded.
      Parameters:
        `bound` - the bound for the `wstring`; cannot be negative
      Returns:
        a newly-created `TypeCode` object describing a bounded IDL `wstring`
      Throws:
        `BAD_PARAM` - if bound is a negative value

    - #### create_sequence_tc

          public abstract TypeCode create_sequence_tc(int bound,
                                                      TypeCode element_type)

      Creates a `TypeCode` object representing an IDL `sequence`. The `TypeCode` object is initialized with the given bound and element type.
      Parameters:
        `bound` - the bound for the `sequence`, 0 if unbounded
        `element_type` - the `TypeCode` object describing the elements contained in the `sequence`
      Returns:
        a newly-created `TypeCode` object describing an IDL `sequence`

    - #### create_recursive_sequence_tc

          @Deprecated
          public abstract TypeCode create_recursive_sequence_tc(int bound,
                                                                            int offset)

      Deprecated. Use a combination of create_recursive_tc and create_sequence_tc instead
      Creates a `TypeCode` object representing a a recursive IDL `sequence`.

      For the IDL `struct` Node in following code fragment, the offset parameter for creating its sequence would be 1:

              Struct Node {
                  long value;
                  Sequence <Node> subnodes;
              };

      Parameters:
        `bound` - the bound for the sequence, 0 if unbounded
        `offset` - the index to the enclosing `TypeCode` object that describes the elements of this sequence
      Returns:
        a newly-created `TypeCode` object describing a recursive sequence
      See Also:
        `create_recursive_tc`, `create_sequence_tc`

    - #### create_array_tc

          public abstract TypeCode create_array_tc(int length,
                                                   TypeCode element_type)

      Creates a `TypeCode` object representing an IDL `array`. The `TypeCode` object is initialized with the given length and element type.
      Parameters:
        `length` - the length of the `array`
        `element_type` - a `TypeCode` object describing the type of element contained in the `array`
      Returns:
        a newly-created `TypeCode` object describing an IDL `array`

    - #### create_native_tc

          public TypeCode create_native_tc(String id,
                                           String name)

      Create a `TypeCode` object for an IDL native type.
      Parameters:
        `id` - the logical id for the native type.
        `name` - the name of the native type.
      Returns:
        the requested TypeCode.

    - #### create_abstract_interface_tc

          public TypeCode create_abstract_interface_tc(String id,
                                                       String name)

      Create a `TypeCode` object for an IDL abstract interface.
      Parameters:
        `id` - the logical id for the abstract interface type.
        `name` - the name of the abstract interface type.
      Returns:
        the requested TypeCode.

    - #### create_fixed_tc

          public TypeCode create_fixed_tc(short digits,
                                          short scale)

      Create a `TypeCode` object for an IDL fixed type.
      Parameters:
        `digits` - specifies the total number of decimal digits in the number and must be from 1 to 31 inclusive.
        `scale` - specifies the position of the decimal point.
      Returns:
        the requested TypeCode.

    - #### create_value_tc

          public TypeCode create_value_tc(String id,
                                          String name,
                                          short type_modifier,
                                          TypeCode concrete_base,
                                          ValueMember[] members)

      Create a `TypeCode` object for an IDL value type. The concrete_base parameter is the TypeCode for the immediate concrete valuetype base of the valuetype for which the TypeCode is being created. It may be null if the valuetype does not have a concrete base.
      Parameters:
        `id` - the logical id for the value type.
        `name` - the name of the value type.
        `type_modifier` - one of the value type modifier constants: VM_NONE, VM_CUSTOM, VM_ABSTRACT or VM_TRUNCATABLE
        `concrete_base` - a `TypeCode` object describing the concrete valuetype base
        `members` - an array containing the members of the value type
      Returns:
        the requested TypeCode

    - #### create_recursive_tc

          public TypeCode create_recursive_tc(String id)

      Create a recursive `TypeCode` object which serves as a placeholder for a concrete TypeCode during the process of creating TypeCodes which contain recursion. The id parameter specifies the repository id of the type for which the recursive TypeCode is serving as a placeholder. Once the recursive TypeCode has been properly embedded in the enclosing TypeCode which corresponds to the specified repository id, it will function as a normal TypeCode. Invoking operations on the recursive TypeCode before it has been embedded in the enclosing TypeCode will result in a `BAD_TYPECODE` exception.

      For example, the following IDL type declaration contains recursion:

              Struct Node {
                  Sequence<Node> subnodes;
              };

      To create a TypeCode for struct Node, you would invoke the TypeCode creation operations as shown below:

           String nodeID = "IDL:Node:1.0";
           TypeCode recursiveSeqTC = orb.create_sequence_tc(0, orb.create_recursive_tc(nodeID));
           StructMember[] members = { new StructMember("subnodes", recursiveSeqTC, null) };
           TypeCode structNodeTC = orb.create_struct_tc(nodeID, "Node", members);

      Also note that the following is an illegal IDL type declaration:

              Struct Node {
                  Node next;
              };

      Recursive types can only appear within sequences which can be empty. That way marshaling problems, when transmitting the struct in an Any, are avoided.

      Parameters:
        `id` - the logical id of the referenced type
      Returns:
        the requested TypeCode

    - #### create_value_box_tc

          public TypeCode create_value_box_tc(String id,
                                              String name,
                                              TypeCode boxed_type)

      Creates a `TypeCode` object for an IDL value box.
      Parameters:
        `id` - the logical id for the value type
        `name` - the name of the value type
        `boxed_type` - the TypeCode for the type
      Returns:
        the requested TypeCode

    - #### create_any

          public abstract Any create_any()

      Creates an IDL `Any` object initialized to contain a `Typecode` object whose `kind` field is set to `TCKind.tc_null`.
      Returns:
        a newly-created `Any` object

    - #### get_current

          @Deprecated
          public Current get_current()

      Deprecated. use `resolve_initial_references`.
      Retrieves a `Current` object. The `Current` interface is used to manage thread-specific information for use by services such as transactions and security.
      Returns:
        a newly-created `Current` object
      See Also:
        `CORBA` package comments for unimplemented features

    - #### run

          public void run()

      This operation blocks the current thread until the ORB has completed the shutdown process, initiated when some thread calls `shutdown`. It may be used by multiple threads which get all notified when the ORB shuts down.

    - #### shutdown

          public void shutdown(boolean wait_for_completion)

      Instructs the ORB to shut down, which causes all object adapters to shut down, in preparation for destruction.
      If the `wait_for_completion` parameter is true, this operation blocks until all ORB processing (including processing of currently executing requests, object deactivation, and other object adapter operations) has completed. If an application does this in a thread that is currently servicing an invocation, the `BAD_INV_ORDER` system exception will be thrown with the OMG minor code 3, since blocking would result in a deadlock.
      If the `wait_for_completion` parameter is `FALSE`, then shutdown may not have completed upon return.

      While the ORB is in the process of shutting down, the ORB operates as normal, servicing incoming and outgoing requests until all requests have been completed. Once an ORB has shutdown, only object reference management operations may be invoked on the ORB or any object reference obtained from it. An application may also invoke the `destroy` operation on the ORB itself. Invoking any other operation will throw the `BAD_INV_ORDER` system exception with the OMG minor code 4.

      The `ORB.run` method will return after `shutdown` has been called.

      Parameters:
        `wait_for_completion` - `true` if the call should block until the shutdown is complete; `false` if it should return immediately
      Throws:
        `BAD_INV_ORDER` - if the current thread is servicing an invocation

    - #### work_pending

          public boolean work_pending()

      Returns `true` if the ORB needs the main thread to perform some work, and `false` if the ORB does not need the main thread.
      Returns:
        `true` if there is work pending, meaning that the ORB needs the main thread to perform some work; `false` if there is no work pending and thus the ORB does not need the main thread

    - #### perform_work

          public void perform_work()

      Performs an implementation-dependent unit of work if called by the main thread. Otherwise it does nothing. The methods `work_pending` and `perform_work` can be used in conjunction to implement a simple polling loop that multiplexes the main thread among the ORB and other activities.

    - #### get_service_information

          public boolean get_service_information(short service_type,
                                                 ServiceInformationHolder service_info)

      Used to obtain information about CORBA facilities and services that are supported by this ORB. The service type for which information is being requested is passed in as the in parameter `service_type`, the values defined by constants in the CORBA module. If service information is available for that type, that is returned in the out parameter `service_info`, and the operation returns the value `true`. If no information for the requested services type is available, the operation returns `false` (i.e., the service is not supported by this ORB).

      Parameters:
        `service_type` - a `short` indicating the service type for which information is being requested
        `service_info` - a `ServiceInformationHolder` object that will hold the `ServiceInformation` object produced by this method
      Returns:
        `true` if service information is available for the `service_type`; `false` if no information for the requested services type is available
      See Also:
        `CORBA` package comments for unimplemented features

    - #### create_dyn_any

          @Deprecated
          public DynAny create_dyn_any(Any value)

      Deprecated. Use the new DynAnyFactory API instead
      Creates a new `DynAny` object from the given `Any` object.

      Parameters:
        `value` - the `Any` object from which to create a new `DynAny` object
      Returns:
        the new `DynAny` object created from the given `Any` object
      See Also:
        `CORBA` package comments for unimplemented features

    - #### create_basic_dyn_any

          @Deprecated
          public DynAny create_basic_dyn_any(TypeCode type)
                                                  throws InconsistentTypeCode

      Deprecated. Use the new DynAnyFactory API instead
      Creates a basic `DynAny` object from the given `TypeCode` object.

      Parameters:
        `type` - the `TypeCode` object from which to create a new `DynAny` object
      Returns:
        the new `DynAny` object created from the given `TypeCode` object
      Throws:
        `InconsistentTypeCode` - if the given `TypeCode` object is not consistent with the operation.
      See Also:
        `CORBA` package comments for unimplemented features

    - #### create_dyn_struct

          @Deprecated
          public DynStruct create_dyn_struct(TypeCode type)
                                                  throws InconsistentTypeCode

      Deprecated. Use the new DynAnyFactory API instead
      Creates a new `DynStruct` object from the given `TypeCode` object.

      Parameters:
        `type` - the `TypeCode` object from which to create a new `DynStruct` object
      Returns:
        the new `DynStruct` object created from the given `TypeCode` object
      Throws:
        `InconsistentTypeCode` - if the given `TypeCode` object is not consistent with the operation.
      See Also:
        `CORBA` package comments for unimplemented features

    - #### create_dyn_sequence

          @Deprecated
          public DynSequence create_dyn_sequence(TypeCode type)
                                                      throws InconsistentTypeCode

      Deprecated. Use the new DynAnyFactory API instead
      Creates a new `DynSequence` object from the given `TypeCode` object.

      Parameters:
        `type` - the `TypeCode` object from which to create a new `DynSequence` object
      Returns:
        the new `DynSequence` object created from the given `TypeCode` object
      Throws:
        `InconsistentTypeCode` - if the given `TypeCode` object is not consistent with the operation.
      See Also:
        `CORBA` package comments for unimplemented features

    - #### create_dyn_array

          @Deprecated
          public DynArray create_dyn_array(TypeCode type)
                                                throws InconsistentTypeCode

      Deprecated. Use the new DynAnyFactory API instead
      Creates a new `DynArray` object from the given `TypeCode` object.

      Parameters:
        `type` - the `TypeCode` object from which to create a new `DynArray` object
      Returns:
        the new `DynArray` object created from the given `TypeCode` object
      Throws:
        `InconsistentTypeCode` - if the given `TypeCode` object is not consistent with the operation.
      See Also:
        `CORBA` package comments for unimplemented features

    - #### create_dyn_union

          @Deprecated
          public DynUnion create_dyn_union(TypeCode type)
                                                throws InconsistentTypeCode

      Deprecated. Use the new DynAnyFactory API instead
      Creates a new `DynUnion` object from the given `TypeCode` object.

      Parameters:
        `type` - the `TypeCode` object from which to create a new `DynUnion` object
      Returns:
        the new `DynUnion` object created from the given `TypeCode` object
      Throws:
        `InconsistentTypeCode` - if the given `TypeCode` object is not consistent with the operation.
      See Also:
        `CORBA` package comments for unimplemented features

    - #### create_dyn_enum

          @Deprecated
          public DynEnum create_dyn_enum(TypeCode type)
                                              throws InconsistentTypeCode

      Deprecated. Use the new DynAnyFactory API instead
      Creates a new `DynEnum` object from the given `TypeCode` object.

      Parameters:
        `type` - the `TypeCode` object from which to create a new `DynEnum` object
      Returns:
        the new `DynEnum` object created from the given `TypeCode` object
      Throws:
        `InconsistentTypeCode` - if the given `TypeCode` object is not consistent with the operation.
      See Also:
        `CORBA` package comments for unimplemented features

    - #### create_policy

          public Policy create_policy(int type,
                                      Any val)
                               throws PolicyError

      Can be invoked to create new instances of policy objects of a specific type with specified initial state. If `create_policy` fails to instantiate a new Policy object due to its inability to interpret the requested type and content of the policy, it raises the `PolicyError` exception with the appropriate reason.
      Parameters:
        `type` - the `PolicyType` of the policy object to be created
        `val` - the value that will be used to set the initial state of the `Policy` object that is created
      Returns:
        Reference to a newly created `Policy` object of type specified by the `type` parameter and initialized to a state specified by the `val` parameter
      Throws:
        ``org.omg.CORBA.PolicyError`` - when the requested policy is not supported or a requested initial state for the policy is not supported.
        `PolicyError`

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, 2016, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.