net.sf.mmm.util.exception.api (JavaDocs for mmm-all dev-SNAPSHOT)

Interface Summary
Interface	Description
ExceptionUtil	This is the interface for a collection of utility functions to deal with exceptions (`Throwable`s).
ExceptionUtilLimited	This is a limited subset of `ExceptionUtil` that is GWT compatible.
GlobalExceptionHandler	This is the interface used as fallback to `handle errors` that can not be handled in a specific way by generic components.
NlsThrowable	This is the interface for exceptions with the following features: real native language support via `NlsMessage`. a `UUID` unique per exception instance automatically generated once per exception `chain`. an `error code` that should be unique per exception type. distinguish between `technical` exceptions and exceptions `intended for end-users`. support for `copying and truncation` of the exception. NOTE: Exceptions should only occur in unexpected or un-normal situations.

Class Summary
Class	Description
ExceptionTruncation	This class configures the (potential) truncation of an exception.
ThrowableHelper	This is a small hack to truncate exceptions.
ThrowableHelper.Helper	Class for reflective access to `Throwable`s.

Exception Summary
Exception	Description
BusinessErrorUserException	This is a generic exception to transport an arbitrary `user` error `message`.
ComposedException	An `ComposedException` combines a list of exceptions in one single exception.
DuplicateObjectException	An `DuplicateObjectException` is thrown if an object was rejected because it is a duplicate.
DuplicateObjectUserException	This is a `DuplicateObjectException` that represents a user failure (is NOT `technical`).
GenericSerializableException	This is a very specific exception that allows sending of any `Throwable` via a remote service.
IllegalCaseException	A `IllegalCaseException` is thrown if a specific case occurred that should never happen.
NlsClassCastException	A `NlsClassCastException` is analog to an `ClassCastException` but with native language support.
NlsException	This is an abstract base implementation of a checked exception with real native language support (NLS).
NlsIllegalArgumentException	A `NlsIllegalArgumentException` is analog to an `IllegalArgumentException` but with true native language support.
NlsIllegalStateException	A `NlsIllegalStateException` is analog to an `IllegalStateException` but with true native language support.
NlsNullPointerException	A `NlsNullPointerException` is analog to an `NullPointerException` but with native language support.
NlsParseException	The `NlsParseException` is thrown if some data could NOT be parsed because it does NOT match the according format (pattern or grammar).
NlsRuntimeException	This is an abstract base implementation of `NlsThrowable` based on `RuntimeException`.
NlsRuntimeWrapperException	This is an `NlsRuntimeException` to wrap an arbitrary `NlsThrowable`.
NlsUnsupportedOperationException	An `NlsUnsupportedOperationException` is thrown if an operation was invoked that is NOT implemented or generally NOT supported.
ObjectDisposedException	An `ObjectDisposedException` is thrown if an object or value is already `disposed` and therefore an operation failed that has been invoked on it.
ObjectMismatchException	An `ObjectMismatchException` is thrown if an object or value do NOT match as expected.
ObjectNotFoundException	An `ObjectNotFoundException` is thrown if an object was requested but does NOT exist or could NOT be found.
ObjectNotFoundUserException	This is an `ObjectNotFoundException` that represents a user failure (is NOT `technical`).
OptimisticLockingException	This is a variant of exceptions like `OptimisticLockException` that is suitable for end-users and support NLS/I18N.
OptimisticLockingExceptionHibernate	The `OptimisticLockingException` for `StaleObjectStateException` from Hibernate.
OptimisticLockingExceptionJpa	The `OptimisticLockingException` for `OptimisticLockException` from JPA.
OptimisticLockingExceptionSpring	The `OptimisticLockingException` for `ObjectOptimisticLockingFailureException` from Spring.
ReadOnlyException	A `ReadOnlyException` is thrown if the modification of something failed because it is read-only.
TechnicalErrorUserException	A `TechnicalErrorUserException` is wrapping arbitrary technical errors to a generic exception for end-users or clients.
ValidationErrorUserException	This exception is thrown if a validation failed unexpectedly.
ValueConvertException	The `ValueConvertException` is thrown if a value could not be converted to a given type.
ValueException	This exception is thrown if a something goes wrong about values.
ValueNotSetException	This is the exception thrown if a required value was not set.
ValueOutOfRangeException	This is the exception thrown if a numeric value is not in the expected range.
WrongValueTypeException	This exception is thrown if a value has the wrong type (a different value type was expected).

Package net.sf.mmm.util.exception.api Description

Provides the API for utilities that help to deal with exceptions.

Util Exception API

This package contains the

advanced
 exceptions

with support for NLS (I18N/L10N), UUIDs, error codes, etc. - especially NlsRuntimeException. Further it contains various exceptions for common errors that can be reused. Finally, it contains the API of utilities that help to deal with exceptions especially ExceptionUtil.

Custom Exception Example:

 public class InvalidCustomerNumberException extends NlsRuntimeException {
   public InvalidCustomerNumberException(String customerNumber) {
     super(createBundle(MyNlsBundleRoot.class).errorInvalidCustomerNumber(customerNumber);
   }

   public getCode() { // optional method
     return "CUST0001"; // maybe use a constant
   }
 }

For native language support (NLS) you create an NlsBundle typically per module:

 public interface MyNlsBundleRoot extends NlsBundle {

    @NlsBundleMessage("The given customer number \"{id}\" is invalid!")
   NlsMessage errorInvalidCustomerNumber(@Named("id") String id);
 }

For further details about the NLS and I18N please read the NLS API documentation.