ebfc4513e0
Please note that the build will fail at the moment due to various checkstyle violations which should be fixed soon
364 lines
11 KiB
Java
364 lines
11 KiB
Java
/*
|
|
* Copyright 2011 The Netty Project
|
|
*
|
|
* The Netty Project 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 io.netty.buffer;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.ByteOrder;
|
|
import java.nio.channels.ClosedChannelException;
|
|
import java.nio.channels.GatheringByteChannel;
|
|
import java.nio.channels.ScatteringByteChannel;
|
|
|
|
/**
|
|
* A NIO {@link ByteBuffer} based buffer. It is recommended to use {@link ChannelBuffers#directBuffer(int)}
|
|
* and {@link ChannelBuffers#wrappedBuffer(ByteBuffer)} instead of calling the
|
|
* constructor explicitly.
|
|
*/
|
|
public class ByteBufferBackedChannelBuffer extends AbstractChannelBuffer {
|
|
|
|
private final ByteBuffer buffer;
|
|
private final ByteOrder order;
|
|
private final int capacity;
|
|
|
|
/**
|
|
* Creates a new buffer which wraps the specified buffer's slice.
|
|
*/
|
|
public ByteBufferBackedChannelBuffer(ByteBuffer buffer) {
|
|
if (buffer == null) {
|
|
throw new NullPointerException("buffer");
|
|
}
|
|
|
|
order = buffer.order();
|
|
this.buffer = buffer.slice().order(order);
|
|
capacity = buffer.remaining();
|
|
writerIndex(capacity);
|
|
}
|
|
|
|
private ByteBufferBackedChannelBuffer(ByteBufferBackedChannelBuffer buffer) {
|
|
this.buffer = buffer.buffer;
|
|
order = buffer.order;
|
|
capacity = buffer.capacity;
|
|
setIndex(buffer.readerIndex(), buffer.writerIndex());
|
|
}
|
|
|
|
@Override
|
|
public ChannelBufferFactory factory() {
|
|
if (buffer.isDirect()) {
|
|
return DirectChannelBufferFactory.getInstance(order());
|
|
} else {
|
|
return HeapChannelBufferFactory.getInstance(order());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isDirect() {
|
|
return buffer.isDirect();
|
|
}
|
|
|
|
@Override
|
|
public ByteOrder order() {
|
|
return order;
|
|
}
|
|
|
|
@Override
|
|
public int capacity() {
|
|
return capacity;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasArray() {
|
|
return buffer.hasArray();
|
|
}
|
|
|
|
@Override
|
|
public byte[] array() {
|
|
return buffer.array();
|
|
}
|
|
|
|
@Override
|
|
public int arrayOffset() {
|
|
return buffer.arrayOffset();
|
|
}
|
|
|
|
@Override
|
|
public byte getByte(int index) {
|
|
return buffer.get(index);
|
|
}
|
|
|
|
@Override
|
|
public short getShort(int index) {
|
|
return buffer.getShort(index);
|
|
}
|
|
|
|
@Override
|
|
public int getUnsignedMedium(int index) {
|
|
return (getByte(index) & 0xff) << 16 |
|
|
(getByte(index + 1) & 0xff) << 8 |
|
|
(getByte(index + 2) & 0xff) << 0;
|
|
}
|
|
|
|
@Override
|
|
public int getInt(int index) {
|
|
return buffer.getInt(index);
|
|
}
|
|
|
|
@Override
|
|
public long getLong(int index) {
|
|
return buffer.getLong(index);
|
|
}
|
|
|
|
@Override
|
|
public void getBytes(int index, ChannelBuffer dst, int dstIndex, int length) {
|
|
if (dst instanceof ByteBufferBackedChannelBuffer) {
|
|
ByteBufferBackedChannelBuffer bbdst = (ByteBufferBackedChannelBuffer) dst;
|
|
ByteBuffer data = bbdst.buffer.duplicate();
|
|
|
|
data.limit(dstIndex + length).position(dstIndex);
|
|
getBytes(index, data);
|
|
} else if (buffer.hasArray()) {
|
|
dst.setBytes(dstIndex, buffer.array(), index + buffer.arrayOffset(), length);
|
|
} else {
|
|
dst.setBytes(dstIndex, this, index, length);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void getBytes(int index, byte[] dst, int dstIndex, int length) {
|
|
ByteBuffer data = buffer.duplicate();
|
|
try {
|
|
data.limit(index + length).position(index);
|
|
} catch (IllegalArgumentException e) {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
data.get(dst, dstIndex, length);
|
|
}
|
|
|
|
@Override
|
|
public void getBytes(int index, ByteBuffer dst) {
|
|
ByteBuffer data = buffer.duplicate();
|
|
int bytesToCopy = Math.min(capacity() - index, dst.remaining());
|
|
try {
|
|
data.limit(index + bytesToCopy).position(index);
|
|
} catch (IllegalArgumentException e) {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
dst.put(data);
|
|
}
|
|
|
|
@Override
|
|
public void setByte(int index, int value) {
|
|
buffer.put(index, (byte) value);
|
|
}
|
|
|
|
@Override
|
|
public void setShort(int index, int value) {
|
|
buffer.putShort(index, (short) value);
|
|
}
|
|
|
|
@Override
|
|
public void setMedium(int index, int value) {
|
|
setByte(index, (byte) (value >>> 16));
|
|
setByte(index + 1, (byte) (value >>> 8));
|
|
setByte(index + 2, (byte) (value >>> 0));
|
|
}
|
|
|
|
@Override
|
|
public void setInt(int index, int value) {
|
|
buffer.putInt(index, value);
|
|
}
|
|
|
|
@Override
|
|
public void setLong(int index, long value) {
|
|
buffer.putLong(index, value);
|
|
}
|
|
|
|
@Override
|
|
public void setBytes(int index, ChannelBuffer src, int srcIndex, int length) {
|
|
if (src instanceof ByteBufferBackedChannelBuffer) {
|
|
ByteBufferBackedChannelBuffer bbsrc = (ByteBufferBackedChannelBuffer) src;
|
|
ByteBuffer data = bbsrc.buffer.duplicate();
|
|
|
|
data.limit(srcIndex + length).position(srcIndex);
|
|
setBytes(index, data);
|
|
} else if (buffer.hasArray()) {
|
|
src.getBytes(srcIndex, buffer.array(), index + buffer.arrayOffset(), length);
|
|
} else {
|
|
src.getBytes(srcIndex, this, index, length);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setBytes(int index, byte[] src, int srcIndex, int length) {
|
|
ByteBuffer data = buffer.duplicate();
|
|
data.limit(index + length).position(index);
|
|
data.put(src, srcIndex, length);
|
|
}
|
|
|
|
@Override
|
|
public void setBytes(int index, ByteBuffer src) {
|
|
ByteBuffer data = buffer.duplicate();
|
|
data.limit(index + src.remaining()).position(index);
|
|
data.put(src);
|
|
}
|
|
|
|
@Override
|
|
public void getBytes(int index, OutputStream out, int length) throws IOException {
|
|
if (length == 0) {
|
|
return;
|
|
}
|
|
|
|
if (buffer.hasArray()) {
|
|
out.write(
|
|
buffer.array(),
|
|
index + buffer.arrayOffset(),
|
|
length);
|
|
} else {
|
|
byte[] tmp = new byte[length];
|
|
((ByteBuffer) buffer.duplicate().position(index)).get(tmp);
|
|
out.write(tmp);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getBytes(int index, GatheringByteChannel out, int length) throws IOException {
|
|
if (length == 0) {
|
|
return 0;
|
|
}
|
|
|
|
return out.write((ByteBuffer) buffer.duplicate().position(index).limit(index + length));
|
|
}
|
|
|
|
@Override
|
|
public int setBytes(int index, InputStream in, int length)
|
|
throws IOException {
|
|
|
|
int readBytes = 0;
|
|
|
|
if (buffer.hasArray()) {
|
|
index += buffer.arrayOffset();
|
|
do {
|
|
int localReadBytes = in.read(buffer.array(), index, length);
|
|
if (localReadBytes < 0) {
|
|
if (readBytes == 0) {
|
|
return -1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
readBytes += localReadBytes;
|
|
index += localReadBytes;
|
|
length -= localReadBytes;
|
|
} while (length > 0);
|
|
} else {
|
|
byte[] tmp = new byte[length];
|
|
int i = 0;
|
|
do {
|
|
int localReadBytes = in.read(tmp, i, tmp.length - i);
|
|
if (localReadBytes < 0) {
|
|
if (readBytes == 0) {
|
|
return -1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
readBytes += localReadBytes;
|
|
i += readBytes;
|
|
} while (i < tmp.length);
|
|
((ByteBuffer) buffer.duplicate().position(index)).put(tmp);
|
|
}
|
|
|
|
return readBytes;
|
|
}
|
|
|
|
@Override
|
|
public int setBytes(int index, ScatteringByteChannel in, int length)
|
|
throws IOException {
|
|
|
|
ByteBuffer slice = (ByteBuffer) buffer.duplicate().limit(index + length).position(index);
|
|
int readBytes = 0;
|
|
|
|
while (readBytes < length) {
|
|
int localReadBytes;
|
|
try {
|
|
localReadBytes = in.read(slice);
|
|
} catch (ClosedChannelException e) {
|
|
localReadBytes = -1;
|
|
}
|
|
if (localReadBytes < 0) {
|
|
if (readBytes == 0) {
|
|
return -1;
|
|
} else {
|
|
return readBytes;
|
|
}
|
|
} else if (localReadBytes == 0) {
|
|
break;
|
|
}
|
|
readBytes += localReadBytes;
|
|
}
|
|
|
|
return readBytes;
|
|
}
|
|
|
|
@Override
|
|
public ByteBuffer toByteBuffer(int index, int length) {
|
|
if (index == 0 && length == capacity()) {
|
|
return buffer.duplicate().order(order());
|
|
} else {
|
|
return ((ByteBuffer) buffer.duplicate().position(
|
|
index).limit(index + length)).slice().order(order());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ChannelBuffer slice(int index, int length) {
|
|
if (index == 0 && length == capacity()) {
|
|
ChannelBuffer slice = duplicate();
|
|
slice.setIndex(0, length);
|
|
return slice;
|
|
} else {
|
|
if (index >= 0 && length == 0) {
|
|
return ChannelBuffers.EMPTY_BUFFER;
|
|
}
|
|
return new ByteBufferBackedChannelBuffer(
|
|
((ByteBuffer) buffer.duplicate().position(
|
|
index).limit(index + length)).order(order()));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ChannelBuffer duplicate() {
|
|
return new ByteBufferBackedChannelBuffer(this);
|
|
}
|
|
|
|
@Override
|
|
public ChannelBuffer copy(int index, int length) {
|
|
ByteBuffer src;
|
|
try {
|
|
src = (ByteBuffer) buffer.duplicate().position(index).limit(index + length);
|
|
} catch (IllegalArgumentException e) {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
|
|
ByteBuffer dst = buffer.isDirect() ? ByteBuffer.allocateDirect(length) : ByteBuffer.allocate(length);
|
|
dst.put(src);
|
|
dst.order(order());
|
|
dst.clear();
|
|
return new ByteBufferBackedChannelBuffer(dst);
|
|
}
|
|
}
|