Given an annotated interface, return a Proxy that implements that interface. Interface must be annotated with @ExceptionWrapper( String idPrefix, String loggerName ). id prefix defaults to empty, loggerName defaults to the package name of the annotated class.

Also, note that this returned wrapper will always implement the MessageInfo interface, which provides a way to capture all of the messages and IDs used in the interface. This is used to generate resource bundles. In order for this to work, it is required that the interface declare a field

public static final [class name] self = ExceptionWrapper.makeWrapper( ... ) ;

This is necessary because the extension mechanism allows the construction of message IDs that cannot be predicted based on the annotations alone.

The behavior of the implementation of each method on the interface is determined in part by its return type as follows:

• void. Such a method can only log a message. Must have @Log, @Message is optional.
• String. Such a method may log a message, and also returns the message. Both @Log and @Message are optional.
• A subclass of Exception. Such a method may log a message, and also returns an exception containing the message. Both @Log and @Message are optional.

Each method may be annotated as follows:

• @Message( String value ). This defines the message to be placed in a resource bundle (generated at build time by a separate tool). The key to the resource bundle is <loggerName>.<methodName>. The message is prepended with the idPrefix and the id from the @Log annotation (if @Log is present, otherwise nothing is prepended to the message). If this annotation is not present, a default message is created from the method name and the arguments.
• @Log( LogLevel level, int id ). The presence of this annotation indicates that a log record must be generated, and logger IF the appropriate logger is enabled at the given level (note that LogLevel is an enum used for the annotation, each member of which returns the java.util.logging.Level from a getLevel() method).

In addition, the @Chain annotation may be used on a method parameter (whose type must be a subclass of Throwable) of a method that returns an exception to indicate that the parameter should be the cause of the returned exception. All other method parameters are used as arguments in formatting the message.