Table 4‑1 lists the CORBA system exceptions.
Table 4‑1 CORBA System Exceptions Since both system and user exceptions require similar functionality, the SystemException and UserException classes are derived from the common Exception class. When an exception is raised, your CORBA client application can narrow from the Exception class to a specific SystemException or UserException class. The C++ Exception inheritance hierarchy is shown in Figure 4‑1.Figure 4‑1 C++ Exception Inheritance HierarchyThe Exception class provides the following public operations:
• The copy constructor and destructor operations automatically manage the storage associated with the exception.The _narrow operation allows your CORBA client application to catch any type of exception and then determine its type. The exception argument passed to the _narrow operation is a pointer to the base class Exception. The _narrow operation accepts a pointer to any Exception object. If the pointer is of type SystemException, the narrow() operation returns a pointer to the exception. If the pointer is not of type SystemException, the narrow() operation returns a Null pointer.Unlike the _narrow operation on object references, the _narrow operation on exceptions returns a suitably typed pointer to the same exception argument, not a pointer to a new exception. Therefore, you do not free a pointer returned by the _narrow operation. If the original exception goes out of scope or is destroyed, the pointer returned by the _narrow operation is no longer valid.
Note: The Oracle Tuxedo CORBA sample applications do not use the _narrow operation.The CORBA C++ client applications in the Oracle Tuxedo sample applications use the standard C++ try-catch exception handling mechanism to raise and catch exceptions when error conditions occur, rather than testing status values to detect errors. This exception-handling mechanism is also used to integrate CORBA exceptions into CORBA client applications. In C++, catch clauses are attempted in the order specified, and the first matching handler is called.try{
//Initialize the ORB
CORBA::ORB* orb=CORBA::ORB_init(argc, argv, ORBid);
//Get a Bootstrap Object
Tobj_Bootstrap* bs= new Tobj_Bootstrap(orb, “//host:port”);
//Resolve Factory Finder
CORBA::Object_var var_factory_finder_oref = bs->
resolve_initial_reference(“FactoryFinder”);
Tobj::FactoryFinder_var var_factory_finder_ref = Tobj::FactoryFinder::_narrow
(var_factory_finder_oref.in());
catch(CORBA::Exception& e) {
cerr <<e.get_id() <<end1;
}The following C++ example shows the OMG IDL file that declares the TooManyCredits user exception inside the Registar interface. Note that exceptions can be declared either within a module or within an interface.exception TooManyCredits
{
unsigned short maximum_credits;
};
interface Registrar
NotRegisteredList register_for_courses(
in StudentId student,
in CourseNumberList courses
) raises (
TooManyCredits
);The following C++ code example shows how a TooManyCredits user exception would work within the scope of a transaction for registering for classes://Register a student for some course
try {
pointer_registrar_reference->register_for_courses
(student_id, course_number_list);
catch (UniversityT::TooManyCredits& e) {
cout <<"You cannot register for more than"<< e.maximum_credits
<<"credits."<<end1;
}