Not at all. The exception can carry all the context that an event does
(like URL, line number and so on). An exception can easily be mapped to
an event:
parser.setApp(app);
try {
parser.run();
}
catch (XmlNotWellFormedException e) {
parser.fatalError(e);
}
You can't generate more than one fatal error event with this approach,
but that seems well out of the scope of a simple interface like SAX.
Apart from the fact that it is the right thing to do (show me a Java API
that uses a callback for a fatal error), there are two other reasons why
throwing an exception is the right approach:
- Representing information about the error as an object allows much
better extensibility: implementations can extend
XmlNotWellFormedException to provide richer error reporting, and this
can be very conveniently exploited by applications.
- A parser will read from a URL, thus it is already the case that it
will generate IOExceptions, and thus applications have to be prepared to
deal with this already. (I hope nobody is suggesting that the parser
should try to catch IOExceptions.) By deriving
XmlNotWellFormedException from IOException, an application doesn't have
to right any additional code to deal with fatal errors.
The fact that a parser needs to be able to throw IOExceptions makes
deriving the parser interface from Runnable unworkable, because run
can't throw any checked exceptions. Instead an app would need to create
its own runnable that calls the parser inside a try statement, and
catches and deals with any IOExceptions.
James