io.edurt.datacap.pinot.org.jboss.netty.buffer.EmptyChannelBuffer Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of datacap-shaded-pinot Show documentation
DataCap - Shaded for Apache Pinot
There is a newer version: 2024.03.6
/*
 * Copyright 2013 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.edurt.datacap.pinot.org.jboss.netty.buffer;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;

/**
 * An immutable empty buffer implementation. Typically used as a singleton via
 * {@link ChannelBuffers#EMPTY_BUFFER} and returned by {@link ChannelBuffers#buffer(int)} etc when
 * an empty buffer is requested.
 *
 * Note: For backwards compatibility, this class extends {@link BigEndianHeapChannelBuffer}.
 * However, it never makes any writes to the reader and writer indices, which avoids contention
 * when the singleton instance is used concurrently.
 */
public class EmptyChannelBuffer extends BigEndianHeapChannelBuffer {

    private static final byte[] BUFFER = {};

    EmptyChannelBuffer() {
        super(BUFFER);
    }

    @Override
    public void clear() {
    }

    @Override
    public void readerIndex(int readerIndex) {
        if (readerIndex != 0) {
            throw new IndexOutOfBoundsException("Invalid readerIndex: "
                    + readerIndex + " - Maximum is 0");
        }
    }

    @Override
    public void writerIndex(int writerIndex) {
        if (writerIndex != 0) {
            throw new IndexOutOfBoundsException("Invalid writerIndex: "
                    + writerIndex + " - Maximum is 0");
        }
    }

    @Override
    public void setIndex(int readerIndex, int writerIndex) {
        if (writerIndex != 0 || readerIndex != 0) {
            throw new IndexOutOfBoundsException("Invalid writerIndex: "
                    + writerIndex + " - Maximum is " + readerIndex + " or "
                    + capacity());
        }
    }

    @Override
    public void markReaderIndex() {
    }

    @Override
    public void resetReaderIndex() {
    }

    @Override
    public void markWriterIndex() {
    }

    @Override
    public void resetWriterIndex() {
    }

    @Override
    public void discardReadBytes() {
    }

    @Override
    public ChannelBuffer readBytes(int length) {
        checkReadableBytes(length);
        return this;
    }

    @Override
    public ChannelBuffer readSlice(int length) {
        checkReadableBytes(length);
        return this;
    }

    @Override
    public void readBytes(byte[] dst, int dstIndex, int length) {
        checkReadableBytes(length);
    }

    @Override
    public void readBytes(byte[] dst) {
        checkReadableBytes(dst.length);
    }

    @Override
    public void readBytes(ChannelBuffer dst) {
        checkReadableBytes(dst.writableBytes());
    }

    @Override
    public void readBytes(ChannelBuffer dst, int length) {
        checkReadableBytes(length);
    }

    @Override
    public void readBytes(ChannelBuffer dst, int dstIndex, int length) {
        checkReadableBytes(length);
    }

    @Override
    public void readBytes(ByteBuffer dst) {
        checkReadableBytes(dst.remaining());
    }

    @Override
    public int readBytes(GatheringByteChannel out, int length) throws IOException {
        checkReadableBytes(length);
        return 0;
    }

    @Override
    public void readBytes(OutputStream out, int length) throws IOException {
        checkReadableBytes(length);
    }

    @Override
    public void skipBytes(int length) {
        checkReadableBytes(length);
    }

    @Override
    public void writeBytes(byte[] src, int srcIndex, int length) {
        checkWritableBytes(length);
    }

    @Override
    public void writeBytes(ChannelBuffer src, int length) {
        checkWritableBytes(length);
    }

    @Override
    public void writeBytes(ChannelBuffer src, int srcIndex, int length) {
        checkWritableBytes(length);
    }

    @Override
    public void writeBytes(ByteBuffer src) {
        checkWritableBytes(src.remaining());
    }

    @Override
    public int writeBytes(InputStream in, int length) throws IOException {
        checkWritableBytes(length);
        return 0;
    }

    @Override
    public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
        checkWritableBytes(length);
        return 0;
    }

    @Override
    public void writeZero(int length) {
        checkWritableBytes(length);
    }

    /**
     * Throws an {@link IndexOutOfBoundsException} the length is not 0.
     */
    private void checkWritableBytes(int length) {
        if (length == 0) {
            return;
        }
        if (length > 0) {
            throw new IndexOutOfBoundsException("Writable bytes exceeded - Need "
                    + length + ", maximum is " + 0);
        } else {
            throw new IndexOutOfBoundsException("length < 0");
        }
    }

    /**
     * Throws an {@link IndexOutOfBoundsException} the length is not 0.
     */
    protected void checkReadableBytes(int length) {
        if (length == 0) {
            return;
        }
        if (length > 0) {
            throw new IndexOutOfBoundsException("Not enough readable bytes - Need "
                    + length + ", maximum is " + readableBytes());
        } else {
            throw new IndexOutOfBoundsException("length < 0");
        }
    }
}