[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
- 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
- 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
- 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
- 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
- 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
- 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]