 
 /// This class provides a series of class functions which expose some of the ICU
 /// library's functionality
-public class ICU {
+public struct ICU {
 	
 	/// Returns true if the UnicodeScalar is a white space character
 	public static func isWhiteSpace(e: UnicodeScalar) -> Bool {
-		return 1 == u_isWhitespace_wrapper(UChar32(e.value))
+		return 1 == u_isWhitespace(e.value)
 	}
 	/// Returns true if the UnicodeScalar is a digit character
 	public static func isDigit(e: UnicodeScalar) -> Bool {
-		return 1 == u_isdigit_wrapper(UChar32(e.value))
+		return 1 == u_isdigit(e.value)
 	}
 	/// Returns true if the UnicodeScalar is an alpha-numeric character
 	public static func isAlphaNum(e: UnicodeScalar) -> Bool {
-		return 1 == u_isalnum_wrapper(UChar32(e.value))
+		return 1 == u_isalnum(e.value)
 	}
 	/// Returns true if the UnicodeScalar is a hexadecimal character
 	public static func isHexDigit(e: UnicodeScalar) -> Bool {
 		if isDigit(e) {
 			return true
 		}
+		e.isHexDigit()
 		switch e {
 		case "A", "B", "C", "D", "E", "F", "a", "b", "c", "d", "e", "f":
 			return true

	
	@noreturn
	static func ThrowICUError(code: UErrorCode) throws {
		let msg = String(validatingUTF8: u_errorName_wrapper(code))!
		
		print("ICUError: \(code.rawValue) \(msg)")
		
		throw PerfectError.SystemError(code.rawValue, msg)
	}
	
	/// Parse a date string according to the indicated format string and return an ICU date.

			locale = UnsafePointer<Int8>(Array<UInt8>(utf8Chars))
		}
		
		let dateFormat = udat_open(UDAT_PATTERN, UDAT_PATTERN, locale, timezone, timeZoneLength, Array<UInt16>(utf16Chars), Int32(utf16Chars.count), &status)
		
		guard U_SUCCESS(status) else {
			try ThrowICUError(status)
		}
		
		defer { udat_close(dateFormat) }
		
		let buffer = UnsafeMutablePointer<UInt16>(allocatingCapacity: 1024)
		defer { buffer.deallocateCapacity(1024) }
		let formatResult = udat_format(dateFormat, date, buffer, 1024, nil, &status)
		
		guard formatResult > 0 && U_SUCCESS(status) else {
			try ThrowICUError(status)
