io.netty_voltpatches.buffer.AdvancedLeakAwareCompositeByteBuf Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of voltdbclient Show documentation
Show all versions of voltdbclient Show documentation
VoltDB client interface libraries
/*
* Copyright 2016 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_voltpatches.buffer;
import static io.netty_voltpatches.buffer.AdvancedLeakAwareByteBuf.recordLeakNonRefCountingOperation;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.List;
import io.netty_voltpatches.util.ResourceLeak;
final class AdvancedLeakAwareCompositeByteBuf extends WrappedCompositeByteBuf {
private final ResourceLeak leak;
AdvancedLeakAwareCompositeByteBuf(CompositeByteBuf wrapped, ResourceLeak leak) {
super(wrapped);
this.leak = leak;
}
@Override
public ByteBuf order(ByteOrder endianness) {
recordLeakNonRefCountingOperation(leak);
if (order() == endianness) {
return this;
} else {
return new AdvancedLeakAwareByteBuf(super.order(endianness), leak);
}
}
@Override
public ByteBuf slice() {
recordLeakNonRefCountingOperation(leak);
return new AdvancedLeakAwareByteBuf(super.slice(), leak);
}
@Override
public ByteBuf slice(int index, int length) {
recordLeakNonRefCountingOperation(leak);
return new AdvancedLeakAwareByteBuf(super.slice(index, length), leak);
}
@Override
public ByteBuf duplicate() {
recordLeakNonRefCountingOperation(leak);
return new AdvancedLeakAwareByteBuf(super.duplicate(), leak);
}
@Override
public ByteBuf readSlice(int length) {
recordLeakNonRefCountingOperation(leak);
return new AdvancedLeakAwareByteBuf(super.readSlice(length), leak);
}
@Override
public CompositeByteBuf discardReadBytes() {
recordLeakNonRefCountingOperation(leak);
return super.discardReadBytes();
}
@Override
public CompositeByteBuf discardSomeReadBytes() {
recordLeakNonRefCountingOperation(leak);
return super.discardSomeReadBytes();
}
@Override
public CompositeByteBuf ensureWritable(int minWritableBytes) {
recordLeakNonRefCountingOperation(leak);
return super.ensureWritable(minWritableBytes);
}
@Override
public int ensureWritable(int minWritableBytes, boolean force) {
recordLeakNonRefCountingOperation(leak);
return super.ensureWritable(minWritableBytes, force);
}
@Override
public boolean getBoolean(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getBoolean(index);
}
@Override
public byte getByte(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getByte(index);
}
@Override
public short getUnsignedByte(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getUnsignedByte(index);
}
@Override
public short getShort(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getShort(index);
}
@Override
public int getUnsignedShort(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getUnsignedShort(index);
}
@Override
public int getMedium(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getMedium(index);
}
@Override
public int getUnsignedMedium(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getUnsignedMedium(index);
}
@Override
public int getInt(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getInt(index);
}
@Override
public long getUnsignedInt(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getUnsignedInt(index);
}
@Override
public long getLong(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getLong(index);
}
@Override
public char getChar(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getChar(index);
}
@Override
public float getFloat(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getFloat(index);
}
@Override
public double getDouble(int index) {
recordLeakNonRefCountingOperation(leak);
return super.getDouble(index);
}
@Override
public CompositeByteBuf getBytes(int index, ByteBuf dst) {
recordLeakNonRefCountingOperation(leak);
return super.getBytes(index, dst);
}
@Override
public CompositeByteBuf getBytes(int index, ByteBuf dst, int length) {
recordLeakNonRefCountingOperation(leak);
return super.getBytes(index, dst, length);
}
@Override
public CompositeByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
recordLeakNonRefCountingOperation(leak);
return super.getBytes(index, dst, dstIndex, length);
}
@Override
public CompositeByteBuf getBytes(int index, byte[] dst) {
recordLeakNonRefCountingOperation(leak);
return super.getBytes(index, dst);
}
@Override
public CompositeByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
recordLeakNonRefCountingOperation(leak);
return super.getBytes(index, dst, dstIndex, length);
}
@Override
public CompositeByteBuf getBytes(int index, ByteBuffer dst) {
recordLeakNonRefCountingOperation(leak);
return super.getBytes(index, dst);
}
@Override
public CompositeByteBuf getBytes(int index, OutputStream out, int length) throws IOException {
recordLeakNonRefCountingOperation(leak);
return super.getBytes(index, out, length);
}
@Override
public int getBytes(int index, GatheringByteChannel out, int length) throws IOException {
recordLeakNonRefCountingOperation(leak);
return super.getBytes(index, out, length);
}
@Override
public CompositeByteBuf setBoolean(int index, boolean value) {
recordLeakNonRefCountingOperation(leak);
return super.setBoolean(index, value);
}
@Override
public CompositeByteBuf setByte(int index, int value) {
recordLeakNonRefCountingOperation(leak);
return super.setByte(index, value);
}
@Override
public CompositeByteBuf setShort(int index, int value) {
recordLeakNonRefCountingOperation(leak);
return super.setShort(index, value);
}
@Override
public CompositeByteBuf setMedium(int index, int value) {
recordLeakNonRefCountingOperation(leak);
return super.setMedium(index, value);
}
@Override
public CompositeByteBuf setInt(int index, int value) {
recordLeakNonRefCountingOperation(leak);
return super.setInt(index, value);
}
@Override
public CompositeByteBuf setLong(int index, long value) {
recordLeakNonRefCountingOperation(leak);
return super.setLong(index, value);
}
@Override
public CompositeByteBuf setChar(int index, int value) {
recordLeakNonRefCountingOperation(leak);
return super.setChar(index, value);
}
@Override
public CompositeByteBuf setFloat(int index, float value) {
recordLeakNonRefCountingOperation(leak);
return super.setFloat(index, value);
}
@Override
public CompositeByteBuf setDouble(int index, double value) {
recordLeakNonRefCountingOperation(leak);
return super.setDouble(index, value);
}
@Override
public CompositeByteBuf setBytes(int index, ByteBuf src) {
recordLeakNonRefCountingOperation(leak);
return super.setBytes(index, src);
}
@Override
public CompositeByteBuf setBytes(int index, ByteBuf src, int length) {
recordLeakNonRefCountingOperation(leak);
return super.setBytes(index, src, length);
}
@Override
public CompositeByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
recordLeakNonRefCountingOperation(leak);
return super.setBytes(index, src, srcIndex, length);
}
@Override
public CompositeByteBuf setBytes(int index, byte[] src) {
recordLeakNonRefCountingOperation(leak);
return super.setBytes(index, src);
}
@Override
public CompositeByteBuf setBytes(int index, byte[] src, int srcIndex, int length) {
recordLeakNonRefCountingOperation(leak);
return super.setBytes(index, src, srcIndex, length);
}
@Override
public CompositeByteBuf setBytes(int index, ByteBuffer src) {
recordLeakNonRefCountingOperation(leak);
return super.setBytes(index, src);
}
@Override
public int setBytes(int index, InputStream in, int length) throws IOException {
recordLeakNonRefCountingOperation(leak);
return super.setBytes(index, in, length);
}
@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
recordLeakNonRefCountingOperation(leak);
return super.setBytes(index, in, length);
}
@Override
public CompositeByteBuf setZero(int index, int length) {
recordLeakNonRefCountingOperation(leak);
return super.setZero(index, length);
}
@Override
public boolean readBoolean() {
recordLeakNonRefCountingOperation(leak);
return super.readBoolean();
}
@Override
public byte readByte() {
recordLeakNonRefCountingOperation(leak);
return super.readByte();
}
@Override
public short readUnsignedByte() {
recordLeakNonRefCountingOperation(leak);
return super.readUnsignedByte();
}
@Override
public short readShort() {
recordLeakNonRefCountingOperation(leak);
return super.readShort();
}
@Override
public int readUnsignedShort() {
recordLeakNonRefCountingOperation(leak);
return super.readUnsignedShort();
}
@Override
public int readMedium() {
recordLeakNonRefCountingOperation(leak);
return super.readMedium();
}
@Override
public int readUnsignedMedium() {
recordLeakNonRefCountingOperation(leak);
return super.readUnsignedMedium();
}
@Override
public int readInt() {
recordLeakNonRefCountingOperation(leak);
return super.readInt();
}
@Override
public long readUnsignedInt() {
recordLeakNonRefCountingOperation(leak);
return super.readUnsignedInt();
}
@Override
public long readLong() {
recordLeakNonRefCountingOperation(leak);
return super.readLong();
}
@Override
public char readChar() {
recordLeakNonRefCountingOperation(leak);
return super.readChar();
}
@Override
public float readFloat() {
recordLeakNonRefCountingOperation(leak);
return super.readFloat();
}
@Override
public double readDouble() {
recordLeakNonRefCountingOperation(leak);
return super.readDouble();
}
@Override
public ByteBuf readBytes(int length) {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(length);
}
@Override
public CompositeByteBuf readBytes(ByteBuf dst) {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(dst);
}
@Override
public CompositeByteBuf readBytes(ByteBuf dst, int length) {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(dst, length);
}
@Override
public CompositeByteBuf readBytes(ByteBuf dst, int dstIndex, int length) {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(dst, dstIndex, length);
}
@Override
public CompositeByteBuf readBytes(byte[] dst) {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(dst);
}
@Override
public CompositeByteBuf readBytes(byte[] dst, int dstIndex, int length) {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(dst, dstIndex, length);
}
@Override
public CompositeByteBuf readBytes(ByteBuffer dst) {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(dst);
}
@Override
public CompositeByteBuf readBytes(OutputStream out, int length) throws IOException {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(out, length);
}
@Override
public int readBytes(GatheringByteChannel out, int length) throws IOException {
recordLeakNonRefCountingOperation(leak);
return super.readBytes(out, length);
}
@Override
public CompositeByteBuf skipBytes(int length) {
recordLeakNonRefCountingOperation(leak);
return super.skipBytes(length);
}
@Override
public CompositeByteBuf writeBoolean(boolean value) {
recordLeakNonRefCountingOperation(leak);
return super.writeBoolean(value);
}
@Override
public CompositeByteBuf writeByte(int value) {
recordLeakNonRefCountingOperation(leak);
return super.writeByte(value);
}
@Override
public CompositeByteBuf writeShort(int value) {
recordLeakNonRefCountingOperation(leak);
return super.writeShort(value);
}
@Override
public CompositeByteBuf writeMedium(int value) {
recordLeakNonRefCountingOperation(leak);
return super.writeMedium(value);
}
@Override
public CompositeByteBuf writeInt(int value) {
recordLeakNonRefCountingOperation(leak);
return super.writeInt(value);
}
@Override
public CompositeByteBuf writeLong(long value) {
recordLeakNonRefCountingOperation(leak);
return super.writeLong(value);
}
@Override
public CompositeByteBuf writeChar(int value) {
recordLeakNonRefCountingOperation(leak);
return super.writeChar(value);
}
@Override
public CompositeByteBuf writeFloat(float value) {
recordLeakNonRefCountingOperation(leak);
return super.writeFloat(value);
}
@Override
public CompositeByteBuf writeDouble(double value) {
recordLeakNonRefCountingOperation(leak);
return super.writeDouble(value);
}
@Override
public CompositeByteBuf writeBytes(ByteBuf src) {
recordLeakNonRefCountingOperation(leak);
return super.writeBytes(src);
}
@Override
public CompositeByteBuf writeBytes(ByteBuf src, int length) {
recordLeakNonRefCountingOperation(leak);
return super.writeBytes(src, length);
}
@Override
public CompositeByteBuf writeBytes(ByteBuf src, int srcIndex, int length) {
recordLeakNonRefCountingOperation(leak);
return super.writeBytes(src, srcIndex, length);
}
@Override
public CompositeByteBuf writeBytes(byte[] src) {
recordLeakNonRefCountingOperation(leak);
return super.writeBytes(src);
}
@Override
public CompositeByteBuf writeBytes(byte[] src, int srcIndex, int length) {
recordLeakNonRefCountingOperation(leak);
return super.writeBytes(src, srcIndex, length);
}
@Override
public CompositeByteBuf writeBytes(ByteBuffer src) {
recordLeakNonRefCountingOperation(leak);
return super.writeBytes(src);
}
@Override
public int writeBytes(InputStream in, int length) throws IOException {
recordLeakNonRefCountingOperation(leak);
return super.writeBytes(in, length);
}
@Override
public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
recordLeakNonRefCountingOperation(leak);
return super.writeBytes(in, length);
}
@Override
public CompositeByteBuf writeZero(int length) {
recordLeakNonRefCountingOperation(leak);
return super.writeZero(length);
}
@Override
public int indexOf(int fromIndex, int toIndex, byte value) {
recordLeakNonRefCountingOperation(leak);
return super.indexOf(fromIndex, toIndex, value);
}
@Override
public int bytesBefore(byte value) {
recordLeakNonRefCountingOperation(leak);
return super.bytesBefore(value);
}
@Override
public int bytesBefore(int length, byte value) {
recordLeakNonRefCountingOperation(leak);
return super.bytesBefore(length, value);
}
@Override
public int bytesBefore(int index, int length, byte value) {
recordLeakNonRefCountingOperation(leak);
return super.bytesBefore(index, length, value);
}
@Override
public int forEachByte(ByteBufProcessor processor) {
recordLeakNonRefCountingOperation(leak);
return super.forEachByte(processor);
}
@Override
public int forEachByte(int index, int length, ByteBufProcessor processor) {
recordLeakNonRefCountingOperation(leak);
return super.forEachByte(index, length, processor);
}
@Override
public int forEachByteDesc(ByteBufProcessor processor) {
recordLeakNonRefCountingOperation(leak);
return super.forEachByteDesc(processor);
}
@Override
public int forEachByteDesc(int index, int length, ByteBufProcessor processor) {
recordLeakNonRefCountingOperation(leak);
return super.forEachByteDesc(index, length, processor);
}
@Override
public ByteBuf copy() {
recordLeakNonRefCountingOperation(leak);
return super.copy();
}
@Override
public ByteBuf copy(int index, int length) {
recordLeakNonRefCountingOperation(leak);
return super.copy(index, length);
}
@Override
public int nioBufferCount() {
recordLeakNonRefCountingOperation(leak);
return super.nioBufferCount();
}
@Override
public ByteBuffer nioBuffer() {
recordLeakNonRefCountingOperation(leak);
return super.nioBuffer();
}
@Override
public ByteBuffer nioBuffer(int index, int length) {
recordLeakNonRefCountingOperation(leak);
return super.nioBuffer(index, length);
}
@Override
public ByteBuffer[] nioBuffers() {
recordLeakNonRefCountingOperation(leak);
return super.nioBuffers();
}
@Override
public ByteBuffer[] nioBuffers(int index, int length) {
recordLeakNonRefCountingOperation(leak);
return super.nioBuffers(index, length);
}
@Override
public ByteBuffer internalNioBuffer(int index, int length) {
recordLeakNonRefCountingOperation(leak);
return super.internalNioBuffer(index, length);
}
@Override
public String toString(Charset charset) {
recordLeakNonRefCountingOperation(leak);
return super.toString(charset);
}
@Override
public String toString(int index, int length, Charset charset) {
recordLeakNonRefCountingOperation(leak);
return super.toString(index, length, charset);
}
@Override
public CompositeByteBuf capacity(int newCapacity) {
recordLeakNonRefCountingOperation(leak);
return super.capacity(newCapacity);
}
@Override
public CompositeByteBuf addComponent(ByteBuf buffer) {
recordLeakNonRefCountingOperation(leak);
return super.addComponent(buffer);
}
@Override
public CompositeByteBuf addComponents(ByteBuf... buffers) {
recordLeakNonRefCountingOperation(leak);
return super.addComponents(buffers);
}
@Override
public CompositeByteBuf addComponents(Iterable buffers) {
recordLeakNonRefCountingOperation(leak);
return super.addComponents(buffers);
}
@Override
public CompositeByteBuf addComponent(int cIndex, ByteBuf buffer) {
recordLeakNonRefCountingOperation(leak);
return super.addComponent(cIndex, buffer);
}
@Override
public CompositeByteBuf addComponents(int cIndex, ByteBuf... buffers) {
recordLeakNonRefCountingOperation(leak);
return super.addComponents(cIndex, buffers);
}
@Override
public CompositeByteBuf addComponents(int cIndex, Iterable buffers) {
recordLeakNonRefCountingOperation(leak);
return super.addComponents(cIndex, buffers);
}
@Override
public CompositeByteBuf addComponent(boolean increaseWriterIndex, ByteBuf buffer) {
recordLeakNonRefCountingOperation(leak);
return super.addComponent(increaseWriterIndex, buffer);
}
@Override
public CompositeByteBuf addComponents(boolean increaseWriterIndex, ByteBuf... buffers) {
recordLeakNonRefCountingOperation(leak);
return super.addComponents(increaseWriterIndex, buffers);
}
@Override
public CompositeByteBuf addComponents(boolean increaseWriterIndex, Iterable buffers) {
recordLeakNonRefCountingOperation(leak);
return super.addComponents(increaseWriterIndex, buffers);
}
@Override
public CompositeByteBuf addComponent(boolean increaseWriterIndex, int cIndex, ByteBuf buffer) {
recordLeakNonRefCountingOperation(leak);
return super.addComponent(increaseWriterIndex, cIndex, buffer);
}
@Override
public CompositeByteBuf removeComponent(int cIndex) {
recordLeakNonRefCountingOperation(leak);
return super.removeComponent(cIndex);
}
@Override
public CompositeByteBuf removeComponents(int cIndex, int numComponents) {
recordLeakNonRefCountingOperation(leak);
return super.removeComponents(cIndex, numComponents);
}
@Override
public Iterator iterator() {
recordLeakNonRefCountingOperation(leak);
return super.iterator();
}
@Override
public List decompose(int offset, int length) {
recordLeakNonRefCountingOperation(leak);
return super.decompose(offset, length);
}
@Override
public CompositeByteBuf consolidate() {
recordLeakNonRefCountingOperation(leak);
return super.consolidate();
}
@Override
public CompositeByteBuf discardReadComponents() {
recordLeakNonRefCountingOperation(leak);
return super.discardReadComponents();
}
@Override
public CompositeByteBuf consolidate(int cIndex, int numComponents) {
recordLeakNonRefCountingOperation(leak);
return super.consolidate(cIndex, numComponents);
}
@Override
public CompositeByteBuf retain() {
leak.record();
return super.retain();
}
@Override
public CompositeByteBuf retain(int increment) {
leak.record();
return super.retain(increment);
}
@Override
public boolean release() {
boolean deallocated = super.release();
if (deallocated) {
leak.close();
} else {
leak.record();
}
return deallocated;
}
@Override
public boolean release(int decrement) {
boolean deallocated = super.release(decrement);
if (deallocated) {
leak.close();
} else {
leak.record();
}
return deallocated;
}
}