public char[] encode(byte[] data, String encoding) throws IOException {
if (encoding == null) {
encoding = DEFAULT_ENCODING;
}
if (!Charset.isSupported(encoding)) throw new IOException("Unsupported encoding " + encoding);
Charset charset = Charset.forName(encoding);
CharsetDecoder cd =
charset
.newDecoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
int en = (int) (cd.maxCharsPerByte() * data.length);
char[] ca = new char[en];
ByteBuffer bb = ByteBuffer.wrap(data);
CharBuffer cb = CharBuffer.wrap(ca);
CoderResult cr = cd.decode(bb, cb, true);
if (!cr.isUnderflow()) {
cr.throwException();
}
cr = cd.flush(cb);
if (!cr.isUnderflow()) {
cr.throwException();
}
return trim(ca, cb.position());
}
@JRubyMethod
public IRubyObject convert(ThreadContext context, IRubyObject srcBuffer) {
if (!(srcBuffer instanceof RubyString)) {
throw context.runtime.newTypeError(srcBuffer, context.runtime.getString());
}
RubyString srcString = (RubyString) srcBuffer;
ByteList srcBL = srcString.getByteList();
if (srcBL.getRealSize() == 0) return context.runtime.newSymbol("source_buffer_empty");
ByteBuffer srcBB = ByteBuffer.wrap(srcBL.getUnsafeBytes(), srcBL.begin(), srcBL.getRealSize());
try {
CharBuffer srcCB =
CharBuffer.allocate((int) (srcDecoder.maxCharsPerByte() * srcBL.getRealSize()) + 1);
CoderResult decodeResult = srcDecoder.decode(srcBB, srcCB, true);
srcCB.flip();
ByteBuffer destBB =
ByteBuffer.allocate((int) (destEncoder.maxBytesPerChar() * srcCB.limit()) + 1);
CoderResult encodeResult = destEncoder.encode(srcCB, destBB, true);
destBB.flip();
byte[] destBytes = new byte[destBB.limit()];
destBB.get(destBytes);
srcDecoder.reset();
destEncoder.reset();
return context.runtime.newString(new ByteList(destBytes, destEncoding.getEncoding(), false));
} catch (Exception e) {
throw context.runtime.newRuntimeError(e.getLocalizedMessage());
}
}
/**
* Decode byte array as specified charset, then convert to UTF-8 by encoding as UTF8
*
* @param buf byte array to decode and convert to UTF8
* @param charsetName charset to decode byte array into
* @return
* @throws CharacterCodingException
*/
public static synchronized byte[] convertByteArrayToUTF8ByteArray(byte[] buf, String charsetName)
throws CharacterCodingException {
Charset cset;
cset = Charset.forName(charsetName); // detected character set name
CharsetDecoder csetDecoder = cset.newDecoder();
Charset utf8 = Charset.forName(Jeeves.ENCODING);
CharsetEncoder utf8Encoder = utf8.newEncoder();
ByteBuffer inputBuffer = ByteBuffer.wrap(buf);
// decode as detected character set
CharBuffer data = csetDecoder.decode(inputBuffer);
// encode as UTF-8
ByteBuffer outputBuffer = utf8Encoder.encode(data);
// remove any nulls from the end of the encoded data why? - this is a
// bug in the encoder???? could also be that the file has characters
// from more than one charset?
byte[] out = outputBuffer.array();
int length = out.length;
while (out[length - 1] == 0) length--;
byte[] result = new byte[length];
System.arraycopy(out, 0, result, 0, length);
// now return the converted bytes
return result;
}
public static void main(String args[]) throws Exception {
String inputFile = "samplein.txt";
String outputFile = "sampleout.txt";
RandomAccessFile inf = new RandomAccessFile(inputFile, "r");
RandomAccessFile outf = new RandomAccessFile(outputFile, "rw");
long inputLength = new File(inputFile).length();
FileChannel inc = inf.getChannel();
FileChannel outc = outf.getChannel();
MappedByteBuffer inputData = inc.map(FileChannel.MapMode.READ_ONLY, 0, inputLength);
Charset latin1 = Charset.forName("ISO-8859-1");
CharsetDecoder decoder = latin1.newDecoder();
CharsetEncoder encoder = latin1.newEncoder();
CharBuffer cb = decoder.decode(inputData);
// Process char data here
ByteBuffer outputData = encoder.encode(cb);
outc.write(outputData);
inf.close();
outf.close();
}
@SuppressFBWarnings("SUA_SUSPICIOUS_UNINITIALIZED_ARRAY")
public static String decode(
final CharsetDecoder cd, final byte[] ba, final int off, final int len) {
if (len == 0) {
return "";
}
int en = (int) (len * (double) cd.maxCharsPerByte());
char[] ca = Arrays.getCharsTmp(en);
if (cd instanceof ArrayDecoder) {
int clen = ((ArrayDecoder) cd).decode(ba, off, len, ca);
return new String(ca, 0, clen);
}
cd.reset();
ByteBuffer bb = ByteBuffer.wrap(ba, off, len);
CharBuffer cb = CharBuffer.wrap(ca);
try {
CoderResult cr = cd.decode(bb, cb, true);
if (!cr.isUnderflow()) {
cr.throwException();
}
cr = cd.flush(cb);
if (!cr.isUnderflow()) {
cr.throwException();
}
} catch (CharacterCodingException x) {
throw new Error(x);
}
return new String(ca, 0, cb.position());
}
public String getPayloadTracingString() {
if (null == payload || 0 == payload.length) return "no payload";
boolean text = true;
for (byte b : payload) {
if (' ' > b) {
switch (b) {
case '\t':
case '\n':
case '\r':
continue;
}
text = false;
break;
}
}
if (text) {
CharsetDecoder decoder = CoAP.UTF8_CHARSET.newDecoder();
decoder.onMalformedInput(CodingErrorAction.REPORT);
decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
ByteBuffer in = ByteBuffer.wrap(payload);
CharBuffer out = CharBuffer.allocate(24);
CoderResult result = decoder.decode(in, out, true);
decoder.flush(out);
out.flip();
if (CoderResult.OVERFLOW == result) {
return "\"" + out + "\".. " + payload.length + " bytes";
} else if (!result.isError()) {
return "\"" + out + "\"";
}
}
return Utils.toHexText(payload, 256);
}
private static String decode(final ByteBuffer b, final Charset charset)
throws CharacterCodingException {
final CharsetDecoder d = charset.newDecoder();
d.onMalformedInput(CodingErrorAction.REPORT);
d.onUnmappableCharacter(CodingErrorAction.REPORT);
return d.decode(b).toString();
}
/** Load synonyms with the given {@link SynonymMap.Parser} class. */
private SynonymMap loadSynonyms(
ResourceLoader loader, String cname, boolean dedup, Analyzer analyzer)
throws IOException, ParseException {
CharsetDecoder decoder =
Charset.forName("UTF-8")
.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
SynonymMap.Parser parser;
Class<? extends SynonymMap.Parser> clazz = loader.findClass(cname, SynonymMap.Parser.class);
try {
parser =
clazz
.getConstructor(boolean.class, boolean.class, Analyzer.class)
.newInstance(dedup, expand, analyzer);
} catch (Exception e) {
throw new RuntimeException(e);
}
File synonymFile = new File(synonyms);
if (synonymFile.exists()) {
decoder.reset();
parser.parse(new InputStreamReader(loader.openResource(synonyms), decoder));
} else {
List<String> files = splitFileNames(synonyms);
for (String file : files) {
decoder.reset();
parser.parse(new InputStreamReader(loader.openResource(file), decoder));
}
}
return parser.build();
}
char[] decode(byte[] ba, int off, int len) {
int en = (int) (cd.maxCharsPerByte() * len);
char[] ca = new char[en];
if (len == 0) return ca;
cd.reset();
ByteBuffer bb = ByteBuffer.wrap(ba, off, len);
CharBuffer cb = CharBuffer.wrap(ca);
try {
CoderResult cr = cd.decode(bb, cb, true);
if (!cr.isUnderflow()) cr.throwException();
cr = cd.flush(cb);
if (!cr.isUnderflow()) cr.throwException();
} catch (CharacterCodingException x) {
// Substitution is always enabled,
// so this shouldn't happen
throw new Error(x);
}
return trim(ca, cb.position());
}
private void assertValidReplaceKind(File repositoryRoot, long revision, SVNNodeKind kind)
throws SVNException {
final CharsetDecoder decoder = Charset.forName("UTF-8").newDecoder();
decoder.onMalformedInput(CodingErrorAction.IGNORE);
decoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
final File revisionNodeFile = new File(repositoryRoot, "db/revs/0/" + revision);
final InputStream in = SVNFileUtil.openFileForReading(revisionNodeFile);
final StringBuffer buffer = new StringBuffer();
final String replaceString = "replace-" + kind;
boolean replaceLineFound = false;
try {
while (true) {
final String line = SVNFileUtil.readLineFromStream(in, buffer, decoder);
if (line == null) {
break;
}
buffer.setLength(0);
if (line.indexOf(replaceString) >= 0) {
replaceLineFound = true;
break;
}
}
} catch (IOException e) {
SVNErrorManager.error(SVNErrorMessage.create(SVNErrorCode.UNKNOWN, e), e, SVNLogType.CLIENT);
} finally {
SVNFileUtil.closeFile(in);
}
Assert.assertTrue(
"Could not find 'replace-" + kind + "' string in revision node file", replaceLineFound);
}
public ByteBuffer convertChunk(
byte[] b, int offset, int length, ByteBuffer dst, boolean endOfInput) throws SVNException {
myInputByteBuffer = allocate(myInputByteBuffer, length);
myInputByteBuffer.put(b, offset, length);
myInputByteBuffer.flip();
myCharBuffer =
allocate(myCharBuffer, (int) (myDecoder.maxCharsPerByte() * myInputByteBuffer.remaining()));
CoderResult result = myDecoder.decode(myInputByteBuffer, myCharBuffer, endOfInput);
if (result.isError()) {
throwException(result);
} else if (result.isUnderflow()) {
myInputByteBuffer.compact();
} else {
myInputByteBuffer.clear();
}
myCharBuffer.flip();
dst = allocate(dst, (int) (myEncoder.maxBytesPerChar() * myCharBuffer.remaining()));
result = myEncoder.encode(myCharBuffer, dst, false);
if (result.isError()) {
throwException(result);
} else if (result.isUnderflow()) {
myCharBuffer.compact();
} else {
myCharBuffer.clear();
}
return dst;
}
public static void main(String[] arguments) {
try {
// read byte data into a byte buffer
String data = "friends.dat";
FileInputStream inData = new FileInputStream(data);
FileChannel inChannel = inData.getChannel();
long inSize = inChannel.size();
ByteBuffer source = ByteBuffer.allocate((int) inSize);
inChannel.read(source, 0);
source.position(0);
System.out.println("Original byte data:");
for (int i = 0; source.remaining() > 0; i++) {
System.out.print(source.get() + " ");
}
// convert byte data into character data
source.position(0);
Charset ascii = Charset.forName("US-ASCII");
CharsetDecoder toAscii = ascii.newDecoder();
CharBuffer destination = toAscii.decode(source);
destination.position(0);
System.out.println("\n\nNew character data:");
for (int i = 0; destination.remaining() > 0; i++) {
System.out.print(destination.get());
}
System.out.println();
} catch (FileNotFoundException fne) {
System.out.println(fne.getMessage());
} catch (IOException ioe) {
System.out.println(ioe.getMessage());
}
}
@Override
protected void onTextMessage(CharBuffer message) throws IOException {
String temp = message.toString();
JSONObject json = (JSONObject) JSONSerializer.toJSON(temp);
String type = json.getString("type").toLowerCase().replaceAll(" ", "");
String location = json.getString("location");
String lat = json.getString("lat");
String lng = json.getString("lng");
String radius = json.getString("radius");
String keywords = json.getString("keywords");
String result = null;
try {
if (type.equals("overview")) result = getOverViewData(location, lat, lng, radius, keywords);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
JSONObject jsonResult = new JSONObject();
jsonResult.put("error", "true");
result = jsonResult.toString();
}
if (result == null || result.equals("")) {
JSONObject jsonResult = new JSONObject();
jsonResult.put("error", "true");
result = jsonResult.toString();
}
Charset charset = Charset.forName("ISO-8859-1");
CharsetDecoder decoder = charset.newDecoder();
CharsetEncoder encoder = charset.newEncoder();
CharBuffer uCharBuffer = CharBuffer.wrap(result);
ByteBuffer bbuf = encoder.encode(uCharBuffer);
CharBuffer cbuf = decoder.decode(bbuf);
getWsOutbound().writeTextMessage(cbuf);
}
/**
* Read a 'n' bytes from buffer into a String where n is the framesize - offset so therefore
* cannot use this if there are other objects after it because it has no delimiter.
*
* <p>Must take into account the text encoding defined in the Encoding Object ID3 Text Frames
* often allow multiple strings seperated by the null char appropriate for the encoding.
*
* @param arr this is the buffer for the frame
* @param offset this is where to start reading in the buffer for this field
* @throws NullPointerException
* @throws IndexOutOfBoundsException
*/
public void readByteArray(byte[] arr, int offset) throws InvalidDataTypeException {
logger.finest("Reading from array from offset:" + offset);
// Get the Specified Decoder
String charSetName = getTextEncodingCharSet();
CharsetDecoder decoder = Charset.forName(charSetName).newDecoder();
decoder.reset();
// Decode sliced inBuffer
ByteBuffer inBuffer;
// #302 [dallen] truncating array manually since the decoder.decode() does not honor the offset
// in the in buffer
byte[] truncArr = new byte[arr.length - offset];
System.arraycopy(arr, offset, truncArr, 0, truncArr.length);
inBuffer = ByteBuffer.wrap(truncArr);
CharBuffer outBuffer = CharBuffer.allocate(arr.length - offset);
CoderResult coderResult = decoder.decode(inBuffer, outBuffer, true);
if (coderResult.isError()) {
logger.warning("Decoding error:" + coderResult.toString());
}
decoder.flush(outBuffer);
outBuffer.flip();
// If using UTF16 with BOM we then search through the text removing any BOMs that could exist
// for multiple values, BOM could be Big Endian or Little Endian
if (charSetName.equals(TextEncoding.CHARSET_UTF_16)) {
value = outBuffer.toString().replace("\ufeff", "").replace("\ufffe", "");
} else {
value = outBuffer.toString();
}
// SetSize, important this is correct for finding the next datatype
setSize(arr.length - offset);
logger.config("Read SizeTerminatedString:" + value + " size:" + size);
}
static boolean check(CharsetDecoder dec, byte[] bytes, boolean direct, int[] flow) {
int inPos = flow[0];
int inLen = flow[1];
int outPos = flow[2];
int outLen = flow[3];
int expedInPos = flow[4];
int expedOutPos = flow[5];
CoderResult expedCR = (flow[6] == 0) ? CoderResult.UNDERFLOW : CoderResult.OVERFLOW;
ByteBuffer bbf;
CharBuffer cbf;
if (direct) {
bbf = ByteBuffer.allocateDirect(inPos + bytes.length);
cbf = ByteBuffer.allocateDirect((outPos + outLen) * 2).asCharBuffer();
} else {
bbf = ByteBuffer.allocate(inPos + bytes.length);
cbf = CharBuffer.allocate(outPos + outLen);
}
bbf.position(inPos);
bbf.put(bytes).flip().position(inPos).limit(inPos + inLen);
cbf.position(outPos);
dec.reset();
CoderResult cr = dec.decode(bbf, cbf, false);
if (cr != expedCR || bbf.position() != expedInPos || cbf.position() != expedOutPos) {
System.out.printf("Expected(direct=%5b): [", direct);
for (int i : flow) System.out.print(" " + i);
System.out.println(
"] CR=" + cr + ", inPos=" + bbf.position() + ", outPos=" + cbf.position());
return false;
}
return true;
}
public static void main(String args[]) {
if (args.length != 1) {
System.err.println("Provide a filename");
return;
}
try {
// Map File from filename to byte buffer
FileInputStream input = new FileInputStream(args[0]);
FileChannel channel = input.getChannel();
int fileLength = (int) channel.size();
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, fileLength);
// Convert to character buffer
Charset charset = Charset.forName("ISO-8859-1");
CharsetDecoder decoder = charset.newDecoder();
CharBuffer charBuffer = decoder.decode(buffer);
// Create line pattern
// Pattern linePattern = Pattern.compile(".*$", Pattern.MULTILINE);
Pattern linePattern = Pattern.compile(".*$");
// Create word pattern
Pattern wordBreakPattern = Pattern.compile("[\\p{Punct}\\s}]");
System.out.println(wordBreakPattern);
// Match line pattern to buffer
Matcher lineMatcher = linePattern.matcher(charBuffer);
// Holder for longest word
String longest = "";
int lineCount = 0;
// For each line
while (lineMatcher.find()) {
lineCount++;
// Get line
String line = lineMatcher.group();
System.out.println(line);
// Get array of words on line
String words[] = wordBreakPattern.split(line);
for (String temp : words) {
System.out.println(temp);
}
// Look for longest word
for (int i = 0, n = words.length; i < n; i++) {
if (words[i].length() > longest.length()) {
longest = words[i];
}
}
}
// Report
System.out.println("Longest word: " + longest);
System.out.println("Total: " + lineCount + " lines.");
// Close
input.close();
} catch (IOException e) {
System.err.println("Error processing");
}
}
public String getString(byte[] bytes) {
CharsetDecoder utf8Decoder = UTF_8.newDecoder();
try {
return utf8Decoder.decode(ByteBuffer.wrap(bytes)).toString();
} catch (CharacterCodingException e) {
throw new MarshalException("invalid UTF8 bytes " + Arrays.toString(bytes));
}
}
public void listen() {
try {
int length;
int b;
String inputLine;
Charset utf = Charset.forName("UTF-8");
CharsetDecoder decoder = utf.newDecoder();
byte[] buffer = new byte[MAX_BUFFER_LENGTH];
ByteBuffer bytes;
while (isOpen) {
decoder.reset();
b = in.read();
if ((b & 0x80) == 0x80) {
length = 0;
while (b != -1 && (b & 0x80) == 0x80) {
b = in.read();
int bv = b & 0x7F;
length *= 128;
length += bv;
}
in.read(buffer, 0, length);
} else if (b == 0x00) {
b = in.read();
inputLine = "";
length = 0;
while (b != -1 && (b & 0xFF) != 0xFF) {
buffer[length] = (byte) b;
b = in.read();
length++;
if (length > MAX_BUFFER_LENGTH) {
bytes = ByteBuffer.wrap(buffer);
inputLine += decoder.decode(bytes).toString();
length = 0;
}
}
} else {
break;
}
bytes = ByteBuffer.wrap(buffer, 0, length);
inputLine = decoder.decode(bytes).toString();
if (b == -1) {
break;
}
messageReceived(inputLine);
}
connectionClosed();
out.close();
in.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
protected String sendAndReceive(byte[] payload) throws IOException {
ByteBuffer sbuf = ByteBuffer.wrap(payload);
ByteBuffer rbuf = ByteBuffer.allocateDirect(256);
CharsetDecoder rbufDecoder = Charset.forName("UTF-8").newDecoder();
StringBuilder response = new StringBuilder();
int ops = SelectionKey.OP_WRITE | SelectionKey.OP_READ;
if (this.channel.isConnectionPending()) {
ops = ops | SelectionKey.OP_CONNECT;
}
Selector selector = Selector.open();
try {
this.channel.register(selector, ops);
while (true) {
if (0 < selector.select(Client.POLLS_INTERVAL * 1000)) {
Iterator keys = selector.selectedKeys().iterator();
while (keys.hasNext()) {
SelectionKey key = (SelectionKey) keys.next();
SocketChannel ch = (SocketChannel) key.channel();
if (key.isConnectable()) {
// Just connected
ch.finishConnect();
}
if (key.isReadable() && !sbuf.hasRemaining()) {
// Receiving the response
while (0 < ch.read(rbuf)) {
rbuf.flip();
response.append(rbufDecoder.decode(rbuf).toString());
}
if (2 <= response.length()
&& response
.substring(response.length() - 2, response.length())
.equals(SocketClient.TERMINATOR)) {
response.setLength(response.length() - 2);
return response.toString();
} else if (0 == response.length()) {
throw new IOException("Connection lost");
}
}
if (key.isWritable() && sbuf.hasRemaining()) {
// Sending the request
while (0 < ch.write(sbuf) && sbuf.hasRemaining()) {
//
}
}
keys.remove();
}
}
}
} catch (java.lang.Exception e) {
throw new IOException("API communication failed: " + e.toString());
} finally {
selector.close();
}
}
/** Create a new WriterOutputStream which writes to the given writer. */
public WriterOutputStream(Writer writer) {
this.writer = writer;
decoder.reset();
decoder.onMalformedInput(CodingErrorAction.REPLACE);
decoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
inBuffer = ByteBuffer.allocate(4096);
inBuffer.clear();
outBuffer = CharBuffer.allocate(4096);
outBuffer.clear();
}
protected static String guessEncoding(Blob blob) throws IOException {
// encoding already known?
if (blob.getEncoding() != null) {
return null;
}
// bad mime type?
String mimeType = blob.getMimeType();
if (mimeType == null) {
return null;
}
if (!mimeType.startsWith("text/") && !mimeType.startsWith("application/xhtml")) {
// not a text file, we shouldn't be in the Note importer
return null;
}
byte[] bytes = blob.getByteArray();
List<String> charsets = Arrays.asList("utf-8", "iso-8859-1");
// charset specified in MIME type?
String CSEQ = "charset=";
int i = mimeType.indexOf(CSEQ);
if (i > 0) {
String onlyMimeType = mimeType.substring(0, i).replace(";", "").trim();
blob.setMimeType(onlyMimeType);
String charset = mimeType.substring(i + CSEQ.length());
i = charset.indexOf(";");
if (i > 0) {
charset = charset.substring(0, i);
}
charset = charset.trim().replace("\"", "");
charsets = new ArrayList<String>(charsets);
charsets.add(0, charset);
}
// resort to auto-detection
for (String charset : charsets) {
try {
Charset cs = Charset.forName(charset);
CharsetDecoder d =
cs.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
CharBuffer cb = d.decode(ByteBuffer.wrap(bytes));
return cb.toString();
} catch (IllegalArgumentException e) {
// illegal charset
} catch (CharacterCodingException e) {
// could not decode
}
}
// nothing worked, use platform
return null;
}
/**
* Attempts to convert text in a given character set to a Unicode string. Returns null on failure.
*
* @param text ByteBuffer containing the character array to convert.
* @param charsetName Character set it's in encoded in.
* @return: Unicode string on success, null on failure.
*/
@CalledByNative
private static String convertToUnicode(ByteBuffer text, String charsetName) {
try {
Charset charset = Charset.forName(charsetName);
CharsetDecoder decoder = charset.newDecoder();
// On invalid characters, this will throw an exception.
return decoder.decode(text).toString();
} catch (Exception e) {
return null;
}
}
/**
* This method should be called if the InputBuffer is being used in conjunction with a {@link
* java.io.Reader} implementation. If this method is not called, any character-based methods
* called on this <code>InputBuffer</code> will throw a {@link IllegalStateException}.
*/
public void processingChars() {
if (!processingChars) {
processingChars = true;
final String enc = httpHeader.getCharacterEncoding();
if (enc != null) {
encoding = enc;
final CharsetDecoder localDecoder = getDecoder();
averageCharsPerByte = localDecoder.averageCharsPerByte();
}
}
}
/** Decode a string into a ByteBuffer */
public static String fromByteBuffer(ByteBuffer bb, CharsetDecoder dec) {
if (bb.remaining() == 0) return "";
dec.reset();
CharBuffer cBuff = CharBuffer.allocate(bb.remaining());
CoderResult r = dec.decode(bb, cBuff, true);
if (r.isOverflow()) throw new InternalErrorException("fromByteBuffer: decode overflow (1)");
r = dec.flush(cBuff);
if (r.isOverflow()) throw new InternalErrorException("fromByteBuffer: decode overflow (2)");
cBuff.flip();
return cBuff.toString();
}
public static String byteBufferToString(ByteBuffer buffer) {
CharBuffer charBuffer = null;
try {
Charset charset = Charset.forName("UTF-8");
CharsetDecoder decoder = charset.newDecoder();
charBuffer = decoder.decode(buffer);
buffer.flip();
return charBuffer.toString();
} catch (Exception ex) {
ex.printStackTrace();
return null;
}
}
String toString(byte[] ba, int length) {
CharsetDecoder cd = decoder().reset();
int len = (int) (length * cd.maxCharsPerByte());
char[] ca = new char[len];
if (len == 0) return new String(ca);
ByteBuffer bb = ByteBuffer.wrap(ba, 0, length);
CharBuffer cb = CharBuffer.wrap(ca);
CoderResult cr = cd.decode(bb, cb, true);
if (!cr.isUnderflow()) throw new IllegalArgumentException(cr.toString());
cr = cd.flush(cb);
if (!cr.isUnderflow()) throw new IllegalArgumentException(cr.toString());
return new String(ca, 0, cb.position());
}
/**
* Flush the input buffer (byte buffer), as much as possible. This may leave a few undecoded bytes
* in the buffer.
*
* @param endOfInput true if there is no more input available
* @throws IOException
*/
private void flushInBuffer(boolean endOfInput) throws IOException {
// Prepare to read from the input buffer
inBuffer.flip();
CoderResult result = decoder.decode(inBuffer, outBuffer, endOfInput);
while (result.isOverflow()) {
flushOutBuffer();
result = decoder.decode(inBuffer, outBuffer, endOfInput);
}
// Remove processed input from the input buffer, and position for writing
inBuffer.compact();
}
public static String stringDecode(ByteBuffer oByteBuffer) {
CharBuffer oDecodedChat;
Charset charset = Charset.forName("utf8");
CharsetDecoder decoder = charset.newDecoder();
try {
oDecodedChat = decoder.decode(oByteBuffer);
return oDecodedChat.toString();
} catch (CharacterCodingException ex) {
ex.printStackTrace();
}
return null;
}
public String decode(ByteBuffer buffer) {
Charset charset = null;
CharsetDecoder decoder = null;
CharBuffer charBuffer = null;
try {
charset = Charset.forName("UTF-8");
decoder = charset.newDecoder();
charBuffer = decoder.decode(buffer);
return charBuffer.toString();
} catch (Exception ex) {
ex.printStackTrace();
return "";
}
}
static char[] decode(Charset cs, byte[] ba, int off, int len) {
// (1)We never cache the "external" cs, the only benefit of creating
// an additional StringDe/Encoder object to wrap it is to share the
// de/encode() method. These SD/E objects are short-lifed, the young-gen
// gc should be able to take care of them well. But the best approash
// is still not to generate them if not really necessary.
// (2)The defensive copy of the input byte/char[] has a big performance
// impact, as well as the outgoing result byte/char[]. Need to do the
// optimization check of (sm==null && classLoader0==null) for both.
// (3)getClass().getClassLoader0() is expensive
// (4)There might be a timing gap in isTrusted setting. getClassLoader0()
// is only chcked (and then isTrusted gets set) when (SM==null). It is
// possible that the SM==null for now but then SM is NOT null later
// when safeTrim() is invoked...the "safe" way to do is to redundant
// check (... && (isTrusted || SM == null || getClassLoader0())) in trim
// but it then can be argued that the SM is null when the opertaion
// is started...
CharsetDecoder cd = cs.newDecoder();
int en = scale(len, cd.maxCharsPerByte());
char[] ca = new char[en];
if (len == 0) return ca;
boolean isTrusted = false;
if (System.getSecurityManager() != null) {
if (!(isTrusted = (cs.getClass().getClassLoader0() == null))) {
ba = Arrays.copyOfRange(ba, off, off + len);
off = 0;
}
}
cd.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE)
.reset();
if (cd instanceof ArrayDecoder) {
int clen = ((ArrayDecoder) cd).decode(ba, off, len, ca);
return safeTrim(ca, clen, cs, isTrusted);
} else {
ByteBuffer bb = ByteBuffer.wrap(ba, off, len);
CharBuffer cb = CharBuffer.wrap(ca);
try {
CoderResult cr = cd.decode(bb, cb, true);
if (!cr.isUnderflow()) cr.throwException();
cr = cd.flush(cb);
if (!cr.isUnderflow()) cr.throwException();
} catch (CharacterCodingException x) {
// Substitution is always enabled,
// so this shouldn't happen
throw new Error(x);
}
return safeTrim(ca, cb.position(), cs, isTrusted);
}
}
