/*
 * Copyright (c) 2010, 2017 Oracle and/or its affiliates. All rights reserved.
 * Copyright 2004 The Apache Software Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.glassfish.grizzly.http.util;

import org.glassfish.grizzly.utils.Charsets;
import org.glassfish.grizzly.Grizzly;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.util.logging.Level;
import java.util.logging.Logger;

Efficient conversion of bytes to character . Now uses NIO directly
/** Efficient conversion of bytes to character . * * Now uses NIO directly */
public class B2CConverter {
Default Logger.
/** * Default Logger. */
private static final boolean IS_OLD_IO_MODE = Boolean.getBoolean(B2CConverter.class.getName() + ".blockingMode"); private static final Logger logger = Grizzly.logger(B2CConverter.class); private static final int MAX_NUMBER_OF_BYTES_PER_CHARACTER = 16; private CharsetDecoder decoder; private final ByteBuffer remainder = ByteBuffer.allocate(MAX_NUMBER_OF_BYTES_PER_CHARACTER); // Support old blocking converter private B2CConverterBlocking blockingConverter; protected B2CConverter() { init("US-ASCII"); }
Create a converter, with bytes going to a byte buffer
/** Create a converter, with bytes going to a byte buffer */
public B2CConverter(String encoding) throws IOException { init(encoding); } protected void init(String encoding) { if (IS_OLD_IO_MODE) { try { blockingConverter = new B2CConverterBlocking(encoding); } catch (IOException e) { throw new IllegalStateException("Can not initialize blocking converter"); } } else { Charset charset = Charsets.lookupCharset(encoding); decoder = charset.newDecoder(). onMalformedInput(CodingErrorAction.REPLACE). onUnmappableCharacter(CodingErrorAction.REPLACE); } }
Reset the internal state, empty the buffers. The encoding remain in effect, the internal buffers remain allocated.
/** Reset the internal state, empty the buffers. * The encoding remain in effect, the internal buffers remain allocated. */
public void recycle() { if (IS_OLD_IO_MODE) { blockingConverter.recycle(); } }
Convert a buffer of bytes into a chars
/** Convert a buffer of bytes into a chars */
public void convert(ByteChunk bb, CharChunk cb) throws IOException { convert(bb, cb, cb.getBuffer().length - cb.getEnd()); } public void convert(ByteChunk bb, CharChunk cb, int limit) throws IOException { if (IS_OLD_IO_MODE) { blockingConverter.convert(bb, cb, limit); return; } try { final int bbAvailable = bb.getEnd() - bb.getStart(); if (limit > bbAvailable) { limit = bbAvailable; } byte[] barr = bb.getBuffer(); int boff = bb.getStart(); ByteBuffer tmp_bb = ByteBuffer.wrap(barr, boff, limit); char[] carr = cb.getBuffer(); int coff = cb.getEnd(); final int remain = carr.length - coff; final int cbLimit = cb.getLimit(); if (remain < limit && (cbLimit < 0 || cbLimit > carr.length)) { cb.makeSpace(limit); carr = cb.getBuffer(); coff = cb.getEnd(); } CharBuffer tmp_cb = CharBuffer.wrap(carr, coff, carr.length - coff); if (remainder.position() > 0) { flushRemainder(tmp_bb, tmp_cb); } CoderResult cr = decoder.decode(tmp_bb, tmp_cb, false); cb.setEnd(tmp_cb.position()); while (cr == CoderResult.OVERFLOW) { cb.flushBuffer(); coff = cb.getEnd(); carr = cb.getBuffer(); tmp_cb = CharBuffer.wrap(carr, coff, carr.length - coff); cr = decoder.decode(tmp_bb, tmp_cb, false); cb.setEnd(tmp_cb.position()); } bb.setStart(tmp_bb.position()); if (tmp_bb.hasRemaining()) { remainder.put(tmp_bb); } if (cr != CoderResult.UNDERFLOW) { throw new IOException("Encoding error"); } } catch (IOException ex) { int debug = 0; if (debug > 0) { log("B2CConverter " + ex.toString()); } decoder.reset(); throw ex; } } // START CR 6309511
Character conversion of a US-ASCII MessageBytes.
/** * Character conversion of a US-ASCII MessageBytes. */
public static void convertASCII(MessageBytes mb) { if (IS_OLD_IO_MODE) { B2CConverterBlocking.convertASCII(mb); return; } // This is of course only meaningful for bytes if (mb.getType() != MessageBytes.T_BYTES) { return; } ByteChunk bc = mb.getByteChunk(); CharChunk cc = mb.getCharChunk(); int length = bc.getLength(); cc.allocate(length, -1); // Default encoding: fast conversion byte[] bbuf = bc.getBuffer(); char[] cbuf = cc.getBuffer(); int start = bc.getStart(); for (int i = 0; i < length; i++) { cbuf[i] = (char) (bbuf[i + start] & 0xff); } mb.setChars(cbuf, 0, length); } // END CR 6309511 public void reset() throws IOException { if (IS_OLD_IO_MODE) { blockingConverter.reset(); return; } if (decoder != null) { decoder.reset(); remainder.clear(); } } void log(String s) { if (logger.isLoggable(Level.FINEST)) { logger.log(Level.FINEST, "B2CConverter: " + s); } } private void flushRemainder(ByteBuffer tmp_bb, CharBuffer tmp_cb) { while(remainder.position() > 0 && tmp_bb.hasRemaining()) { remainder.put(tmp_bb.get()); remainder.flip(); CoderResult cr = decoder.decode(remainder, tmp_cb, false); if (cr == CoderResult.OVERFLOW) { // Shouldn't happen, because we allocated required output buffer before throw new IllegalStateException("CharChunk is not big enough"); } if (!remainder.hasRemaining()) { remainder.clear(); break; } remainder.compact(); } } }