| Methods Summary |
|---|
| public static synchronized char[] | byteToCharArray(byte[] buffer, int offset, int length, java.lang.String enc)Convert a byte array to a char array
if (offset < 0) {
throw new IndexOutOfBoundsException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped Integer.toString(offset)
/* #endif */
);
}
if (length < 0) {
throw new IndexOutOfBoundsException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped Integer.toString(length)
/* #endif */
);
}
// Note: offset or length might be near -1>>>1.
if (offset > buffer.length - length) {
throw new IndexOutOfBoundsException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped Integer.toString(offset + length)
/* #endif */
);
}
//Because most cases use ISO8859_1 encoding, we can optimize this case.
if(enc.compareTo("ISO8859_1") == 0) {
char[] value = new char[length];
for(int i=0; i<length; i++) {
value[i] = (char)(buffer[i+offset] & 0xff);
}
return value;
}
/* If we don't have a cached reader then make one */
if (lastReaderEncoding == null || !lastReaderEncoding.equals(enc)) {
lastReader = getStreamReaderPrim(enc);
lastReaderEncoding = enc;
}
/* Ask the reader for the size the output will be */
int size = lastReader.sizeOf(buffer, offset, length);
/* Allocate a buffer of that size */
char[] outbuf = new char[size];
/* Open the reader on a ByteArrayInputStream */
lastReader.open(new ByteArrayInputStream(buffer, offset, length), enc);
try {
/* Read the input */
int numread = lastReader.read(outbuf, 0, size);
if (numread<size) {
// this may happen only if the last character is truncated
// (say, it should be of 3 bytes, but there are only 2).
lastReader.read(outbuf, numread, size-numread);
}
/* Close the reader */
lastReader.close();
} catch(IOException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "IOException reading reader "+x.getMessage()
/* #endif */
);
}
/* And return the buffer */
return outbuf;
|
| public static char[] | byteToCharArray(byte[] buffer, int offset, int length)Convert a byte array to a char array
try {
return byteToCharArray(buffer, offset, length, defaultEncoding);
} catch(UnsupportedEncodingException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "Missing default encoding "+defaultEncoding
/* #endif */
);
}
|
| public static synchronized byte[] | charToByteArray(char[] buffer, int offset, int length, java.lang.String enc)Convert a char array to a byte array
//Because most cases use ISO8859_1 encoding, we can optimize this case.
if(enc.compareTo("ISO8859_1") == 0) {
char c;
byte[] value = new byte[length];
for(int i=0; i<length; i++) {
c = buffer[i+offset];
value[i] = (c <= 255) ? (byte)c : (byte)'?";
}
return value;
}
/* If we don't have a cached writer then make one */
if(lastWriterEncoding == null || !lastWriterEncoding.equals(enc)) {
lastWriter = getStreamWriterPrim(enc);
lastWriterEncoding = enc;
}
/* Ask the writer for the size the output will be */
int size = lastWriter.sizeOf(buffer, offset, length);
/* Get the output stream */
ByteArrayOutputStream os = new ByteArrayOutputStream(size);
/* Open the writer */
lastWriter.open(os, enc);
try {
/* Convert */
lastWriter.write(buffer, offset, length);
/* Close the writer */
lastWriter.close();
} catch(IOException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "IOException writing writer "+x.getMessage()
/* #endif */
);
}
/* Close the output stream */
try {
os.close();
} catch(IOException x) {};
/* Return the array */
return os.toByteArray();
|
| public static byte[] | charToByteArray(char[] buffer, int offset, int length)Convert a char array to a byte array
try {
return charToByteArray(buffer, offset, length, defaultEncoding);
} catch(UnsupportedEncodingException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "Missing default encoding "+defaultEncoding
/* #endif */
);
}
|
| public static java.io.Reader | getStreamReader(java.io.InputStream is)Get a reader for an InputStream
/* Get the default encoding name */
defaultEncoding = System.getProperty("microedition.encoding");
if (defaultEncoding == null) {
defaultEncoding = "ISO8859_1";
}
/* Get the default encoding name */
defaultMEPath = System.getProperty("com.sun.cldc.i18n.Helper.i18npath");
if (defaultMEPath == null) {
defaultMEPath = "com.sun.cldc.i18n.j2me";
}
try {
return getStreamReader(is, defaultEncoding);
} catch(UnsupportedEncodingException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "Missing default encoding "+defaultEncoding
/* #endif */
);
}
|
| public static java.io.Reader | getStreamReader(java.io.InputStream is, java.lang.String name)Get a reader for an InputStream
/* Test for null arguments */
if(is == null || name == null) {
throw new NullPointerException();
}
/* Get the reader from the encoding */
StreamReader fr = getStreamReaderPrim(name);
/* Open the connection and return*/
return fr.open(is, name);
|
| private static java.lang.Object | getStreamReaderOrWriter(java.lang.String name, java.lang.String suffix)
if (name == null) {
throw new NullPointerException();
}
name = internalNameForEncoding(name);
try {
String className;
/* Get the reader class name */
className = defaultMEPath + '." + name + suffix;
/* Using the decoder names lookup a class to implement the reader */
Class clazz = Class.forName(className);
/* Return a new instance */
return clazz.newInstance();
} catch(ClassNotFoundException x) {
throw new UnsupportedEncodingException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "Encoding "+name+" not found"
/* #endif */
);
} catch(InstantiationException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "InstantiationException "+x.getMessage()
/* #endif */
);
} catch(IllegalAccessException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "IllegalAccessException "+x.getMessage()
/* #endif */
);
}
|
| private static StreamReader | getStreamReaderPrim(java.lang.String name)Get a reader for an InputStream
try {
return (StreamReader)getStreamReaderOrWriter(name, "_Reader");
} catch(ClassCastException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "ClassCastException "+x.getMessage()
/* #endif */
);
}
|
| public static java.io.Writer | getStreamWriter(java.io.OutputStream os)Get a writer for an OutputStream
try {
return getStreamWriter(os, defaultEncoding);
} catch(UnsupportedEncodingException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "Missing default encoding "+defaultEncoding
/* #endif */
);
}
|
| public static java.io.Writer | getStreamWriter(java.io.OutputStream os, java.lang.String name)Get a writer for an OutputStream
/* Test for null arguments */
if(os == null || name == null) {
throw new NullPointerException();
}
/* Get the writer from the encoding */
StreamWriter sw = getStreamWriterPrim(name);
/* Open it on the output stream and return */
return sw.open(os, name);
|
| private static StreamWriter | getStreamWriterPrim(java.lang.String name)Get a writer for an OutputStream
try {
return (StreamWriter)getStreamReaderOrWriter(name, "_Writer");
} catch(ClassCastException x) {
throw new RuntimeException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "ClassCastException "+x.getMessage()
/* #endif */
);
}
|
| private static java.lang.String | internalNameForEncoding(java.lang.String encodingName)Get the internal name for an encoding.
String internalName;
String property;
internalName = normalizeEncodingName(encodingName);
// The preferred MIME name according to the IANA Charset Registry.
if (internalName.equals("US_ASCII")) {
/*
* US-ASCII is subclass of ISO-8859-1 so we do not need a
* separate reader for it.
*/
return "ISO8859_1";
}
// The preferred MIME name according to the IANA Charset Registry.
if (internalName.equals("ISO_8859_1")) {
return "ISO8859_1";
}
/*
* Since IANA character encoding names can start with a digit
* and that some Reader class names that do not match the standard
* name, we have a way to configure alternate names for encodings.
*
* Note: The names must normalized, digits, upper case only with "_"
* and "_" substituted for ":" and "-".
*/
property = System.getProperty(internalName + "_InternalEncodingName");
if (property != null) {
return property;
}
return internalName;
|
| private static java.lang.String | normalizeEncodingName(java.lang.String encodingName)Converts "-" and ":" in a string to "_" and converts the name
to upper case.
This is needed because the names of IANA character encodings have
characters that are not allowed for java class names and
IANA encoding names are not case sensitive.
StringBuffer normalizedName ;
char currentChar;
normalizedName = new StringBuffer(encodingName);
for (int i = 0; i < normalizedName.length(); i++) {
currentChar = normalizedName.charAt(i);
if (currentChar == '-" || currentChar == ':") {
normalizedName.setCharAt(i, '_");
} else {
normalizedName.setCharAt(i, Character.toUpperCase(currentChar));
}
}
return normalizedName.toString();
|
