|
What is CORBA?
|
|
What is ISB for C++?
|
|
Developing Applications with ISB for C++
|
|
ISB for C++ Features
|
What is CORBA?
The Common Object Request Broker Architecture (CORBA) specification was developed by the Object Management Group to address the complexity and high cost of developing software applications. CORBA specifies an object-oriented approach to creating software components that can be reused and shared between applications. Each object encapsulates the details of its inner workings and presents a well defined interface, which reduces application complexity. The cost of developing applications is also reduced because once an object is implemented and tested, it may be used over and over again.
The Object Request Broker (ORB) in Figure 1.1 connects a client application with the objects it wishes to use. The client application does not need to know whether the object resides on the same computer or is located on a remote computer somewhere on the network. The client application only needs to know the object's name and understand how to use the object's interface. The ORB takes care of the details of locating the object, routing the request, and returning the result.
Figure 1.1 Client application acting on an object through an ORB.
Accessing Distributed Objects
To use an object, your application must first bind itself to the object, specifying the object's interface name. The ORB locates the host that offers an object with the requested interface name. If the server that implements the requested object is not currently executing, the ORB can ensure that the appropriate server is started. After the bind is completed, the client application can invoke operations on the object. The client's method invocations are translated into requests that are sent to the object server.
What is ISB for C++?
ISB for C++ is an ORB that offers a complete implementation of the CORBA specification. ISB for C++ makes it easy for you to develop distributed, object-based client applications and servers. ISB for C++ offers these important features:
The interface specification you create is used by the ISB for C++ IDL compiler to generate stub routines for the client application and skeleton code for the object implementation. The stub routines are used by the client application for all method invocations. You use the skeleton code, along with code you write, to create the server that implements the objects. The code for the client and object, once completed, is used as input to your C++ compiler and linker to produce the executable client application and object server. These steps are covered in detail in Getting Started.
ISB for C++ Features
In addition to providing the features defined in the CORBA specification, ISB for C++ offers enhancements that increase application performance and reliability.
Optimized Binding
When your application binds to an object, ISB for C++ selects and establishes the most efficient communication mechanism. Depending on the platform and the location of the requested object, the bind may be established through a pointer reference, shared memory, or a TCP/IP socket. Naming and Binding to Objects describes optimized binding in detail.
Dynamic Invocation Interface
ISB for C++ maintains an interface repository that contains the IDL specifications for all of the objects that have been activated. This repository can be used by client applications to discover a recently added object, obtain the object's interface, and dynamically construct requests to act on the object. The Dynamic Invocation Interface (DII) is covered in Dynamic Interfaces.
Support for Threads
On those platforms that support threads, ISB for C++ is thread-safe and reentrant for both the client application and the server. For each thread within your client application, each bind is allocated its own thread within the server. When your client disconnects, the server thread allocated for your client will exit. Thread support is discussed in Advanced Programming Topics.
Event Handling Facilities
ISB for C++ allows you to monitor the following events:
Event Loop Integration (For Single-Threaded Applications Only)
You may find that the objects you implement require interaction with an event-driven environment. Object implementations are also event driven because they must wait for client requests. ISB for C++ gives you the ability to incorporate your object's event polling into the network or windowing component's event loop. This frees you from the complexity of managing nested event loops in your code. Advanced Programming Topics explains the details of event loop integration.
Last Updated: 02/03/98 15:28:34