Lines Matching defs:ORB
41 * features. The {@code ORB} class also provides
42 * "pluggable ORB implementation" APIs that allow another vendor's ORB
45 * An ORB makes it possible for CORBA objects to communicate
50 * The {@code ORB} class, which
53 * the class {@code ORB}, are typically used with the
57 * most commonly they are used by the ORB internally and are
60 * <li> initializes the ORB implementation by supplying values for
65 * <li> connects the ORB to a servant (an instance of a CORBA object
66 * implementation) and disconnects the ORB from a servant
80 * The {@code ORB} class can be used to obtain references to objects
84 * by initializing itself into an {@code ORB} using one of
95 * <TD>class name of an ORB implementation</TD></TR>
97 * <TD>class name of the ORB returned by {@code init()}</TD></TR>
101 * These properties allow a different vendor's {@code ORB}
104 * When an ORB instance is being created, the class name of the ORB
126 * fully-functional ORB and for the Singleton ORB. When the method
128 * ORB is returned. When the method {@code init} is given parameters
129 * but no ORB class is specified, the Java IDL ORB implementation
132 * The following code fragment creates an {@code ORB} object
133 * initialized with the default ORB Singleton.
134 * This ORB has a
140 * ORB orb = ORB.init();
143 * The following code fragment creates an {@code ORB} object
146 * method. Since the property specifies the ORB class to be
147 * "SomeORBImplementation", the new ORB will be initialized with
148 * that ORB implementation. If p had been null,
149 * and the arguments had not specified an ORB class,
150 * the new ORB would have been
155 * ORB orb = ORB.init(args, p);
158 * The following code fragment creates an {@code ORB} object
160 * applet does not specify an ORB class, the new ORB will be
163 * ORB orb = ORB.init(myApplet, null);
167 * ORB initialization is a bootstrap call into the CORBA world.
171 * When a singleton ORB is configured via the system property,
176 * It should be noted that the singleton ORB is system wide.
178 * When a per-application ORB is created via the 2-arg init methods,
191 abstract public class ORB {
194 // This is the ORB implementation used when nothing else is specified.
196 // point at their ORB implementation.
220 // The global instance of the singleton ORB implementation which
227 static private ORB singleton;
313 * Returns the {@code ORB} singleton object. This method always returns the
314 * same ORB instance, which is an instance of the class described by the
325 * that it is called in an applet environment, the ORB it returns
330 * If an ORB is created using this method from an applet,
335 * @return the singleton ORB
339 * the system-wide singleton ORB is located via the
342 public static synchronized ORB init() {
357 private static ORB create_impl_with_systemclassloader(String className) {
362 Class<org.omg.CORBA.ORB> orbBaseClass = org.omg.CORBA.ORB.class;
364 return (ORB)singletonOrbClass.newInstance();
367 "can't instantiate default ORB implementation " + className);
373 private static ORB create_impl(String className) {
380 Class<org.omg.CORBA.ORB> orbBaseClass = org.omg.CORBA.ORB.class;
382 return (ORB)orbClass.newInstance();
385 "can't instantiate default ORB implementation " + className);
392 * Creates a new {@code ORB} instance for a standalone
394 * only and returns a new fully functional {@code ORB} object
399 * @return the newly-created ORB instance
403 * the ORB is located via the thread context class loader.
405 public static ORB init(String[] args, Properties props) {
408 // specifying the default ORB implementation. For an
411 // and it's baked-in ORB implementation default or by
416 ORB orb;
436 * Creates a new {@code ORB} instance for an applet. This
438 * fully-functional {@code ORB} object each time it is called.
441 * @return the newly-created ORB instance
445 * the ORB is located via the thread context class loader.
447 public static ORB init(Applet app, Properties props) {
449 ORB orb;
469 * Allows the ORB implementation to be initialized with the given
471 * is implemented by subclass ORB implementations and called
481 * Allows the ORB implementation to be initialized with the given
483 * is implemented by subclass ORB implementations and called
494 * to the ORB. The servant class must
500 * automatically and implicitly connected to the ORB if it is passed as
506 * when the servant object is already connected to the ORB.
517 * Destroys the ORB so that its resources can be reclaimed.
518 * Any operation invoked on a destroyed ORB reference will throw the
520 * Once an ORB has been destroyed, another call to {@code init}
521 * with the same ORBid will return a reference to a newly constructed ORB.<p>
522 * If {@code destroy} is called on an ORB that has not been shut down,
523 * it will start the shut down process and block until the ORB has shut down
524 * before it destroys the ORB.<br>
530 * on all ORB instances before exiting.
539 * Disconnects the given servant object from the ORB. After this method returns,
540 * the ORB will reject incoming remote requests for the disconnected
546 * pass through the ORB; hence, they will continue to be processed by the
550 * if the servant is not connected to the ORB.
554 * @param obj The servant object to be disconnected from the ORB
561 // ORB method implementations.
564 // It can act as a default ORB implementation front-end,
565 // creating an actual ORB implementation object which is a
566 // subclass of this ORB class and then delegating the method
579 * that are initially available with this ORB
598 * strings generated by a different ORB to be converted back into an object
652 // If we came here, it means that the actual ORB implementation
1135 * This operation blocks the current thread until the ORB has
1138 * get all notified when the ORB shuts down.
1147 * Instructs the ORB to shut down, which causes all
1150 * is true, this operation blocks until all ORB processing (including
1159 * While the ORB is in the process of shutting down, the ORB operates as normal,
1161 * Once an ORB has shutdown, only object reference management operations
1162 * may be invoked on the ORB or any object reference obtained from it.
1163 * An application may also invoke the {@code destroy} operation on the ORB itself.
1166 * The {@code ORB.run} method will return after
1181 * Returns {@code true} if the ORB needs the main thread to
1182 * perform some work, and {@code false} if the ORB does not
1185 * @return {@code true} if there is work pending, meaning that the ORB
1187 * if there is no work pending and thus the ORB does not need the
1202 * the main thread among the ORB and other activities.
1212 * that are supported by this ORB. The service type for which
1220 * (i.e., the service is not supported by this ORB).