org.elasticsearch.common.io.FastByteArrayOutputStream Maven / Gradle / Ivy
/* * Licensed to ElasticSearch and Shay Banon under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. ElasticSearch licenses this * file to you 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.elasticsearch.common.io; import java.io.IOException; import java.io.OutputStream; import java.io.UnsupportedEncodingException; import org.apache.lucene.util.ArrayUtil; import org.elasticsearch.common.bytes.BytesArray; import org.elasticsearch.common.bytes.BytesReference; import com.google.common.base.Charsets; /** * Similar to {@link java.io.ByteArrayOutputStream} just not synced. */ public class FastByteArrayOutputStream extends OutputStream implements BytesStream { /** * The buffer where data is stored. */ protected byte buf[]; /** * The number of valid bytes in the buffer. */ protected int count; /** * Creates a new byte array output stream. The buffer capacity is * initially 1024 bytes, though its size increases if necessary. * * ES: We use 1024 bytes since we mainly use this to build json/smile * content in memory, and rarely does the 32 byte default in ByteArrayOutputStream fits... */ public FastByteArrayOutputStream() { this(1024); } /** * Creates a new byte array output stream, with a buffer capacity of * the specified size, in bytes. * * @param size the initial size. * @throws IllegalArgumentException if size is negative. */ public FastByteArrayOutputStream(int size) { if (size < 0) { throw new IllegalArgumentException("Negative initial size: " + size); } buf = new byte[size]; } /** * Writes the specified byte to this byte array output stream. * * @param b the byte to be written. */ public void write(int b) { int newcount = count + 1; if (newcount > buf.length) { buf = ArrayUtil.grow(buf, newcount); } buf[count] = (byte) b; count = newcount; } /** * Writes
charsetlen
bytes from the specified byte array * starting at offsetoff
to this byte array output stream. * * NO checks for bounds, parameters must be ok! * * @param b the data. * @param off the start offset in the data. * @param len the number of bytes to write. */ public void write(byte b[], int off, int len) { if (len == 0) { return; } int newcount = count + len; if (newcount > buf.length) { buf = ArrayUtil.grow(buf, newcount); } System.arraycopy(b, off, buf, count, len); count = newcount; } /** * Writes the complete contents of this byte array output stream to * the specified output stream argument, as if by calling the output * stream's write method usingout.write(buf, 0, count)
. * * @param out the output stream to which to write the data. * @throws IOException if an I/O error occurs. */ public void writeTo(OutputStream out) throws IOException { out.write(buf, 0, count); } /** * Resets thecount
field of this byte array output * stream to zero, so that all currently accumulated output in the * output stream is discarded. The output stream can be used again, * reusing the already allocated buffer space. * * @see java.io.ByteArrayInputStream#count */ public void reset() { count = 0; } /** * Returns the underlying byte array. Note, use {@link #size()} in order to know * the length of it. */ @Override public BytesReference bytes() { return new BytesArray(buf, 0, count); } /** * Returns the current size of the buffer. * * @return the value of thecount
field, which is the number * of valid bytes in this output stream. * @see java.io.ByteArrayOutputStream#count */ public int size() { return count; } /** * Seeks back to the given position. Size will become the seeked location. */ public void seek(int position) { this.count = position; } /** * Converts the buffer's contents into a string decoding bytes using the * platform's default character set. The length of the new String * is a function of the character set, and hence may not be equal to the * size of the buffer. * *This method always replaces malformed-input and unmappable-character * sequences with the default replacement string for the platform's * default character set. The {@linkplain java.nio.charset.CharsetDecoder} * class should be used when more control over the decoding process is * required. * * @return String decoded from the buffer's contents. * @since JDK1.1 */ public String toString() { return new String(buf, 0, count, Charsets.UTF_8); } /** * Converts the buffer's contents into a string by decoding the bytes using * the specified {@link java.nio.charset.Charset charsetName}. The length of * the new String is a function of the charset, and hence may not be * equal to the length of the byte array. *
*This method always replaces malformed-input and unmappable-character * sequences with this charset's default replacement string. The {@link * java.nio.charset.CharsetDecoder} class should be used when more control * over the decoding process is required. * * @param charsetName the name of a supported * {@linkplain java.nio.charset.Charset
} * @return String decoded from the buffer's contents. * @throws java.io.UnsupportedEncodingException * If the named charset is not supported * @since JDK1.1 */ public String toString(String charsetName) throws UnsupportedEncodingException { return new String(buf, 0, count, charsetName); } /** * Closing a ByteArrayOutputStream has no effect. The methods in * this class can be called after the stream has been closed without * generating an IOException. * */ public void close() throws IOException { } }