/*
 * ====================================================================
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF 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.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 *
 */

package org.apache.http.nio.util;

import java.nio.BufferOverflowException;
import java.nio.ByteBuffer;

import org.apache.http.io.BufferInfo;
import org.apache.http.util.Args;

A buffer that expand its capacity on demand using ByteBufferAllocator interface. Internally, this class is backed by an instance of ByteBuffer.

This class is not thread safe.

Since:4.0
/** * A buffer that expand its capacity on demand using {@link ByteBufferAllocator} * interface. Internally, this class is backed by an instance of * {@link ByteBuffer}. * <p> * This class is not thread safe. * * @since 4.0 */
@SuppressWarnings("deprecation") public class ExpandableBuffer implements BufferInfo, org.apache.http.nio.util.BufferInfo { public final static int INPUT_MODE = 0; public final static int OUTPUT_MODE = 1; private final ByteBufferAllocator allocator; private int mode; protected ByteBuffer buffer = null;
Allocates buffer of the given size using the given allocator.
Params:
  • bufferSize – the buffer size.
  • allocator – allocator to be used to allocate ByteBuffers.
/** * Allocates buffer of the given size using the given allocator. * * @param bufferSize the buffer size. * @param allocator allocator to be used to allocate {@link ByteBuffer}s. */
public ExpandableBuffer(final int bufferSize, final ByteBufferAllocator allocator) { super(); Args.notNull(allocator, "ByteBuffer allocator"); this.allocator = allocator; this.buffer = allocator.allocate(bufferSize); this.mode = INPUT_MODE; }
Returns the current mode:

INPUT_MODE: the buffer is in the input mode.

OUTPUT_MODE: the buffer is in the output mode.

Returns:current input/output mode.
/** * Returns the current mode: * <p> * {@link #INPUT_MODE}: the buffer is in the input mode. * <p> * {@link #OUTPUT_MODE}: the buffer is in the output mode. * * @return current input/output mode. */
protected int getMode() { return this.mode; }
Sets output mode. The buffer can now be read from.
/** * Sets output mode. The buffer can now be read from. */
protected void setOutputMode() { if (this.mode != OUTPUT_MODE) { this.buffer.flip(); this.mode = OUTPUT_MODE; } }
Sets input mode. The buffer can now be written into.
/** * Sets input mode. The buffer can now be written into. */
protected void setInputMode() { if (this.mode != INPUT_MODE) { if (this.buffer.hasRemaining()) { this.buffer.compact(); } else { this.buffer.clear(); } this.mode = INPUT_MODE; } } private void expandCapacity(final int capacity) { final ByteBuffer oldbuffer = this.buffer; this.buffer = allocator.allocate(capacity); oldbuffer.flip(); this.buffer.put(oldbuffer); }
Expands buffer's capacity.
Throws:
  • BufferOverflowException – in case we get over the maximum allowed value
/** * Expands buffer's capacity. * * @throws BufferOverflowException in case we get over the maximum allowed value */
protected void expand() throws BufferOverflowException { int newCapacity = (this.buffer.capacity() + 1) << 1; if (newCapacity < 0) { final int vmBytes = Long.SIZE >> 3; final int javaBytes = 8; // this is to be checked when the JVM version changes @SuppressWarnings("unused") // we really need the 8 if we're going to make this foolproof final int headRoom = (vmBytes >= javaBytes) ? vmBytes : javaBytes; // Reason: In GC the size of objects is passed as int (2 bytes). // Then, the header size of the objects is added to the size. // Long has the longest header available. Object header seems to be linked to it. // Details: I added a minimum of 8 just to be safe and because 8 is used in // java.lang.Object.ArrayList: private static final int MAX_ARRAY_SIZE = 2147483639. // // WARNING: This code assumes you are providing enough heap room with -Xmx. // source of inspiration: https://bugs.openjdk.java.net/browse/JDK-8059914 newCapacity = Integer.MAX_VALUE - headRoom; if (newCapacity <= this.buffer.capacity()) { throw new BufferOverflowException(); } } expandCapacity(newCapacity); }
Ensures the buffer can accommodate the required capacity.
/** * Ensures the buffer can accommodate the required capacity. */
protected void ensureCapacity(final int requiredCapacity) { if (requiredCapacity > this.buffer.capacity()) { expandCapacity(requiredCapacity); } }
Returns the total capacity of this buffer.
Returns:total capacity.
/** * Returns the total capacity of this buffer. * * @return total capacity. */
@Override public int capacity() { return this.buffer.capacity(); }
Determines if the buffer contains data.
Returns:true if there is data in the buffer, false otherwise.
/** * Determines if the buffer contains data. * * @return {@code true} if there is data in the buffer, * {@code false} otherwise. */
public boolean hasData() { setOutputMode(); return this.buffer.hasRemaining(); }
Returns the length of this buffer.
Returns:buffer length.
/** * Returns the length of this buffer. * * @return buffer length. */
@Override public int length() { setOutputMode(); return this.buffer.remaining(); }
Returns available capacity of this buffer.
Returns:buffer length.
/** * Returns available capacity of this buffer. * * @return buffer length. */
@Override public int available() { setInputMode(); return this.buffer.remaining(); }
Clears buffer.
/** * Clears buffer. */
protected void clear() { this.buffer.clear(); this.mode = INPUT_MODE; } @Override public String toString() { final StringBuilder sb = new StringBuilder(); sb.append("[mode="); if (getMode() == INPUT_MODE) { sb.append("in"); } else { sb.append("out"); } sb.append(" pos="); sb.append(this.buffer.position()); sb.append(" lim="); sb.append(this.buffer.limit()); sb.append(" cap="); sb.append(this.buffer.capacity()); sb.append("]"); return sb.toString(); } }