Contents

12.1 User-Defined Exceptions

12.1.1 The IDL Definitions

12.1.2 The Generated Code

12.2 System Exceptions

12.3 The Client: Handling Exceptions

12.3.1 Handling Specific System Exceptions

12.4 The Server: Throwing an Exception

12.4.1 Operation Completion Status in System Exceptions

Note that OrbixWeb does not require any special handling for exceptions. IDL exceptions are mapped to Java classes which inherit from java.lang.Exception. Therefore, exceptions thrown by a server can be handled by try and catch statements in the normal way.

12.1 User-Defined Exceptions

12.1.1 The IDL Definitions

The exception Reject is defined within the Bank interface and it defines a string member which will indicate the reason which caused the Bank to reject the request.

 // IDL
 interface Account { // Bank accounts.
 
 	readonly attribute float balance;
 
 	void makeDeposit(in float f);
 	void makeWithdrawal(in float f);
 };
 
 // A factory for bank accounts.
 interface Bank {
 	exception Reject { string reason; };
 
 	Account newAccount(in string name)
 		raises (Reject);
 
 	// Delete an account.
 	void deleteAccount(in Account a);
 };

 idl -jP idl_demo bank.idl

The Java class generated from the IDL exception definition is:

 // Java
 // Automatically generated,
 // in file _Bank/Reject.java.
 package idl_demo._Bank;
 
 import IE.Iona.Orbix2._CORBA;
 
 public class Reject 
 	extends IE.Iona.Orbix2.CORBA.UserException 
 	implements IE.Iona.Orbix2.CORBA.IDLCloneable, 
 	IE.Iona.Orbix2.CORBA.Marshalable {
 
 	public String reason;
 
 	public Reject() {
 		...
 	}
 
 	public Reject(String reason) {
 		...
 	}
 
 	...
 }

Since the Reject exception has one member (reason, of type string) a constructor is provided in the generated class, which allows this member to be initialised.

The Java interface for Account is generated as follows:

 // Java
 // Automatically generated,
 // in file _AccountRef.java.
 package idl_demo;
 
 public interface _AccountRef 
 	extends IE.Iona.Orbix2.CORBA._ObjectRef {
 	public float balance()
 		throws IE.Iona.Orbix2.CORBA.SystemException;
 
 	public void makeDeposit(float f)
 		throws IE.Iona.Orbix2.CORBA.SystemException;
 
 	public void makeWithdrawal(float f)
 		throws IE.Iona.Orbix2.CORBA.SystemException;
 }

 // Java
 // Automatically generated,
 // in file _BankRef.java.
 package idl_demo;
 
 public interface _BankRef 
 	extends IE.Iona.Orbix2.CORBA._ObjectRef {
 	public idl_demo._AccountRef newAccount(
 		String name)
 		throws idl_demo._Bank.Reject, 
 		IE.Iona.Orbix2.CORBA.SystemException;
 	
 	public void deleteAccount(
 		idl_demo._AccountRef a)
 		throws IE.Iona.Orbix2.CORBA.SystemException;
 }

12.2 System Exceptions

The system exceptions are implemented as a set of Java classes (in the package IE.Iona.Orbix2.CORBA), organised into a class hierarchy: each system exception is a derived class of SystemException (which in turn is a derived class of CORBAException). This allows all system exceptions to be caught in one single Java catch clause.

A client can also handle individual system exceptions in separate catch clauses, as described in section 12.3.1. Each system exception is implemented as a class of the following form:

 // Java
 package IE.Iona.Orbix2.CORBA;
 
 public class <EXCEPTION TYPE>
 	extends IE.Iona.Orbix2.CORBA.SystemException {
 	public <EXCEPTION TYPE> (){
 		...
 	}
 
 	public <EXCEPTION TYPE> (int minor, 
 		int compl_status) { 
 		...
 	}
 
 	public <EXCEPTION TYPE> (int minor, 
 		int compl_status, String detail) { 
 		...
 	}
 }

12.3 The Client: Handling Exceptions

 // Java
 // In file Client.java.
 package idl_demo;
 
 import IE.Iona.Orbix2.CORBA.SystemException;
 
 public class Client {
 	public static void main (String args[]) {
 		_BankRef bRef;
 		_AccountRef aRef;
 	
 		try {
 			// Bind to bank with marker College_Green
 			// in the BankSrv server.
 			bRef = Bank._bind 
 				("College_Green:BankSrv");
 
 			// Obtain a new bank account.
 			aRef = bRef.newAccount("Joe");
 		}
 		catch (_Bank.Reject re) {
 			System.out.println 
 				("Error on newAccount():");
 			System.out.println 
 				("Account creation rejected "
 				+ "with reason: " + re.reason);
 			return;
 		}
 		catch (SystemException se) {
 			System.out.println (
 				"Unexpected system exception:");
 			System.out.println (se.toString ());
 			return;
 		}
 
 		// Continue here if no exception.
 		...
 	}
 }

12.3.1 Handling Specific System Exceptions

 // Java
 // In file Client.java.
 package idl_demo;
 
 import IE.Iona.Orbix2.CORBA.SystemException;
 import IE.Iona.Orbix2.CORBA.COMM_FAILURE;
 
 public class Client {
 	public static void main (String args[]) {
 		_BankRef bRef;
 
 		try {
 			// Bind to bank with marker College_Green
 			// in the BankSrv server.
 			bRef = Bank._bind
 				("College_Green:BankSrv");
 		}
 		catch (COMM_FAILURE cfe) {
 			System.out.println
 				("Unexpected comm failure exception:");
 			System.out.println (cfe.toString ());
 			return;
 		}
 		catch (SystemException se) {
 			System.out.println
 				("Unexpected system exception:");
 			System.out.println (se.toString ());
 			return;
 		}
 
 		// Continue here if no exception.
 		...
 	}
 }

To handle individual system exceptions as shown in the code fragment above, it is necessary to import the required exceptions from the IE.Iona.Orbix2.CORBA package. As an alternative, the exception classes could be referenced by fully scoped names.

Note that if the programmer simply wishes to know the type of exception that occurred, then the message output by toString() on class SystemException is sufficient. A handler for an individual exception is only required when specific action is to be taken if that exception occurs.

12.4 The Server: Throwing an Exception

For example, to throw an exception of IDL type Bank::Reject, a programmer could simply do the following:

 // Java
 throw new idl_demo._Bank.Reject ("Some reason");

The implementation of the newAccount() operation can now be coded as follows:

 // Java
 // In file BankImplementation.java,
 // in package idl_demo,
 // in class BankImplementation.
 
 public _AccountRef 
 	newAccount(String name) 
 	throws _Bank.Reject, SystemException {
 	_AccountRef acc = null;
 
 	// Ensure that we do not already have an Account 
 	// for the given name, and if we are happy that 
 	// the name is okay, then:
 
 	if (happyToProceed) {
 		try {
 			acc = new AccountImplementation (0, name);
 		}
 		catch (SystemException se) {
 			// Details omitted.
 		} 
 
 		record (name, acc);
 		return acc; 
 	}
 	else {
 		// Throw a Reject exception.
 		throw new Bank.Reject 
 			("Bank is unhappy.");
 	}
 }