mina api & 源码

/* * 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. * */ package org.apache.mina.core.buffer; import java.io.EOFException; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.ObjectStreamClass; import java.io.OutputStream; import java.io.StreamCorruptedException; import java.nio.BufferOverflowException; import java.nio.BufferUnderflowException; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.CharBuffer; import java.nio.DoubleBuffer; import java.nio.FloatBuffer; import java.nio.IntBuffer; import java.nio.LongBuffer; import java.nio.ShortBuffer; import java.nio.charset.CharacterCodingException; import java.nio.charset.CharsetDecoder; import java.nio.charset.CharsetEncoder; import java.nio.charset.CoderResult; import java.util.EnumSet; import java.util.Set; /** * A base implementation of {@link IoBuffer}. This implementation * assumes that {@link IoBuffer#buf()} always returns a correct NIO * {@link ByteBuffer} instance. Most implementations could * extend this class and implement their own buffer management mechanism. * * @author <a href="http://mina.apache.org">Apache MINA Project</a> * @see IoBufferAllocator */ public abstract class AbstractIoBuffer extends IoBuffer { /** Tells if a buffer has been created from an existing buffer */ private final boolean derived; /** A flag set to true if the buffer can extend automatically */ private boolean autoExpand; /** A flag set to true if the buffer can shrink automatically */ private boolean autoShrink; /** Tells if a buffer can be expanded */ private boolean recapacityAllowed = true; /** The minimum number of bytes the IoBuffer can hold */ private int minimumCapacity; /** A mask for a byte */ private static final long BYTE_MASK = 0xFFL; /** A mask for a short */ private static final long SHORT_MASK = 0xFFFFL; /** A mask for an int */ private static final long INT_MASK = 0xFFFFFFFFL; /** * We don't have any access to Buffer.markValue(), so we need to track it down, * which will cause small extra overhead. */ private int mark = -1; /** * Creates a new parent buffer. * * @param allocator The allocator to use to create new buffers * @param initialCapacity The initial buffer capacity when created */ protected AbstractIoBuffer(IoBufferAllocator allocator, int initialCapacity) { setAllocator(allocator); this.recapacityAllowed = true; this.derived = false; this.minimumCapacity = initialCapacity; } /** * Creates a new derived buffer. A derived buffer uses an existing * buffer properties - the allocator and capacity -. * * @param parent The buffer we get the properties from */ protected AbstractIoBuffer(AbstractIoBuffer parent) { setAllocator(parent.getAllocator()); this.recapacityAllowed = false; this.derived = true; this.minimumCapacity = parent.minimumCapacity; } /** * {@inheritDoc} */ @Override public final boolean isDirect() { return buf().isDirect(); } /** * {@inheritDoc} */ @Override public final boolean isReadOnly() { return buf().isReadOnly(); } /** * Sets the underlying NIO buffer instance. * * @param newBuf The buffer to store within this IoBuffer */ protected abstract void buf(ByteBuffer newBuf); /** * {@inheritDoc} */ @Override public final int minimumCapacity() { return minimumCapacity; } /** * {@inheritDoc} */ @Override public final IoBuffer minimumCapacity(int minimumCapacity) { if (minimumCapacity < 0) { throw new IllegalArgumentException("minimumCapacity: " + minimumCapacity); } this.minimumCapacity = minimumCapacity; return this; } /** * {@inheritDoc} */ @Override public final int capacity() { return buf().capacity(); } /** * {@inheritDoc} */ @Override public final IoBuffer capacity(int newCapacity) { if (!recapacityAllowed) { throw new IllegalStateException( "Derived buffers and their parent can't be expanded."); } // Allocate a new buffer and transfer all settings to it. if (newCapacity > capacity()) { // Expand: //// Save the state. int pos = position(); int limit = limit(); ByteOrder bo = order(); //// Reallocate. ByteBuffer oldBuf = buf(); ByteBuffer newBuf = getAllocator().allocateNioBuffer(newCapacity, isDirect()); oldBuf.clear(); newBuf.put(oldBuf); buf(newBuf); //// Restore the state. buf().limit(limit); if (mark >= 0) { buf().position(mark); buf().mark(); } buf().position(pos); buf().order(bo); } return this; } /** * {@inheritDoc} */ @Override public final boolean isAutoExpand() { return autoExpand && recapacityAllowed; } /** * {@inheritDoc} */ @Override public final boolean isAutoShrink() { return autoShrink && recapacityAllowed; } /** * {@inheritDoc} */ @Override public final boolean isDerived() { return derived; } /** * {@inheritDoc} */ @Override public final IoBuffer setAutoExpand(boolean autoExpand) { if (!recapacityAllowed) { throw new IllegalStateException( "Derived buffers and their parent can't be expanded."); } this.autoExpand = autoExpand; return this; } /** * {@inheritDoc} */ @Override public final IoBuffer setAutoShrink(boolean autoShrink) { if (!recapacityAllowed) { throw new IllegalStateException( "Derived buffers and their parent can't be shrinked."); } this.autoShrink = autoShrink; return this; } /** * {@inheritDoc} */ @Override public final IoBuffer expand(int expectedRemaining) { return expand(position(), expectedRemaining, false); } private IoBuffer expand(int expectedRemaining, boolean autoExpand) { return expand(position(), expectedRemaining, autoExpand); } /** * {@inheritDoc} */ @Override public final IoBuffer expand(int pos, int expectedRemaining) { return expand(pos, expectedRemaining, false); } private IoBuffer expand(int pos, int expectedRemaining, boolean autoExpand) { if (!recapacityAllowed) { throw new IllegalStateException( "Derived buffers and their parent can't be expanded."); } int end = pos + expectedRemaining; int newCapacity; if (autoExpand) { newCapacity = IoBuffer.normaliz