Wrapper class for UErrorCode, with conversion operators for direct use in ICU C and C++ APIs. More...

#include <errorcode.h>

Inheritance diagram for ErrorCode:

Public Member Functions
	ErrorCode ()
	Default constructor.

virtual	~ErrorCode ()
	Destructor, does nothing.

	operator UErrorCode & ()
	Conversion operator, returns a reference.

	operator UErrorCode * ()
	Conversion operator, returns a pointer.

UBool	isSuccess () const
	Tests for U_SUCCESS().

UBool	isFailure () const
	Tests for U_FAILURE().

UErrorCode	get () const
	Returns the UErrorCode value.

void	set (UErrorCode value)
	Sets the UErrorCode value.

UErrorCode	reset ()
	Returns the UErrorCode value and resets it to U_ZERO_ERROR.

void	assertSuccess () const
	Asserts isSuccess().

const char *	errorName () const
	Return a string for the UErrorCode value.

Protected Member Functions
virtual void	handleFailure () const
	Called by assertSuccess() if isFailure() is true.

Protected Attributes
UErrorCode	errorCode
	Internal UErrorCode, accessible to subclasses.

Detailed Description

Wrapper class for UErrorCode, with conversion operators for direct use in ICU C and C++ APIs.

Intended to be used as a base class, where a subclass overrides the handleFailure() function so that it throws an exception, does an assert(), logs an error, etc. This is not an abstract base class. This class can be used and instantiated by itself, although it will be more useful when subclassed.

Features:

The constructor initializes the internal UErrorCode to U_ZERO_ERROR, removing one common source of errors.
Same use in C APIs taking a UErrorCode * (pointer) and C++ taking UErrorCode & (reference) via conversion operators.
Possible automatic checking for success when it goes out of scope.

Note: For automatic checking for success in the destructor, a subclass must implement such logic in its own destructor because the base class destructor cannot call a subclass function (like handleFailure()). The ErrorCode base class destructor does nothing.

Note also: While it is possible for a destructor to throw an exception, it is generally unsafe to do so. This means that in a subclass the destructor and the handleFailure() function may need to take different actions.

Sample code:

class IcuErrorCode: public icu::ErrorCode {
public:
  virtual ~IcuErrorCode() {  // should be defined in .cpp as "key function"
    // Safe because our handleFailure() does not throw exceptions.
    if(isFailure()) { handleFailure(); }
  }
protected:
  virtual void handleFailure() const {
    log_failure(u_errorName(errorCode));
    exit(errorCode);
  }
};
IcuErrorCode error_code;
UConverter *cnv = ucnv_open("Shift-JIS", error_code);
length = ucnv_fromUChars(dest, capacity, src, length, error_code);
ucnv_close(cnv);
// IcuErrorCode destructor checks for success.