# Glossary of Java IDL Terms

adapter activator
  An adapter activator is an object that the application developer can associate with a POA. The ORB will invoke an operation on an adapter activator when a request is received for a child POA that does not currently exist. The adapter activator can then create the required POA on demand.
attribute (IDL)
  An identifiable association between an object and a value. An attribute `A` is made visible to clients as a pair of operations: `get_A` and `set_A`. Readonly attributes only generate a get operation.

  Also, that part of an IDL interface that is similar to a public class field or C++ data member. The `idlj` compiler maps an OMG IDL attribute to accessor and modifier methods in the Java programming language. For example, an interface `ball` might include the attribute `color`. The `idlj` compiler would generate a Java programming language method to get the color, and unless the attribute is `readonly`, a method to set the color.

client
  Any code which invokes an operation on a distributed object. A client might itself be a CORBA object, or it might be a non-object-oriented program, but while invoking a method on a CORBA object, it is said to be acting as client.
client stub
  A Java programming language class generated by `idlj` and used transparently by the client ORB during object invocation. The remote object reference held by the client points to the client stub. This stub is specific to the IDL interface from which it was generated, and it contains the information needed for the client to invoke a method on the CORBA object that was defined in the IDL interface.
client tier
  The portion of a distributed application that requests services from the server tier. Typically, the client tier is characterized by a small local footprint, a graphical user interface, and simplified development and maintenance efforts.

Common Object Request Broker Architecture (CORBA)
  An OMG-specified architecture that is the basis for the CORBA object model. The CORBA specification includes an interface definition language (IDL), which is a language-independent way of creating contracts between objects for implementation as distributed applications.
  The Java 2 Platform Standard Edition (J2SE) provides a CORBA Object Request Broker (ORB) and two CORBA programming models that utilize the Java CORBA ORB and Internet InterORB Protocol (IIOP). The two programming models are the RMI programming model, or RMI-IIOP, and the IDL programming model, or Java IDL. For more information on these programming models, read CORBA Technology and the Java Platform.
  See also: client tier, service tier, data store tier
CORBA object
  An entity which (1) is defined by an OMG IDL interface, and (2) for which an object reference is available. `Object` is also the implicit common base type for object references of IDL interfaces.
data store tier
  The portion of a distributed application that manages access to persistent data and its storage mechanisms, such as relational databases.
distributed application
  A program designed to run on more than one computer, typically with functionality separated into tiers such as client, service, and data store.
distributed environment
  A network of one or more computers that use CORBA objects. Objects are installed on the various machines and can communicate with each other.
Dynamic Invocation Interface (DII)
  An API that allows a client to make dynamic invocations on remote CORBA objects. It is used when at compile time a client does not have knowledge about an object it wants to invoke. Once an object is discovered, the client program can obtain a definition of it, issue a parameterized call to it, and receive a reply from it, all without having a type-specific client stub for the remote object.
Dynamic Skeleton Interface (DSI)
  An API that provides a way to deliver requests from an ORB to an object implementation when the type of the object implementation is not known at compile time. DSI, which is the server side analog to the client side DII, makes it possible for the application programmer to inspect the parameters of an incoming request to determine a target object and method.
exception (IDL)
  An IDL construct that represents an exceptional condition that could be returned in response to an invocation. There are two categories of exceptions: (1) system exceptions, which inherit from `org.omg.CORBA.SystemException` (which is a `java.lang.RuntimeException`), and (2) user-defined exceptions, which inherit from `org.omg.CORBA.UserException` (which is a `java.lang.Exception`).
factory object
  A CORBA object that is used to create new CORBA objects. Factory objects are themselves usually created at server installation time.
idlj compiler
  A tool that takes an interface written in OMG IDL and produces Java programming language interfaces and classes that represent the mapping from the IDL interface to the Java programming language. The resulting files are `.java` files. Prior to JDK 1.3, the `idlj` compiler was known as the `idltojava` compiler. The `idlj` compiler supports new CORBA-standard features required for RMI-IIOP. The `idlj` compiler is placed in the SDK's `.bin` directory by the installer.
idltojava compiler
  A tool that takes an interface written in OMG IDL and produces Java programming language interfaces and classes that represent the mapping from the IDL interface to the Java programming language. The resulting files are `.java` files. Beginning with JDK 1.3, the IDL-to-Java language mapping is handled by the `idlj` compiler, which supports new CORBA-standard features required for RMI-IIOP. The `idltojava` compiler can be downloaded from the Java Developer Connection (JDC) web site.
implementation
  A concrete class that defines the behavior for all of the operations and attributes of the IDL interface it supports. A servant object is an instance of an implementation. There may be many implementations of a single interface.
initial naming context
  The `NamingContext` object returned by a call to the method `orb.resolve_initial_references("NameService")`. It is an object reference to the COS Naming Service registered with the ORB and can be used to create other `NamingContext` objects.
  See also: naming context
Interface Definition Language (IDL)
  The OMG-standard language for defining the interfaces for all CORBA objects. An IDL interface declares a set of operations, exceptions, and attributes. Each operation has a signature, which defines its name, parameters, result and exceptions. OMG IDL does not include implementations for operations; rather, as its name indicates, it is simply a language for defining interfaces. The complete syntax and semantics for IDL are available in the OMG specification at the OMG web site.
Interface Repository (IFR)
  A service that contains all the registered component interfaces, the methods they support, and the parameters they require. The IFR stores, updates, and manages object interface definitions. Programs may use the IFR APIs to access and update this information. An IFR is not necessary for normal client/server interactions.
Internet InterORB Protocol (IIOP)
  The OMG-specified network protocol for communicating between ORBs. Java IDL conforms to CORBA/IIOP specification 2.3.1.
invocation
  The process of performing a method call on a CORBA object, which can be done without knowledge of the object's location on the network. Static invocation, which uses a client stub for the invocation and a server skeleton for the service being invoked, is used when the interface of the object is known at compile time. If the interface is not known at compile time, dynamic invocation must be used.
Java IDL
  The classes, libraries, and tools that make it possible to use CORBA objects from the Java programming language. The main components of Java IDL are an ORB, a naming service, and the `idlj` compiler. All are part of this release of J2SE.
name binding
  The association of a name with an object reference. Name bindings are stored in a naming context.
namespace
  A collection of naming contexts that are grouped together.
naming context
  A CORBA object that supports the `NamingContext` interface and functions as a sort of directory which contains (points to) other naming contexts and/or simple names. Similar to a directory structure, where the last item is a file and preceding items are directories, in a naming context, the last item is an object reference name, and the preceding items are naming contexts.
naming service
  A CORBA service that allows CORBA objects to be named by means of binding a name to an object reference. The name binding may be stored in the naming service, and a client may supply the name to obtain the desired object reference. The two options for Naming Services shipped with this version of J2SE are `orbd`, which is a daemon process containing a Bootstrap Service, a Transient Naming Service, a Persistent Naming Service, and a Server Manager, and `tnameserv`, a transient naming service.
object
  A computational grouping of operations and data into a modular unit. An object is defined by the interface it presents to others, its behavior when operations on its interface are invoked, and its state.
object adapter
  The ORB component which provides object reference, activation, and state related services to an object implementation. There may be different adapters provided for different kinds of implementations. The POA is a particular type of object adapter specified by OMG that can be used with multiple ORB implementations with a minimum of rewriting needed to deal with different vendors' implementations.
object id
  An object id is a value that is used by the POA and by the user-supplied implementation to identify a particular abstract CORBA object. Object Id values may be assigned and managed by the POA, or they may be assigned and managed by the implementation. Object Id values are hidden from clients, encapsulated by references. Object Ids have no standard form; they are managed by the POA as uninterpreted octet sequences.
object implementation
  See implementation.
Object Management Group (OMG)
  An international organization with over 700 members that establishes industry guidelines and object management specifications in order to provide a common framework for object-oriented application development. Its members include platform vendors, object-oriented database vendors, software tool developers, corporate developers, and software application vendors. The OMG Common Object Request Broker Architecture specifies the CORBA object model. See www.omg.org for more information.
object reference
  A construct containing the information needed to specify an object within an ORB. An object reference is used in method invocations to locate a CORBA object. Object references are the CORBA object equivalent to programming language-specific object pointers. They may be obtained from a factory object or from the Naming Service. An object reference, which is opaque (its internal structure is irrelevant to application developers), identifies the same CORBA object each time it is used. It is possible, however, for multiple object references to refer to the same CORBA object.
Object Request Broker (ORB)
  The libraries, processes, and other infrastructure in a distributed environment that enable CORBA objects to communicate with each other. The ORB connects objects requesting services to the objects providing them.
operation (IDL)
  The construct in an IDL interface that maps to a Java programming language method. For example, an interface `ball` might support the operation `bounce`. Operations may take parameters, return a result, or raise exceptions. IDL operations can be `oneway`, in which case they cannot return results (return values or out arguments) or raise exceptions.
operations interface
  A non abstract IDL interface is mapped to two public Java interfaces: a signature interface and an operations interface. The operations interface has the same name as the IDL interface with the suffix `Operations` appended to the end and is used in the server-side mapping and as a mechanism for providing optimized calls for collocated clients and servers.
ORBD (Object Request Broker Daemon)
  The orbd tool is a daemon process containing a Bootstrap Service, a Transient Naming Service, a Persistent Naming Service, and a Server Manager.
parameter (IDL)
  One or more objects the client passes to an IDL operation when it invokes the operation. Parameters may be declared as "in" (passed from client to server), "out" (passed from server to client), or "inout" (passed from client to server and then back from server to client).
persistent object
  An object that can survive the process or thread that created it. A persistent object exists until it is explicitly deleted.
PIDL (Pseudo-IDL)
  The interface definition language for describing a CORBA pseudo-object. Each language mapping, including the mapping from IDL to the Java programming language, describes how pseudo objects are mapped to language-specific constructs. PIDL mappings may or may not follow the rules that apply to mapping regular CORBA objects.
POA (Portable Object Adapter)
  An object adapter is the mechanism that connects a request using an object reference with the proper code to service that request. The POA is a particular type of object adapter specified by OMG that can be used with multiple ORB implementations with a minimum of rewriting needed to deal with different vendors' implementations.

  The POA is also intended to allow persistent objects -- at least, from the client's perspective. That is, as far as the client is concerned, these objects are always alive, and maintain data values stored in them, even though physically, the server may have been restarted many times, or the implementation may be provided by many different object implementations.

POA Manager
  A POA manager is an object that encapsulates the processing state of one or more POAs. Using operations on a POA manager, the developer can cause requests for the associated POAs to be queued or discarded. The developer can also use the POA manager to deactivate the POAs.
policy
  A policy is an object associated with a POA by an application in order to specify a characteristic shared by the objects implemented in that POA. This specification defines policies controlling the POA's threading model as well as a variety of other options related to the management of objects. Other specifications may define other policies that affect how an ORB processes requests on objects implemented in the POA.
Portable Interceptors
  Portable Interceptors are hooks into the ORB through which ORB services can intercept the normal flow of execution of the ORB. For more information, see `PortableInterceptor` Package.
pragma
  In J2SE v.1.2, a directive to the `idltojava` compiler to perform certain operations while compiling an IDL file. For example, the pragma "javaPackage" directs the `idltojava` compiler to put the Java programming language interfaces and classes it generates from the IDL interface into the Java programming language package specified. In J2SE v.1.3 and higher, this functionality is supported via the `-pkgPrefix` command line option to `idlj`.
pseudo-object
  An object similar to a CORBA object in that it is described in IDL, but unlike a CORBA object, it cannot be passed around using its object reference, nor can it be narrowed or stringified. Examples of pseudo-objects include the Interface Repository and DII which, although implemented as libraries, are more clearly described in OMG specifications as pseudo-objects with IDL interfaces. The IDL for pseudo-objects is called "PIDL" to indicate that a pseudo-object is being defined.
RMI-IIOP
  Java RMI-IIOP is an Object Request Broker and a compiler, `rmic -iiop`, that generates IIOP stub and tie classes. With RMI-IIOP, developers can write remote interfaces in the Java programming language and implement them simply using Java technology and the Java RMI APIs. These interfaces can be implemented in any other language that is supported by an OMG mapping and a vendor supplied ORB for that language. Similarly, clients can be written in other languages using IDL derived from the remote Java technology-based interfaces. Using RMI-IIOP, objects can be passed both by reference and by value over IIOP.
servant
  A servant is a programming language object or entity that implements requests on one or more objects. Servants generally exist within the context of a server process. Requests made on an object's references are mediated by the ORB and transformed into invocations on a particular servant. In the course of an object's lifetime it may be associated with (that is, requests on its references will be targeted at) multiple servants.
servant manager
  A servant manager is an object that the application developer can associate with a POA. The ORB will invoke operations on servant managers to activate servants on demand, and to deactivate servants. Servant managers are responsible for managing the association of an object (as characterized by its Object Id value) with a particular servant, and for determining whether an object exists or not. There are two kinds of servant managers, called `ServantActivator` and ServantLocator; the type used in a particular situation depends on policies in the POA.
servant object
  An instance of an object implementation for an IDL interface. The servant object is registered with the ORB so that the ORB knows where to send invocations. It is the servant that performs the services requested when a CORBA object's method is invoked.
server
  A program that contains the implementations of one or more IDL interfaces. For example, a desktop publishing server might implement a `Document` object type, a `ParagraphTag` object type, and other related object types. The server is required to register each implementation (servant object) with the ORB so that the ORB knows about the servant. Servers are sometimes referred to as object servers.
server skeleton
  A public abstract class generated by the `idlj` compiler that provides the ORB with information it needs in dispatching method invocations to the servant object(s). A server skeleton, like a client stub, is specific to the IDL interface from which it is generated. A server skeleton is the server side analog to a client stub, and these two classes are used by ORBs in static invocation.
servertool
  The Java IDL Server Tool, `servertool` provides the ease-of-use interface for the application programmers to register, unregister, startup, and shutdown a server.
service tier
  The portion of a distributed application that contains the business logic and performs most of the computation. The service tier is typically located on a shared machine for optimum resource use.
signature interface
  A non-abstract IDL interface is mapped to two public Java interfaces: a signature interface and an operations interface. The signature interface, which extends `IDLEntity`, has the same name as the IDL interface name and is used as the signature type in method declarations when interfaces of the specified type are used in other interfaces.
skeleton
  The object-interface-specific ORB component which assists an object adapter in passing requests to particular methods.
static invocation
  See invocation.
stringified object reference
  An object reference that has been converted to a string so that it may be stored on disk in a text file (or stored in some other manner). Such strings should be treated as opaque because they are ORB-implementation independent. Standard `object_to_string` and `string_to_object` methods on `org.omg.CORBA.Object` make stringified references available to all CORBA Objects.
stub
  A local procedure corresponding to a single operation that invokes that operation when called.
tnameserv
  The CORBA COS (Common Object Services) Naming Service provides a tree-like directory for object references much like a filesystem provides a directory structure for files. The Transient Naming Service provided with Java IDL, `tnameserv`, is a simple implementation of the COS Naming Service specification. Object references are stored in the namespace by name and each object reference-name pair is called a name binding. Name bindings may be organized under naming contexts. Naming contexts are themselves name bindings and serve the same organizational function as a file system subdirectory. All bindings are stored under the initial naming context. The initial naming context is the only persistent binding in the namespace; the rest of the namespace is lost if the transient naming service process halts and restarts.
transient object
  An object whose existence is limited by the lifetime of the process or thread that created it.

Distributed Application Concepts | CORBA and the Java Platform | Glossary

Home

Copyright © 1996-2004 Sun Microsystems, Inc., 2550 Garcia Ave., Mtn. View, CA. 94043-1100 USA., All rights reserved.