[Up: Glossary]
[Previous: Abbreviations] [Next: Examples]


Note: For more POA terminology, see chapter 4.2.
The act of associating a type, servant and a user-supplied or generated Object Id in order to create an object. The servant may be left empty in order to create a new virtual object.
Basic Object Adapter
(BOA) The only object adapter specified by CORBA versions up to and including 2.1. Removed from the specification in CORBA 2.2.
The program that acquires client objects and performs CORBA invocations.
Collocation Proxy
A special type of stub used if the servant is in the same process as the client. The collocation proxy sets up the environment and performs a direct (local) procedure call into the servant if possible, else it falls back to normal stub behavior of sending a request through the ORB.
Common Data Representation
(CDR) Standardized ``on-the-wire'' representation for IDL data types, taking padding and endianness issues into account. Used by the General Inter-ORB Protocol.
Removes an object from the active object map. See etherealization. Deactivated objects become virtual and may be reincarnated at a later point in time.
Dynamic Invocation Interface
(DII) A standardized client-side interface for the marshalling of parameters into a request and invoking methods using run-time type information. Unlike the Static Invocation Interface, the DII allows for asynchronous method invocations by first sending a request and then waiting or polling for the result.
Dynamic Skeleton
The skeleton class that an object implementation must be derived from if it is to use the Dynamic Skeleton Interface.
Dynamic Skeleton Interface
(DSI) A standardized server-side interface for the unmarshalling of parameters from a request and retrieval of other request-specific data using run-time type information.
The act of disassociating a servant from an object, so that only a virtual object remains. Etherealization is triggered by an object's deactivation. Both terms are somewhat synonymous: an object is deactivated, and the servant is etherealized.
General Inter-ORB Protocol
(GIOP) The standardized request-response protocol used to send requests and to exchange control messages between ORBs. Uses Common Data Representation for the exchange of data and Interoperable ObjectReferences for addressing.
IDL Compiler
A program that reads descriptions from Interface Definition Language files and produces type declarations, stubs and skeletons for a target programming language according to the language mapping.
Internet Inter-ORB Protocol
(IIOP) The application of the General Inter-ORB Protocol to TCP/IP.
In a POSIX environment, an implementation is an executable program. When executed, an implementation becomes a server. The term is also frequently used to denote the user code that, when activated, becomes a servant. This document uses the term object implementation instead to emphasize the difference.
Implementation Name
A unique name that must be assigned to an implementation if it contains persistent objects. The Implementation Name is set using the -POAImplName option on the command line. (MICO-specific)
Implementation Repository
(IMR) A database containing information about available implementations and the objects they implement.
The act of associating a virtual object with a servant, usually in a servant activator.
Interface Definition Language
(IDL) The language used to describe an object's interface. This description is translated by the IDL compiler into a programming language's type declarations, stubs and skeletons according to the language mapping.
Interface Repository
(IFR) A database containing type information for interfaces, their data structures, operations and parameters, filled in from IDL files, usually by the IDL compiler. Can be used by clients or servers to retrieve type information at runtime.
Interoperable Object Reference
(IOR) A standardized format for object references.
Language Mapping
A language mapping describes how the types and declarations from the IDL language are expressed and how clients and servants can be implemented in a particular programming language.
The packaging of a method's parameters into a request.
A CORBA object is an abstract entity with a public interface and internal state. An object ``exists'' on the server side; the difference to the term ``servant'' is that the same servant can be used to implement many objects at once. Logically, an object is a three-tuple consisting of a type, a unique Object Id and a servant. Clients do not handle objects, they handle object references.
Object Adapter
The layer that exists on the server side to mediate between the ORB's request processing and the servants' readiness to receive requests.
Object Id
The part of an object key that identifies a particular servant within its object adapter. Can be either user-selected or assigned by the object adapter itself.
Object Implementation
The user-provided implementation code realizing all methods of a specific interface. In the C++ language mapping, an object implementation is a C++ class that inherits either from an IDL-generated skeleton or from the Dynamic Skeleton base class. A servant is an instance of an object implementation.
Object Key
The part of an object reference (or more precisely, of a profile) that identifies a particular object adapter within the server and a servant within that object adapter, using the object Id.
Object Reference
The ``address'' of a specific servant. An object reference contains a type and one or more profiles. To the user, an object reference is opaque data and cannot be examined or constructed.
Object Request Broker
(ORB) The ORB is basically only the entity that takes requests from a client and delivers them to a potentially remote servant. Sometimes called the ``ORB core,'' to distinguish this rudimentary task from the other user services also provided by the ORB, such as the stringification of object references. The term ``ORB'' is also frequently used to denote the sum of all non-user CORBA components, including the object adapters, dynamic invocation interface etc.
Persistent Object
A persistent object has been activated in a POA with the ``persistent'' lifespan policy. Persistent objects can outlive the server they were originally created in, so the server can be stopped and restarted transparently, usually by an Implementation Repository.
Portable Object Adapter
(POA) A powerful object adapter introduced in CORBA 2.2.
The part of an object reference that identifies a particular servant, consisting of location information (in the case of an IIOP, an Internet host name and TCP port number) and the object key.
A request is sent from the client to the server as part of method invocation, encapsulating the object's identity (object reference), the method name and the parameters. The request is dispatched to a servant, and the result is then returned in a reply message.
A servant is an instance of an object implementation. Servants must be activated with an Object Adapter. After activation, object references can be created for that servant.
A server contains one or more servants. In a POSIX environment, a server corresponds to a separate process.
The server-side programming-language code (C++ class) generated for a particular interface by the IDL compiler. Skeletons are abstract, the programmer must derive from the skeleton and add the methods' implementation. Instances of a class that derives from skeleton are servants.
Static Invocation Interface
A vendor-specific interface for the marshalling of parameters, employed by IDL-generated stubs. Proprietary, but usually much faster than the Dynamic Invocation Interface.
Static Skeleton Interface
A vendor-specific interface for the unmarshalling of parameters, employed by IDL-generated skeletons. Proprietary, but usually much faster than the Dynamic Skeleton Interface.
The client-side programming-language code (concrete C++ class) generated for a particular interface by the IDL compiler. Stub objects are instances of a stub.
Stub Object
Encapsulates an object reference and incarnates a specific most-derived interface. To the programming language, it presents the same interface as declared in the IDL file. The code for stub objects is generated by the IDL compiler. A stub objects' methods use the Static Invocation Interface to package its parameters into a CORBA request and causes a remote invocation on the servant.
Transient Object
A transient object is an object that has been activated in a POA with the ``transient'' lifespan policy. Its lifespan is bounded by the POA it was activated in, and ceases to exist if its POA instance is destroyed, for example as part of server shutdown. Note: this definition has changed in CORBA 2.3; according to CORBA 2.2, a transient object's lifespan is bounded by the lifespan of its server process.
Virtual Object
A virtual object has not been incarnated yet. The POA allows to create object references to virtual objects. The server could incarnate the object at a later point in time, or on demand by using a servant manager.

[Previous: Abbreviations] [Next: Examples]
[Up: Glossary]

Frank Pilhofer