diff --git a/buffer/src/main/java/io/netty/buffer/b2/Allocator.java b/buffer/src/main/java/io/netty/buffer/b2/Allocator.java index a9ffbcf..8923c85 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/Allocator.java +++ b/buffer/src/main/java/io/netty/buffer/b2/Allocator.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -73,7 +73,7 @@ public interface Allocator extends AutoCloseable { @Override public Buf allocate(long size) { checkSize(size); - return man.allocateConfined(size, man.drop()); + return man.allocateConfined(size, man.drop(), null); } }; } @@ -84,7 +84,7 @@ public interface Allocator extends AutoCloseable { @Override public Buf allocate(long size) { checkSize(size); - return man.allocateConfined(size, man.drop()); + return man.allocateConfined(size, man.drop(), null); } }; } @@ -95,9 +95,7 @@ public interface Allocator extends AutoCloseable { @Override public Buf allocate(long size) { checkSize(size); - var buf = man.allocateConfined(size, man.drop()); - man.registerCleaner(buf, Statics.CLEANER); - return buf; + return man.allocateConfined(size, man.drop(), Statics.CLEANER); } }; } diff --git a/buffer/src/main/java/io/netty/buffer/b2/Buf.java b/buffer/src/main/java/io/netty/buffer/b2/Buf.java index ea9d59b..44182f3 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/Buf.java +++ b/buffer/src/main/java/io/netty/buffer/b2/Buf.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -20,7 +20,52 @@ import java.nio.ByteOrder; /** * A reference counted buffer API with separate reader and writer indexes. */ -public interface Buf extends Rc { +public interface Buf extends Rc, BufAccessors { + /** + * Compose the given sequence of buffers and present them as a single buffer. + *

+ * Note: The composite buffer increments the reference count on all the constituent buffers, + * and holds a reference to them until the composite buffer is deallocated. + * This means the constituent buffers must still have their outside-reference count decremented as normal. + * If the buffers are allocated for the purpose of participating in the composite buffer, + * then they should be closed as soon as the composite buffer has been created, like in this example: + * 

{@code
+     *     try (Buf a = allocator.allocate(size);
+     *          Buf b = allocator.allocate(size)) {
+     *         return Buf.compose(a, b); // Reference counts for 'a' and 'b' incremented here.
+     *     } // Reference count for 'a' and 'b' decremented here; composite buffer now holds the last references.
+     * }
+ *

+ * {@linkplain #send() Sending} a composite buffer implies sending all of its constituent buffers. + *

+ * All of the constituent buffers must have the same {@linkplain #order() byte order}. + * An exception will be thrown if you attempt to compose buffers that have different byte orders, + * and changing the byte order of the constituent buffers so they become inconsistent after construction, + * will result in unspecified behaviour. + *

+ * The read and write offsets of the constituent buffers must be arranged such that there are no "gaps" when viewed + * as a single connected chunk of memory. + * Specifically, there can be at most one buffer whose write offset is neither zero nor at capacity, + * and all buffers prior to it must have their write indexes at capacity, and all buffers after it must have a write + * offset of zero. + * Likewise, there can be at most one buffer whose read offset is neither zero nor at capacity, + * and all buffers prior to it must have their read indexes at capacity, and all buffers after it must have a read + * offset of zero. + * Furthermore, the sum of the read offsets must be less than or equal to the sum of the write offsets. + *

+ * Reads and writes to the composite buffer that modifies the read or write offsets, will also modify the relevant + * offsets in the constituent buffers. + *

+ * It is not a requirement that the buffers have the same size. + * + * @param bufs The buffers to compose into a single buffer view. + * @return A buffer composed of, and backed by, the given buffers. + * @throws IllegalArgumentException if the given buffers have an inconsistent {@linkplain #order() byte order}. + */ + static Buf compose(Buf... bufs) { + return new CompositeBuf(bufs); + } + /** * Change the default byte order of this buffer, and return this buffer. * @@ -79,12 +124,16 @@ public interface Buf extends Rc { /** * Returns the number of readable bytes which is equal to {@code (writerIndex() - readerIndex())}. */ - int readableBytes(); + default int readableBytes() { + return writerIndex() - readerIndex(); + } /** * Returns the number of writable bytes which is equal to {@code (capacity() - writerIndex())}. */ - int writableBytes(); + default int writableBytes() { + return capacity() - writerIndex(); + } /** * Fill the buffer with the given byte value. This method does not respect the {@link #readerIndex()} or {@link @@ -106,7 +155,7 @@ public interface Buf extends Rc { byte[] copy(); /** - * Give the native memory address backing this buffer, or return 0 if this is a heap backed buffer. + * Give the native memory address backing this buffer, or return 0 if this buffer has no native memory address. * @return The native memory address, if any, otherwise 0. */ long getNativeAddress(); @@ -141,597 +190,4 @@ public interface Buf extends Rc { * that is a view of the given region of this buffer. */ Buf slice(int offset, int length); - - // ### CODEGEN START primitive accessors interface - // - - /** - * Get the byte value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Byte#BYTES}. - * The value is read using a two's complement 8-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The byte value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Byte#BYTES}. - */ - byte readByte(); - - /** - * Get the byte value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using a two's complement 8-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The byte value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}. - */ - byte readByte(int roff); - - /** - * Get the unsigned byte value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Byte#BYTES}. - * The value is read using an unsigned two's complement 8-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The unsigned byte value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Byte#BYTES}. - */ - int readUnsignedByte(); - - /** - * Get the unsigned byte value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using an unsigned two's complement 8-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The unsigned byte value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}. - */ - int readUnsignedByte(int roff); - - /** - * Set the given byte value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Byte#BYTES}. - * The value is written using a two's complement 8-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The byte value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Byte#BYTES}. - */ - Buf writeByte(byte value); - - /** - * Set the given byte value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using a two's complement 8-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The byte value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}. - */ - Buf writeByte(int woff, byte value); - - /** - * Set the given unsigned byte value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Byte#BYTES}. - * The value is written using an unsigned two's complement 8-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Byte#BYTES}. - */ - Buf writeUnsignedByte(int value); - - /** - * Set the given unsigned byte value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using an unsigned two's complement 8-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}. - */ - Buf writeUnsignedByte(int woff, int value); - - /** - * Get the char value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by 2. - * The value is read using a 2-byte UTF-16 encoding, - * with the {@link #order() configured} default byte order. - * - * @return The char value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 2. - */ - char readChar(); - - /** - * Get the char value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using a 2-byte UTF-16 encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The char value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus 2. - */ - char readChar(int roff); - - /** - * Set the given char value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by 2. - * The value is written using a 2-byte UTF-16 encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The char value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 2. - */ - Buf writeChar(char value); - - /** - * Set the given char value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using a 2-byte UTF-16 encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The char value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus 2. - */ - Buf writeChar(int woff, char value); - - /** - * Get the short value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Short#BYTES}. - * The value is read using a two's complement 16-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The short value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Short#BYTES}. - */ - short readShort(); - - /** - * Get the short value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using a two's complement 16-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The short value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}. - */ - short readShort(int roff); - - /** - * Get the unsigned short value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Short#BYTES}. - * The value is read using an unsigned two's complement 16-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The unsigned short value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Short#BYTES}. - */ - int readUnsignedShort(); - - /** - * Get the unsigned short value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using an unsigned two's complement 16-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The unsigned short value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}. - */ - int readUnsignedShort(int roff); - - /** - * Set the given short value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Short#BYTES}. - * The value is written using a two's complement 16-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The short value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Short#BYTES}. - */ - Buf writeShort(short value); - - /** - * Set the given short value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using a two's complement 16-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The short value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}. - */ - Buf writeShort(int woff, short value); - - /** - * Set the given unsigned short value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Short#BYTES}. - * The value is written using an unsigned two's complement 16-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Short#BYTES}. - */ - Buf writeUnsignedShort(int value); - - /** - * Set the given unsigned short value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using an unsigned two's complement 16-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}. - */ - Buf writeUnsignedShort(int woff, int value); - - /** - * Get the int value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by 3. - * The value is read using a two's complement 24-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The int value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 3. - */ - int readMedium(); - - /** - * Get the int value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using a two's complement 24-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The int value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus 3. - */ - int readMedium(int roff); - - /** - * Get the unsigned int value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by 3. - * The value is read using an unsigned two's complement 24-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The unsigned int value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 3. - */ - int readUnsignedMedium(); - - /** - * Get the unsigned int value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using an unsigned two's complement 24-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The unsigned int value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus 3. - */ - int readUnsignedMedium(int roff); - - /** - * Set the given int value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by 3. - * The value is written using a two's complement 24-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 3. - */ - Buf writeMedium(int value); - - /** - * Set the given int value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using a two's complement 24-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus 3. - */ - Buf writeMedium(int woff, int value); - - /** - * Set the given unsigned int value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by 3. - * The value is written using an unsigned two's complement 24-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 3. - */ - Buf writeUnsignedMedium(int value); - - /** - * Set the given unsigned int value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using an unsigned two's complement 24-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus 3. - */ - Buf writeUnsignedMedium(int woff, int value); - - /** - * Get the int value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Integer#BYTES}. - * The value is read using a two's complement 32-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The int value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Integer#BYTES}. - */ - int readInt(); - - /** - * Get the int value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using a two's complement 32-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The int value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}. - */ - int readInt(int roff); - - /** - * Get the unsigned int value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Integer#BYTES}. - * The value is read using an unsigned two's complement 32-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The unsigned int value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Integer#BYTES}. - */ - long readUnsignedInt(); - - /** - * Get the unsigned int value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using an unsigned two's complement 32-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The unsigned int value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}. - */ - long readUnsignedInt(int roff); - - /** - * Set the given int value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Integer#BYTES}. - * The value is written using a two's complement 32-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Integer#BYTES}. - */ - Buf writeInt(int value); - - /** - * Set the given int value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using a two's complement 32-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The int value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}. - */ - Buf writeInt(int woff, int value); - - /** - * Set the given unsigned int value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Integer#BYTES}. - * The value is written using an unsigned two's complement 32-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The long value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Integer#BYTES}. - */ - Buf writeUnsignedInt(long value); - - /** - * Set the given unsigned int value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using an unsigned two's complement 32-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The long value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}. - */ - Buf writeUnsignedInt(int woff, long value); - - /** - * Get the float value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Float#BYTES}. - * The value is read using a 32-bit IEEE floating point encoding, - * with the {@link #order() configured} default byte order. - * - * @return The float value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Float#BYTES}. - */ - float readFloat(); - - /** - * Get the float value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using a 32-bit IEEE floating point encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The float value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Float#BYTES}. - */ - float readFloat(int roff); - - /** - * Set the given float value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Float#BYTES}. - * The value is written using a 32-bit IEEE floating point encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The float value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Float#BYTES}. - */ - Buf writeFloat(float value); - - /** - * Set the given float value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using a 32-bit IEEE floating point encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The float value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Float#BYTES}. - */ - Buf writeFloat(int woff, float value); - - /** - * Get the long value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Long#BYTES}. - * The value is read using a two's complement 64-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @return The long value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Long#BYTES}. - */ - long readLong(); - - /** - * Get the long value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using a two's complement 64-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The long value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Long#BYTES}. - */ - long readLong(int roff); - - /** - * Set the given long value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Long#BYTES}. - * The value is written using a two's complement 64-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The long value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Long#BYTES}. - */ - Buf writeLong(long value); - - /** - * Set the given long value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using a two's complement 64-bit encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The long value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Long#BYTES}. - */ - Buf writeLong(int woff, long value); - - /** - * Get the double value at the current {@link Buf#readerIndex()}, - * and increases the reader offset by {@link Double#BYTES}. - * The value is read using a 64-bit IEEE floating point encoding, - * with the {@link #order() configured} default byte order. - * - * @return The double value at the current reader offset. - * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Double#BYTES}. - */ - double readDouble(); - - /** - * Get the double value at the given reader offset. - * The {@link Buf#readerIndex()} is not modified. - * The value is read using a 64-bit IEEE floating point encoding, - * with the {@link #order() configured} default byte order. - * - * @param roff The read offset, an absolute index into this buffer, to read from. - * @return The double value at the given offset. - * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Double#BYTES}. - */ - double readDouble(int roff); - - /** - * Set the given double value at the current {@link Buf#writerIndex()}, - * and increase the writer offset by {@link Double#BYTES}. - * The value is written using a 64-bit IEEE floating point encoding, - * with the {@link #order() configured} default byte order. - * - * @param value The double value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Double#BYTES}. - */ - Buf writeDouble(double value); - - /** - * Set the given double value at the given write offset. The {@link Buf#writerIndex()} is not modified. - * The value is written using a 64-bit IEEE floating point encoding, - * with the {@link #order() configured} default byte order. - * - * @param woff The write offset, an absolute index into this buffer to write to. - * @param value The double value to write. - * @return This Buf. - * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or - * greater than or equal to {@link Buf#capacity()} minus {@link Double#BYTES}. - */ - Buf writeDouble(int woff, double value); - // - // ### CODEGEN END primitive accessors interface } \ No newline at end of file diff --git a/buffer/src/main/java/io/netty/buffer/b2/BufAccessors.java b/buffer/src/main/java/io/netty/buffer/b2/BufAccessors.java new file mode 100644 index 0000000..7394901 --- /dev/null +++ b/buffer/src/main/java/io/netty/buffer/b2/BufAccessors.java @@ -0,0 +1,616 @@ +/* + * Copyright 2020 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: + * + * https://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.b2; + +/** + * This interface is just the primitive data accessor methods that {@link Buf} exposes. + * It can be useful if you only need the data access methods, and perhaps wish to decorate or modify their behaviour. + * Usually, you'd use the {@link Buf} interface directly, since this lets you properly control the buffer reference count. + */ +public interface BufAccessors { + // ### CODEGEN START primitive accessors interface + // + + /** + * Get the byte value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Byte#BYTES}. + * The value is read using a two's complement 8-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The byte value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Byte#BYTES}. + */ + byte readByte(); + + /** + * Get the byte value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using a two's complement 8-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The byte value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}. + */ + byte readByte(int roff); + + /** + * Get the unsigned byte value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Byte#BYTES}. + * The value is read using an unsigned two's complement 8-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The unsigned byte value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Byte#BYTES}. + */ + int readUnsignedByte(); + + /** + * Get the unsigned byte value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using an unsigned two's complement 8-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The unsigned byte value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}. + */ + int readUnsignedByte(int roff); + + /** + * Set the given byte value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Byte#BYTES}. + * The value is written using a two's complement 8-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The byte value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Byte#BYTES}. + */ + Buf writeByte(byte value); + + /** + * Set the given byte value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using a two's complement 8-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The byte value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}. + */ + Buf writeByte(int woff, byte value); + + /** + * Set the given unsigned byte value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Byte#BYTES}. + * The value is written using an unsigned two's complement 8-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Byte#BYTES}. + */ + Buf writeUnsignedByte(int value); + + /** + * Set the given unsigned byte value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using an unsigned two's complement 8-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Byte#BYTES}. + */ + Buf writeUnsignedByte(int woff, int value); + + /** + * Get the char value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by 2. + * The value is read using a 2-byte UTF-16 encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The char value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 2. + */ + char readChar(); + + /** + * Get the char value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using a 2-byte UTF-16 encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The char value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus 2. + */ + char readChar(int roff); + + /** + * Set the given char value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by 2. + * The value is written using a 2-byte UTF-16 encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The char value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 2. + */ + Buf writeChar(char value); + + /** + * Set the given char value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using a 2-byte UTF-16 encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The char value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus 2. + */ + Buf writeChar(int woff, char value); + + /** + * Get the short value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Short#BYTES}. + * The value is read using a two's complement 16-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The short value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Short#BYTES}. + */ + short readShort(); + + /** + * Get the short value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using a two's complement 16-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The short value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}. + */ + short readShort(int roff); + + /** + * Get the unsigned short value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Short#BYTES}. + * The value is read using an unsigned two's complement 16-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The unsigned short value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Short#BYTES}. + */ + int readUnsignedShort(); + + /** + * Get the unsigned short value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using an unsigned two's complement 16-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The unsigned short value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}. + */ + int readUnsignedShort(int roff); + + /** + * Set the given short value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Short#BYTES}. + * The value is written using a two's complement 16-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The short value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Short#BYTES}. + */ + Buf writeShort(short value); + + /** + * Set the given short value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using a two's complement 16-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The short value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}. + */ + Buf writeShort(int woff, short value); + + /** + * Set the given unsigned short value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Short#BYTES}. + * The value is written using an unsigned two's complement 16-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Short#BYTES}. + */ + Buf writeUnsignedShort(int value); + + /** + * Set the given unsigned short value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using an unsigned two's complement 16-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Short#BYTES}. + */ + Buf writeUnsignedShort(int woff, int value); + + /** + * Get the int value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by 3. + * The value is read using a two's complement 24-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The int value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 3. + */ + int readMedium(); + + /** + * Get the int value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using a two's complement 24-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The int value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus 3. + */ + int readMedium(int roff); + + /** + * Get the unsigned int value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by 3. + * The value is read using an unsigned two's complement 24-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The unsigned int value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than 3. + */ + int readUnsignedMedium(); + + /** + * Get the unsigned int value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using an unsigned two's complement 24-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The unsigned int value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus 3. + */ + int readUnsignedMedium(int roff); + + /** + * Set the given int value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by 3. + * The value is written using a two's complement 24-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 3. + */ + Buf writeMedium(int value); + + /** + * Set the given int value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using a two's complement 24-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus 3. + */ + Buf writeMedium(int woff, int value); + + /** + * Set the given unsigned int value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by 3. + * The value is written using an unsigned two's complement 24-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than 3. + */ + Buf writeUnsignedMedium(int value); + + /** + * Set the given unsigned int value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using an unsigned two's complement 24-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus 3. + */ + Buf writeUnsignedMedium(int woff, int value); + + /** + * Get the int value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Integer#BYTES}. + * The value is read using a two's complement 32-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The int value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Integer#BYTES}. + */ + int readInt(); + + /** + * Get the int value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using a two's complement 32-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The int value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}. + */ + int readInt(int roff); + + /** + * Get the unsigned int value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Integer#BYTES}. + * The value is read using an unsigned two's complement 32-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The unsigned int value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Integer#BYTES}. + */ + long readUnsignedInt(); + + /** + * Get the unsigned int value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using an unsigned two's complement 32-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The unsigned int value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}. + */ + long readUnsignedInt(int roff); + + /** + * Set the given int value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Integer#BYTES}. + * The value is written using a two's complement 32-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Integer#BYTES}. + */ + Buf writeInt(int value); + + /** + * Set the given int value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using a two's complement 32-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The int value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}. + */ + Buf writeInt(int woff, int value); + + /** + * Set the given unsigned int value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Integer#BYTES}. + * The value is written using an unsigned two's complement 32-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The long value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Integer#BYTES}. + */ + Buf writeUnsignedInt(long value); + + /** + * Set the given unsigned int value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using an unsigned two's complement 32-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The long value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Integer#BYTES}. + */ + Buf writeUnsignedInt(int woff, long value); + + /** + * Get the float value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Float#BYTES}. + * The value is read using a 32-bit IEEE floating point encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The float value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Float#BYTES}. + */ + float readFloat(); + + /** + * Get the float value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using a 32-bit IEEE floating point encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The float value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Float#BYTES}. + */ + float readFloat(int roff); + + /** + * Set the given float value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Float#BYTES}. + * The value is written using a 32-bit IEEE floating point encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The float value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Float#BYTES}. + */ + Buf writeFloat(float value); + + /** + * Set the given float value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using a 32-bit IEEE floating point encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The float value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Float#BYTES}. + */ + Buf writeFloat(int woff, float value); + + /** + * Get the long value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Long#BYTES}. + * The value is read using a two's complement 64-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The long value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Long#BYTES}. + */ + long readLong(); + + /** + * Get the long value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using a two's complement 64-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The long value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Long#BYTES}. + */ + long readLong(int roff); + + /** + * Set the given long value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Long#BYTES}. + * The value is written using a two's complement 64-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The long value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Long#BYTES}. + */ + Buf writeLong(long value); + + /** + * Set the given long value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using a two's complement 64-bit encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The long value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Long#BYTES}. + */ + Buf writeLong(int woff, long value); + + /** + * Get the double value at the current {@link Buf#readerIndex()}, + * and increases the reader offset by {@link Double#BYTES}. + * The value is read using a 64-bit IEEE floating point encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @return The double value at the current reader offset. + * @throws IndexOutOfBoundsException If {@link Buf#readableBytes} is less than {@link Double#BYTES}. + */ + double readDouble(); + + /** + * Get the double value at the given reader offset. + * The {@link Buf#readerIndex()} is not modified. + * The value is read using a 64-bit IEEE floating point encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param roff The read offset, an absolute index into this buffer, to read from. + * @return The double value at the given offset. + * @throws IndexOutOfBoundsException if the given index is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Double#BYTES}. + */ + double readDouble(int roff); + + /** + * Set the given double value at the current {@link Buf#writerIndex()}, + * and increase the writer offset by {@link Double#BYTES}. + * The value is written using a 64-bit IEEE floating point encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param value The double value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException If {@link Buf#writableBytes} is less than {@link Double#BYTES}. + */ + Buf writeDouble(double value); + + /** + * Set the given double value at the given write offset. The {@link Buf#writerIndex()} is not modified. + * The value is written using a 64-bit IEEE floating point encoding, + * with the {@link Buf#order() configured} default byte order. + * + * @param woff The write offset, an absolute index into this buffer to write to. + * @param value The double value to write. + * @return This Buf. + * @throws IndexOutOfBoundsException if the given offset is out of bounds of the buffer, that is, less than 0 or + * greater than or equal to {@link Buf#capacity()} minus {@link Double#BYTES}. + */ + Buf writeDouble(int woff, double value); + // + // ### CODEGEN END primitive accessors interface +} \ No newline at end of file diff --git a/buffer/src/main/java/io/netty/buffer/b2/CompositeBuf.java b/buffer/src/main/java/io/netty/buffer/b2/CompositeBuf.java new file mode 100644 index 0000000..abe1603 --- /dev/null +++ b/buffer/src/main/java/io/netty/buffer/b2/CompositeBuf.java @@ -0,0 +1,1124 @@ +/* + * Copyright 2020 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: + * + * https://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.b2; + +import java.nio.ByteOrder; +import java.util.Arrays; + +final class CompositeBuf extends RcSupport implements Buf { + /** + * The max array size is JVM implementation dependant, but most seem to settle on {@code Integer.MAX_VALUE - 8}. + * We set the max composite buffer capacity to the same, since it would otherwise be impossible to create a + * non-composite copy of the buffer. + */ + private static final int MAX_CAPACITY = Integer.MAX_VALUE - 8; + private static final Drop COMPOSITE_DROP = new Drop() { + @Override + public void drop(CompositeBuf obj) { + for (Buf buf : obj.bufs) { + buf.close(); + } + } + }; + + private final TornBufAccessors tornBufAccessors; + private final boolean isSendable; + private Buf[] bufs; + private int[] offsets; // The offset, for the composite buffer, where each constituent buffer starts. + private int[] offsetSums; // The cumulative composite buffer offset. + private int capacity; + private int roff; + private int woff; + private int subOffset; // The next offset *within* a consituent buffer to read from or write to. + + CompositeBuf(Buf[] bufs) { + this(true, bufs.clone()); // Clone prevents external modification of array. + } + + private CompositeBuf(boolean isSendable, Buf[] bufs) { + super(COMPOSITE_DROP); + this.isSendable = isSendable; + for (Buf buf : bufs) { + buf.acquire(); + } + if (bufs.length > 0) { + ByteOrder targetOrder = bufs[0].order(); + for (Buf buf : bufs) { + if (buf.order() != targetOrder) { + throw new IllegalArgumentException("Constituent buffers have inconsistent byte order."); + } + } + boolean woffMidpoint = false; + for (Buf buf : bufs) { + if (buf.writableBytes() == 0) { + woff += buf.capacity(); + } else if (!woffMidpoint) { + woff += buf.writerIndex(); + woffMidpoint = true; + } else if (buf.writerIndex() != 0) { + throw new IllegalArgumentException( + "The given buffers cannot be composed because they have an unwritten gap: " + + Arrays.toString(bufs) + '.'); + } + } + boolean roffMidpoint = false; + for (Buf buf : bufs) { + if (buf.readableBytes() == 0 && buf.writableBytes() == 0) { + roff += buf.capacity(); + } else if (!roffMidpoint) { + roff += buf.readerIndex(); + roffMidpoint = true; + } else if (buf.readerIndex() != 0) { + throw new IllegalArgumentException( + "The given buffers cannot be composed because they have an unread gap: " + + Arrays.toString(bufs) + '.'); + } + } + assert roff <= woff: + "The given buffers place the read offset ahead of the write offset: " + Arrays.toString(bufs) + '.'; + } + offsets = new int[bufs.length]; + offsetSums = new int[bufs.length]; + long cap = 0; + for (int i = 0; i < bufs.length; i++) { + offsets[i] = (int) cap; + offsetSums[i] = (int) (cap + (i == 0? 0 : offsets[i - 1])); + cap += bufs[i].capacity(); + } + if (cap > MAX_CAPACITY) { + throw new IllegalArgumentException( + "Combined size of the constituent buffers is too big. " + + "The maximum buffer capacity is " + MAX_CAPACITY + " (Interger.MAX_VALUE - 8), " + + "but the sum of the constituent buffer capacities was " + cap + '.'); + } + capacity = (int) cap; + this.bufs = bufs; + tornBufAccessors = new TornBufAccessors(this); + } + + @Override + public Buf order(ByteOrder order) { + for (Buf buf : bufs) { + buf.order(order); + } + return this; + } + + @Override + public ByteOrder order() { + return bufs[0].order(); + } + + @Override + public int capacity() { + return capacity; + } + + @Override + public int readerIndex() { + return roff; + } + + @Override + public Buf readerIndex(int index) { + prepRead(index, 0); + int indexLeft = index; + for (Buf buf : bufs) { + buf.readerIndex(Math.min(indexLeft, buf.capacity())); + indexLeft = Math.max(0, indexLeft - buf.capacity()); + } + roff = index; + return this; + } + + @Override + public int writerIndex() { + return woff; + } + + @Override + public Buf writerIndex(int index) { + checkWriteBounds(index, 0); + int indexLeft = index; + for (Buf buf : bufs) { + buf.writerIndex(Math.min(indexLeft, buf.capacity())); + indexLeft = Math.max(0, indexLeft - buf.capacity()); + } + woff = index; + return this; + } + + @Override + public Buf fill(byte value) { + for (Buf buf : bufs) { + buf.fill(value); + } + return this; + } + + @Override + public byte[] copy() { + var bytes = new byte[capacity]; + int base = 0; + for (Buf buf : bufs) { + var src = buf.copy(); + System.arraycopy(src, 0, bytes, base, src.length); + base += src.length; + } + return bytes; + } + + @Override + public long getNativeAddress() { + return 0; + } + + @Override + public Buf slice(int offset, int length) { + checkWriteBounds(offset, length); + if (offset < 0 || length < 0) { + throw new IndexOutOfBoundsException( + "Offset and length cannot be negative, but offset was " + + offset + ", and length was " + length + '.'); + } + Buf choice = (Buf) chooseBuffer(offset, 0); + Buf[] slices = null; + + try { + if (length > 0) { + slices = new Buf[bufs.length]; + int off = subOffset; + int cap = length; + int i; + for (i = searchOffsets(offset); cap > 0; i++) { + var buf = bufs[i]; + int avail = buf.capacity() - off; + slices[i] = buf.slice(off, Math.min(cap, avail)); + cap -= avail; + off = 0; + } + slices = Arrays.copyOf(slices, i); + } else { + // Specialize for length == 0, since we must slice from at least one constituent buffer. + slices = new Buf[] { choice.slice(subOffset, 0) }; + } + + return new CompositeBuf(false, slices).writerIndex(length); + } finally { + if (slices != null) { + for (Buf slice : slices) { + if (slice != null) { + slice.close(); // Ownership now transfers to the composite buffer. + } + } + } + } + } + + // + @Override + public byte readByte() { + return prepRead(Byte.BYTES).readByte(); + } + + @Override + public byte readByte(int roff) { + return prepRead(roff, Byte.BYTES).readByte(subOffset); + } + + @Override + public int readUnsignedByte() { + return prepRead(Byte.BYTES).readUnsignedByte(); + } + + @Override + public int readUnsignedByte(int roff) { + return prepRead(roff, Byte.BYTES).readUnsignedByte(subOffset); + } + + @Override + public Buf writeByte(byte value) { + prepWrite(Byte.BYTES).writeByte(value); + return this; + } + + @Override + public Buf writeByte(int woff, byte value) { + prepWrite(woff, Byte.BYTES).writeByte(subOffset, value); + return this; + } + + @Override + public Buf writeUnsignedByte(int value) { + prepWrite(Byte.BYTES).writeUnsignedByte(value); + return this; + } + + @Override + public Buf writeUnsignedByte(int woff, int value) { + prepWrite(woff, Byte.BYTES).writeUnsignedByte(subOffset, value); + return this; + } + + @Override + public char readChar() { + return prepRead(2).readChar(); + } + + @Override + public char readChar(int roff) { + return prepRead(roff, 2).readChar(subOffset); + } + + @Override + public Buf writeChar(char value) { + prepWrite(2).writeChar(value); + return this; + } + + @Override + public Buf writeChar(int woff, char value) { + prepWrite(woff, 2).writeChar(subOffset, value); + return this; + } + + @Override + public short readShort() { + return prepRead(Short.BYTES).readShort(); + } + + @Override + public short readShort(int roff) { + return prepRead(roff, Short.BYTES).readShort(subOffset); + } + + @Override + public int readUnsignedShort() { + return prepRead(Short.BYTES).readShort(); + } + + @Override + public int readUnsignedShort(int roff) { + return prepRead(roff, Short.BYTES).readUnsignedShort(subOffset); + } + + @Override + public Buf writeShort(short value) { + prepWrite(Short.BYTES).writeShort(value); + return this; + } + + @Override + public Buf writeShort(int woff, short value) { + prepWrite(woff, Short.BYTES).writeShort(subOffset, value); + return this; + } + + @Override + public Buf writeUnsignedShort(int value) { + prepWrite(Short.BYTES).writeUnsignedShort(value); + return this; + } + + @Override + public Buf writeUnsignedShort(int woff, int value) { + prepWrite(woff, Short.BYTES).writeUnsignedShort(subOffset, value); + return this; + } + + @Override + public int readMedium() { + return prepRead(3).readMedium(); + } + + @Override + public int readMedium(int roff) { + return prepRead(roff, 3).readMedium(subOffset); + } + + @Override + public int readUnsignedMedium() { + return prepRead(3).readMedium(); + } + + @Override + public int readUnsignedMedium(int roff) { + return prepRead(roff, 3).readMedium(subOffset); + } + + @Override + public Buf writeMedium(int value) { + prepWrite(3).writeMedium(value); + return this; + } + + @Override + public Buf writeMedium(int woff, int value) { + prepWrite(woff, 3).writeMedium(subOffset, value); + return this; + } + + @Override + public Buf writeUnsignedMedium(int value) { + prepWrite(3).writeUnsignedMedium(value); + return this; + } + + @Override + public Buf writeUnsignedMedium(int woff, int value) { + prepWrite(woff, 3).writeUnsignedMedium(subOffset, value); + return this; + } + + @Override + public int readInt() { + return prepRead(Integer.BYTES).readInt(); + } + + @Override + public int readInt(int roff) { + return prepRead(roff, Integer.BYTES).readInt(subOffset); + } + + @Override + public long readUnsignedInt() { + return prepRead(Integer.BYTES).readUnsignedInt(); + } + + @Override + public long readUnsignedInt(int roff) { + return prepRead(roff, Integer.BYTES).readUnsignedInt(subOffset); + } + + @Override + public Buf writeInt(int value) { + prepWrite(Integer.BYTES).writeInt(value); + return this; + } + + @Override + public Buf writeInt(int woff, int value) { + prepWrite(woff, Integer.BYTES).writeInt(subOffset, value); + return this; + } + + @Override + public Buf writeUnsignedInt(long value) { + prepWrite(Integer.BYTES).writeUnsignedInt(value); + return this; + } + + @Override + public Buf writeUnsignedInt(int woff, long value) { + prepWrite(woff, Integer.BYTES).writeUnsignedInt(subOffset, value); + return this; + } + + @Override + public float readFloat() { + return prepRead(Float.BYTES).readFloat(); + } + + @Override + public float readFloat(int roff) { + return prepRead(roff, Float.BYTES).readFloat(subOffset); + } + + @Override + public Buf writeFloat(float value) { + prepWrite(Float.BYTES).writeFloat(value); + return this; + } + + @Override + public Buf writeFloat(int woff, float value) { + prepWrite(woff, Float.BYTES).writeFloat(subOffset, value); + return this; + } + + @Override + public long readLong() { + return prepRead(Long.BYTES).readLong(); + } + + @Override + public long readLong(int roff) { + return prepRead(roff, Long.BYTES).readLong(subOffset); + } + + @Override + public Buf writeLong(long value) { + prepWrite(Long.BYTES).writeLong(value); + return this; + } + + @Override + public Buf writeLong(int woff, long value) { + prepWrite(woff, Long.BYTES).writeLong(subOffset, value); + return this; + } + + @Override + public double readDouble() { + return prepRead(Double.BYTES).readDouble(); + } + + @Override + public double readDouble(int roff) { + return prepRead(roff, Double.BYTES).readDouble(subOffset); + } + + @Override + public Buf writeDouble(double value) { + prepWrite(Double.BYTES).writeDouble(value); + return this; + } + + @Override + public Buf writeDouble(int woff, double value) { + prepWrite(woff, Double.BYTES).writeDouble(subOffset, value); + return this; + } + // + + @Override + protected Owned prepareSend() { + if (!isSendable) { + throw new IllegalStateException( + "Cannot send() this buffer. This buffer might be a slice of another buffer."); + } + @SuppressWarnings("unchecked") + Send[] sends = new Send[bufs.length]; + try { + for (int i = 0; i < bufs.length; i++) { + sends[i] = bufs[i].send(); + } + } catch (Throwable throwable) { + // Repair our bufs array. + for (int i = 0; i < sends.length; i++) { + if (sends[i] != null) { + try { + bufs[i] = sends[i].receive(); + } catch (Exception e) { + throwable.addSuppressed(e); + } + } + } + throw throwable; + } + return new Owned() { + @Override + public CompositeBuf transferOwnership(Drop drop) { + Buf[] received = new Buf[sends.length]; + for (int i = 0; i < sends.length; i++) { + received[i] = sends[i].receive(); + } + var composite = new CompositeBuf(true, received); + drop.accept(composite); + return composite; + } + }; + } + + + + long readPassThrough() { + var buf = choosePassThroughBuffer(subOffset++); + assert buf != tornBufAccessors: "Recursive call to torn buffer."; + return buf.readUnsignedByte(); + } + + void writePassThrough(int value) { + var buf = choosePassThroughBuffer(subOffset++); + assert buf != tornBufAccessors: "Recursive call to torn buffer."; + buf.writeUnsignedByte(value); + } + + long readPassThrough(int roff) { + var buf = chooseBuffer(roff, 1); + assert buf != tornBufAccessors: "Recursive call to torn buffer."; + return buf.readUnsignedByte(subOffset); + } + + void writePassThrough(int woff, int value) { + var buf = chooseBuffer(woff, 1); + assert buf != tornBufAccessors: "Recursive call to torn buffer."; + buf.writeUnsignedByte(subOffset, value); + } + + private BufAccessors prepRead(int size) { + var buf = prepRead(roff, size); + roff += size; + return buf; + } + + private BufAccessors prepRead(int index, int size) { + checkReadBounds(index, size); + return chooseBuffer(index, size); + } + + private void checkReadBounds(int index, int size) { + if (index < 0 || woff < index + size) { + throw indexOutOfBounds(index); + } + } + + private BufAccessors prepWrite(int size) { + var buf = prepWrite(woff, size); + woff += size; + return buf; + } + + private BufAccessors prepWrite(int index, int size) { + checkWriteBounds(index, size); + return chooseBuffer(index, size); + } + + private void checkWriteBounds(int index, int size) { + if (index < 0 || capacity < index + size) { + throw indexOutOfBounds(index); + } + } + + private IndexOutOfBoundsException indexOutOfBounds(int index) { + return new IndexOutOfBoundsException( + "Index " + index + " is out of bounds: [read 0 to " + woff + ", write 0 to " + + (capacity - 1) + "]."); + } + + private BufAccessors chooseBuffer(int index, int size) { + int i = searchOffsets(index); + if (i == bufs.length) { + // This happens when the read/write offsets are parked 1 byte beyond the end of the buffer. + // In that case it should not matter what buffer is returned, because it shouldn't be used anyway. + return null; + } + int off = index - offsetSums[i]; + Buf candidate = bufs[i]; + if (off + size <= candidate.capacity()) { + subOffset = off; + return candidate; + } + subOffset = index; + return tornBufAccessors; + } + + private BufAccessors choosePassThroughBuffer(int index) { + int i = searchOffsets(index); + return bufs[i]; + } + + private int searchOffsets(int index) { + int i = Arrays.binarySearch(offsets, index); + return i < 0? -(i+2) : i; + } + + private static final class TornBufAccessors implements BufAccessors { + private final CompositeBuf buf; + + private TornBufAccessors(CompositeBuf buf) { + this.buf = buf; + } + + @Override + public byte readByte() { + throw new AssertionError("Method should not be used."); + } + + @Override + public byte readByte(int roff) { + throw new AssertionError("Method should not be used."); + } + + @Override + public int readUnsignedByte() { + throw new AssertionError("Method should not be used."); + } + + @Override + public int readUnsignedByte(int roff) { + throw new AssertionError("Method should not be used."); + } + + @Override + public Buf writeByte(byte value) { + throw new AssertionError("Method should not be used."); + } + + @Override + public Buf writeByte(int woff, byte value) { + throw new AssertionError("Method should not be used."); + } + + @Override + public Buf writeUnsignedByte(int value) { + throw new AssertionError("Method should not be used."); + } + + @Override + public Buf writeUnsignedByte(int woff, int value) { + throw new AssertionError("Method should not be used."); + } + + @Override + public char readChar() { + if (bigEndian()) { + return (char) (read() << 8 | read()); + } else { + return (char) (read() | read() << 8); + } + } + + @Override + public char readChar(int roff) { + if (bigEndian()) { + return (char) (read(roff) << 8 | read(roff + 1)); + } else { + return (char) (read(roff) | read(roff + 1) << 8); + } + } + + @Override + public Buf writeChar(char value) { + if (bigEndian()) { + write(value >>> 8); + write(value & 0xFF); + } else { + write(value & 0xFF); + write(value >>> 8); + } + return buf; + } + + @Override + public Buf writeChar(int woff, char value) { + if (bigEndian()) { + write(woff, value >>> 8); + write(woff + 1, value & 0xFF); + } else { + write(woff, value & 0xFF); + write(woff + 1, value >>> 8); + } + return buf; + } + + @Override + public short readShort() { + if (bigEndian()) { + return (short) (read() << 8 | read()); + } else { + return (short) (read() | read() << 8); + } + } + + @Override + public short readShort(int roff) { + if (bigEndian()) { + return (short) (read(roff) << 8 | read(roff + 1)); + } else { + return (short) (read(roff) | read(roff + 1) << 8); + } + } + + @Override + public int readUnsignedShort() { + if (bigEndian()) { + return (int) (read() << 8 | read()) & 0xFFFF; + } else { + return (int) (read() | read() << 8) & 0xFFFF; + } + } + + @Override + public int readUnsignedShort(int roff) { + if (bigEndian()) { + return (int) (read(roff) << 8 | read(roff + 1)) & 0xFFFF; + } else { + return (int) (read(roff) | read(roff + 1) << 8) & 0xFFFF; + } + } + + @Override + public Buf writeShort(short value) { + if (bigEndian()) { + write(value >>> 8); + write(value & 0xFF); + } else { + write(value & 0xFF); + write(value >>> 8); + } + return buf; + } + + @Override + public Buf writeShort(int woff, short value) { + if (bigEndian()) { + write(woff, value >>> 8); + write(woff + 1, value & 0xFF); + } else { + write(woff, value & 0xFF); + write(woff + 1, value >>> 8); + } + return buf; + } + + @Override + public Buf writeUnsignedShort(int value) { + if (bigEndian()) { + write(value >>> 8); + write(value & 0xFF); + } else { + write(value & 0xFF); + write(value >>> 8); + } + return buf; + } + + @Override + public Buf writeUnsignedShort(int woff, int value) { + if (bigEndian()) { + write(woff, value >>> 8); + write(woff + 1, value & 0xFF); + } else { + write(woff, value & 0xFF); + write(woff + 1, value >>> 8); + } + return buf; + } + + @Override + public int readMedium() { + if (bigEndian()) { + return (int) (read() << 16 | read() << 8 | read()); + } else { + return (int) (read() | read() << 8 | read() << 16); + } + } + + @Override + public int readMedium(int roff) { + if (bigEndian()) { + return (int) (read(roff) << 16 | read(roff + 1) << 8 | read(roff + 2)); + } else { + return (int) (read(roff) | read(roff + 1) << 8 | read(roff + 2) << 16); + } + } + + @Override + public int readUnsignedMedium() { + if (bigEndian()) { + return (int) (read() << 16 | read() << 8 | read()) & 0xFFFFFF; + } else { + return (int) (read() | read() << 8 | read() << 16) & 0xFFFFFF; + } + } + + @Override + public int readUnsignedMedium(int roff) { + if (bigEndian()) { + return (int) (read(roff) << 16 | read(roff + 1) << 8 | read(roff + 2)) & 0xFFFFFF; + } else { + return (int) (read(roff) | read(roff + 1) << 8 | read(roff + 2) << 16) & 0xFFFFFF; + } + } + + @Override + public Buf writeMedium(int value) { + if (bigEndian()) { + write(value >>> 16); + write(value >>> 8 & 0xFF); + write(value & 0xFF); + } else { + write(value & 0xFF); + write(value >>> 8 & 0xFF); + write(value >>> 16); + } + return buf; + } + + @Override + public Buf writeMedium(int woff, int value) { + if (bigEndian()) { + write(woff, value >>> 16); + write(woff + 1, value >>> 8 & 0xFF); + write(woff + 2, value & 0xFF); + } else { + write(woff, value & 0xFF); + write(woff + 1, value >>> 8 & 0xFF); + write(woff + 2, value >>> 16); + } + return buf; + } + + @Override + public Buf writeUnsignedMedium(int value) { + if (bigEndian()) { + write(value >>> 16); + write(value >>> 8 & 0xFF); + write(value & 0xFF); + } else { + write(value & 0xFF); + write(value >>> 8 & 0xFF); + write(value >>> 16); + } + return buf; + } + + @Override + public Buf writeUnsignedMedium(int woff, int value) { + if (bigEndian()) { + write(woff, value >>> 16); + write(woff + 1, value >>> 8 & 0xFF); + write(woff + 2, value & 0xFF); + } else { + write(woff, value & 0xFF); + write(woff + 1, value >>> 8 & 0xFF); + write(woff + 2, value >>> 16); + } + return buf; + } + + @Override + public int readInt() { + if (bigEndian()) { + return (int) (read() << 24 | read() << 16 | read() << 8 | read()); + } else { + return (int) (read() | read() << 8 | read() << 16 | read() << 24); + } + } + + @Override + public int readInt(int roff) { + if (bigEndian()) { + return (int) (read(roff) << 24 | read(roff + 1) << 16 | read(roff + 2) << 8 | read(roff + 3)); + } else { + return (int) (read(roff) | read(roff + 1) << 8 | read(roff + 2) << 16 | read(roff + 3) << 24); + } + } + + @Override + public long readUnsignedInt() { + if (bigEndian()) { + return (read() << 24 | read() << 16 | read() << 8 | read()) & 0xFFFFFFFFL; + } else { + return (read() | read() << 8 | read() << 16 | read() << 24) & 0xFFFFFFFFL; + } + } + + @Override + public long readUnsignedInt(int roff) { + if (bigEndian()) { + return (read(roff) << 24 | read(roff + 1) << 16 | read(roff + 2) << 8 | read(roff + 3)) & 0xFFFFFFFFL; + } else { + return (read(roff) | read(roff + 1) << 8 | read(roff + 2) << 16 | read(roff + 3) << 24) & 0xFFFFFFFFL; + } + } + + @Override + public Buf writeInt(int value) { + if (bigEndian()) { + write(value >>> 24); + write(value >>> 16 & 0xFF); + write(value >>> 8 & 0xFF); + write(value & 0xFF); + } else { + write(value & 0xFF); + write(value >>> 8 & 0xFF); + write(value >>> 16 & 0xFF); + write(value >>> 24); + } + return buf; + } + + @Override + public Buf writeInt(int woff, int value) { + if (bigEndian()) { + write(woff, value >>> 24); + write(woff + 1, value >>> 16 & 0xFF); + write(woff + 2, value >>> 8 & 0xFF); + write(woff + 3, value & 0xFF); + } else { + write(woff, value & 0xFF); + write(woff + 1, value >>> 8 & 0xFF); + write(woff + 2, value >>> 16 & 0xFF); + write(woff + 3, value >>> 24); + } + return buf; + } + + @Override + public Buf writeUnsignedInt(long value) { + if (bigEndian()) { + write((int) (value >>> 24)); + write((int) (value >>> 16 & 0xFF)); + write((int) (value >>> 8 & 0xFF)); + write((int) (value & 0xFF)); + } else { + write((int) (value & 0xFF)); + write((int) (value >>> 8 & 0xFF)); + write((int) (value >>> 16 & 0xFF)); + write((int) (value >>> 24)); + } + return buf; + } + + @Override + public Buf writeUnsignedInt(int woff, long value) { + if (bigEndian()) { + write(woff, (int) (value >>> 24)); + write(woff + 1, (int) (value >>> 16 & 0xFF)); + write(woff + 2, (int) (value >>> 8 & 0xFF)); + write(woff + 3, (int) (value & 0xFF)); + } else { + write(woff, (int) (value & 0xFF)); + write(woff + 1, (int) (value >>> 8 & 0xFF)); + write(woff + 2, (int) (value >>> 16 & 0xFF)); + write(woff + 3, (int) (value >>> 24)); + } + return buf; + } + + @Override + public float readFloat() { + return Float.intBitsToFloat(readInt()); + } + + @Override + public float readFloat(int roff) { + return Float.intBitsToFloat(readInt(roff)); + } + + @Override + public Buf writeFloat(float value) { + return writeUnsignedInt(Float.floatToRawIntBits(value)); + } + + @Override + public Buf writeFloat(int woff, float value) { + return writeUnsignedInt(woff, Float.floatToRawIntBits(value)); + } + + @Override + public long readLong() { + if (bigEndian()) { + return read() << 56 | read() << 48 | read() << 40 | read() << 32 | + read() << 24 | read() << 16 | read() << 8 | read(); + } else { + return read() | read() << 8 | read() << 16 | read() << 24 | + read() << 32 | read() << 40 | read() << 48 | read() << 56; + } + } + + @Override + public long readLong(int roff) { + if (bigEndian()) { + return read(roff) << 56 | read(roff + 1) << 48 | read(roff + 2) << 40 | read(roff + 3) << 32 | + read(roff + 4) << 24 | read(roff + 5) << 16 | read(roff + 6) << 8 | read(roff + 7); + } else { + return read(roff) | read(roff + 1) << 8 | read(roff + 2) << 16 | read(roff + 3) << 24 | + read(roff + 4) << 32 | read(roff + 5) << 40 | read(roff + 6) << 48 | read(roff + 7) << 56; + } + } + + @Override + public Buf writeLong(long value) { + if (bigEndian()) { + write((int) (value >>> 56)); + write((int) (value >>> 48 & 0xFF)); + write((int) (value >>> 40 & 0xFF)); + write((int) (value >>> 32 & 0xFF)); + write((int) (value >>> 24 & 0xFF)); + write((int) (value >>> 16 & 0xFF)); + write((int) (value >>> 8 & 0xFF)); + write((int) (value & 0xFF)); + } else { + write((int) (value & 0xFF)); + write((int) (value >>> 8 & 0xFF)); + write((int) (value >>> 16 & 0xFF)); + write((int) (value >>> 24)); + write((int) (value >>> 32)); + write((int) (value >>> 40)); + write((int) (value >>> 48)); + write((int) (value >>> 56)); + } + return buf; + } + + @Override + public Buf writeLong(int woff, long value) { + if (bigEndian()) { + write(woff, (int) (value >>> 56)); + write(woff + 1, (int) (value >>> 48 & 0xFF)); + write(woff + 2, (int) (value >>> 40 & 0xFF)); + write(woff + 3, (int) (value >>> 32 & 0xFF)); + write(woff + 4, (int) (value >>> 24 & 0xFF)); + write(woff + 5, (int) (value >>> 16 & 0xFF)); + write(woff + 6, (int) (value >>> 8 & 0xFF)); + write(woff + 7, (int) (value & 0xFF)); + } else { + write(woff, (int) (value & 0xFF)); + write(woff + 1, (int) (value >>> 8 & 0xFF)); + write(woff + 2, (int) (value >>> 16 & 0xFF)); + write(woff + 3, (int) (value >>> 24)); + write(woff + 4, (int) (value >>> 32)); + write(woff + 5, (int) (value >>> 40)); + write(woff + 6, (int) (value >>> 48)); + write(woff + 7, (int) (value >>> 56)); + } + return buf; + } + + @Override + public double readDouble() { + return Double.longBitsToDouble(readLong()); + } + + @Override + public double readDouble(int roff) { + return Double.longBitsToDouble(readLong(roff)); + } + + @Override + public Buf writeDouble(double value) { + return writeLong(Double.doubleToRawLongBits(value)); + } + + @Override + public Buf writeDouble(int woff, double value) { + return writeLong(woff, Double.doubleToRawLongBits(value)); + } + + private boolean bigEndian() { + return buf.order() == ByteOrder.BIG_ENDIAN; + } + + private long read() { + return buf.readPassThrough(); + } + + private void write(int value) { + buf.writePassThrough(value); + } + + private long read(int roff) { + return buf.readPassThrough(roff); + } + + private void write(int woff, int value) { + buf.writePassThrough(woff, value); + } + } +} diff --git a/buffer/src/main/java/io/netty/buffer/b2/Drop.java b/buffer/src/main/java/io/netty/buffer/b2/Drop.java index 58cf2e2..e526720 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/Drop.java +++ b/buffer/src/main/java/io/netty/buffer/b2/Drop.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/main/java/io/netty/buffer/b2/MemSegBuf.java b/buffer/src/main/java/io/netty/buffer/b2/MemSegBuf.java index d48d957..5ef018a 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/MemSegBuf.java +++ b/buffer/src/main/java/io/netty/buffer/b2/MemSegBuf.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -52,7 +52,7 @@ class MemSegBuf extends RcSupport implements Buf { static final Drop SEGMENT_CLOSE = buf -> buf.seg.close(); final MemorySegment seg; private boolean isBigEndian; - private boolean isSendable; + private final boolean isSendable; private int roff; private int woff; @@ -107,16 +107,6 @@ class MemSegBuf extends RcSupport implements Buf { return this; } - @Override - public int readableBytes() { - return writerIndex() - readerIndex(); - } - - @Override - public int writableBytes() { - return capacity() - writerIndex(); - } - @Override public Buf fill(byte value) { seg.fill(value); @@ -623,11 +613,11 @@ getByteAtOffset_BE(seg, roff) & 0xFF | } MemSegBuf outer = this; boolean isConfined = seg.ownerThread() == null; - MemorySegment transferSegment = isConfined? seg : seg.withOwnerThread(null); + MemorySegment transferSegment = isConfined? seg : seg.share(); return new Owned() { @Override - public MemSegBuf transferOwnership(Thread recipient, Drop drop) { - var newSegment = isConfined? transferSegment.withOwnerThread(recipient) : transferSegment; + public MemSegBuf transferOwnership(Drop drop) { + var newSegment = isConfined? transferSegment.handoff(Thread.currentThread()) : transferSegment; MemSegBuf copy = new MemSegBuf(newSegment, drop); copy.isBigEndian = outer.isBigEndian; copy.roff = outer.roff; diff --git a/buffer/src/main/java/io/netty/buffer/b2/MemoryManager.java b/buffer/src/main/java/io/netty/buffer/b2/MemoryManager.java index 5e68f4c..d3d38c3 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/MemoryManager.java +++ b/buffer/src/main/java/io/netty/buffer/b2/MemoryManager.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -29,10 +29,9 @@ public interface MemoryManager { } boolean isNative(); - Buf allocateConfined(long size, Drop drop); - Buf allocateShared(long size, Drop drop); + Buf allocateConfined(long size, Drop drop, Cleaner cleaner); + Buf allocateShared(long size, Drop drop, Cleaner cleaner); Drop drop(); - void registerCleaner(Buf buf, Cleaner cleaner); Object unwrapRecoverableMemory(Buf buf); Buf recoverMemory(Object recoverableMemory, Drop drop); @@ -41,14 +40,20 @@ public interface MemoryManager { public abstract boolean isNative(); @Override - public Buf allocateConfined(long size, Drop drop) { + public Buf allocateConfined(long size, Drop drop, Cleaner cleaner) { var segment = createSegment(size); + if (cleaner != null) { + segment = segment.registerCleaner(cleaner); + } return new MemSegBuf(segment, convert(drop)); } @Override - public Buf allocateShared(long size, Drop drop) { - var segment = createSegment(size).withOwnerThread(null); + public Buf allocateShared(long size, Drop drop, Cleaner cleaner) { + var segment = createSegment(size).share(); + if (cleaner != null) { + segment = segment.registerCleaner(cleaner); + } return new MemSegBuf(segment, convert(drop)); } @@ -59,12 +64,6 @@ public interface MemoryManager { return convert(MemSegBuf.SEGMENT_CLOSE); } - @Override - public void registerCleaner(Buf buf, Cleaner cleaner) { - var b = (MemSegBuf) buf; - b.seg.registerCleaner(cleaner); - } - @Override public Object unwrapRecoverableMemory(Buf buf) { var b = (MemSegBuf) buf; @@ -103,8 +102,8 @@ public interface MemoryManager { @Override protected MemorySegment createSegment(long size) { - var segment = MemorySegment.allocateNative(size) - .withCleanupAction(Statics.getCleanupAction(size)); + var segment = MemorySegment.allocateNative(size); +// .withCleanupAction(Statics.getCleanupAction(size)); Statics.MEM_USAGE_NATIVE.add(size); return segment; } diff --git a/buffer/src/main/java/io/netty/buffer/b2/NativeMemoryCleanerDrop.java b/buffer/src/main/java/io/netty/buffer/b2/NativeMemoryCleanerDrop.java index 56d1931..f4dd2ad 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/NativeMemoryCleanerDrop.java +++ b/buffer/src/main/java/io/netty/buffer/b2/NativeMemoryCleanerDrop.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/main/java/io/netty/buffer/b2/Owned.java b/buffer/src/main/java/io/netty/buffer/b2/Owned.java index 4c9b636..9f41667 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/Owned.java +++ b/buffer/src/main/java/io/netty/buffer/b2/Owned.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -24,16 +24,15 @@ package io.netty.buffer.b2; @SuppressWarnings("InterfaceMayBeAnnotatedFunctional") public interface Owned { /** - * Transfer the ownership of the owned Rc, to the given recipient thread. The owned Rc is invalidated but without + * Transfer the ownership of the owned Rc, to the calling thread. The owned Rc is invalidated but without * disposing of its internal state. Then a new Rc with the given owner is produced in its stead. *

* This method is called by {@link Send} implementations. These implementations will ensure that the transfer of * ownership (the calling of this method) happens-before the new owner begins accessing the new object. This ensures * that the new Rc is safely published to the new owners. * - * @param recipient The new owner of the state represented by this Rc. * @param drop The drop object that knows how to dispose of the state represented by this Rc. * @return A new Rc instance that is exactly the same as this Rc, except it has the new owner. */ - T transferOwnership(Thread recipient, Drop drop); + T transferOwnership(Drop drop); } diff --git a/buffer/src/main/java/io/netty/buffer/b2/Rc.java b/buffer/src/main/java/io/netty/buffer/b2/Rc.java index ac7ea13..e76da94 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/Rc.java +++ b/buffer/src/main/java/io/netty/buffer/b2/Rc.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -47,14 +47,10 @@ public interface Rc> extends AutoCloseable { void close(); /** - * Send this Rc instance to another Thread, transferring the ownership to the recipient. This method can be used - * when the receiving thread is not known up front. + * Send this Rc instance to another Thread, transferring the ownership to the recipient. *

* This instance immediately becomes inaccessible, and all attempts at accessing this Rc will throw. Calling {@link * #close()} will have no effect, so this method is safe to call within a try-with-resources statement. - * - * @implNote Not possible without hacks because we need the receiving thread in order to set the new owner in the - * currently owning thread. */ Send send(); } diff --git a/buffer/src/main/java/io/netty/buffer/b2/RcSupport.java b/buffer/src/main/java/io/netty/buffer/b2/RcSupport.java index c71089f..87d5270 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/RcSupport.java +++ b/buffer/src/main/java/io/netty/buffer/b2/RcSupport.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -84,7 +84,7 @@ public abstract class RcSupport, T extends RcSupport> impl /** * Prepare this instance for ownsership transfer. This method is called from {@link #send()} in the sending thread. * This method should put this Rc in a deactivated state where it is no longer accessible from the currently owning - * thread. In this state, the Rc instance should only allow a call to {@link Owned#transferOwnership(Thread, Drop)} in + * thread. In this state, the Rc instance should only allow a call to {@link Owned#transferOwnership(Drop)} in * the recipient thread. * * @return This Rc instance in a deactivated state. diff --git a/buffer/src/main/java/io/netty/buffer/b2/ResourceDisposeFailedException.java b/buffer/src/main/java/io/netty/buffer/b2/ResourceDisposeFailedException.java index a4baccd..bac0b49 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/ResourceDisposeFailedException.java +++ b/buffer/src/main/java/io/netty/buffer/b2/ResourceDisposeFailedException.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/main/java/io/netty/buffer/b2/Send.java b/buffer/src/main/java/io/netty/buffer/b2/Send.java index 0b0bdd6..d71cc29 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/Send.java +++ b/buffer/src/main/java/io/netty/buffer/b2/Send.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/main/java/io/netty/buffer/b2/SizeClassedMemoryPool.java b/buffer/src/main/java/io/netty/buffer/b2/SizeClassedMemoryPool.java index 473f939..a932424 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/SizeClassedMemoryPool.java +++ b/buffer/src/main/java/io/netty/buffer/b2/SizeClassedMemoryPool.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -51,7 +51,7 @@ class SizeClassedMemoryPool implements Allocator, Drop { } protected Buf createBuf(long size, Drop drop) { - var buf = manager.allocateShared(size, drop); + var buf = manager.allocateShared(size, drop, null); drop.accept(buf); return buf; } diff --git a/buffer/src/main/java/io/netty/buffer/b2/Statics.java b/buffer/src/main/java/io/netty/buffer/b2/Statics.java index 1273d87..ddb2ca1 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/Statics.java +++ b/buffer/src/main/java/io/netty/buffer/b2/Statics.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/main/java/io/netty/buffer/b2/TransferSend.java b/buffer/src/main/java/io/netty/buffer/b2/TransferSend.java index 3c479c4..d26a626 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/TransferSend.java +++ b/buffer/src/main/java/io/netty/buffer/b2/TransferSend.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -17,8 +17,8 @@ package io.netty.buffer.b2; import java.lang.invoke.VarHandle; -import static io.netty.buffer.b2.Statics.*; -import static java.lang.invoke.MethodHandles.*; +import static io.netty.buffer.b2.Statics.findVarHandle; +import static java.lang.invoke.MethodHandles.lookup; class TransferSend, T extends Rc> implements Send { private static final VarHandle RECEIVED = findVarHandle(lookup(), TransferSend.class, "received", boolean.class); @@ -38,7 +38,7 @@ class TransferSend, T extends Rc> implements Send { if (!RECEIVED.compareAndSet(this, false, true)) { throw new IllegalStateException("This object has already been received."); } - var copy = outgoing.transferOwnership(Thread.currentThread(), drop); + var copy = outgoing.transferOwnership(drop); drop.accept(copy); return (I) copy; } diff --git a/buffer/src/main/java/io/netty/buffer/b2/package-info.java b/buffer/src/main/java/io/netty/buffer/b2/package-info.java index 7b8e8d2..2e56362 100644 --- a/buffer/src/main/java/io/netty/buffer/b2/package-info.java +++ b/buffer/src/main/java/io/netty/buffer/b2/package-info.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/test/java/io/netty/buffer/b2/BufTest.java b/buffer/src/test/java/io/netty/buffer/b2/BufTest.java index 1fc1bf1..27ff4aa 100644 --- a/buffer/src/test/java/io/netty/buffer/b2/BufTest.java +++ b/buffer/src/test/java/io/netty/buffer/b2/BufTest.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -18,6 +18,7 @@ package io.netty.buffer.b2; import org.junit.After; import org.junit.AssumptionViolatedException; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import java.nio.ByteOrder; @@ -181,6 +182,7 @@ public abstract class BufTest { } } + @Ignore // This test uses too much memory. @Test public void mustThrowWhenAllocatingOverSizedBuffer() { try { @@ -190,6 +192,7 @@ public abstract class BufTest { } } + @Ignore // This test uses too much memory. @Test public void mustAllowAllocatingMaxArraySizedBuffer() { try { diff --git a/buffer/src/test/java/io/netty/buffer/b2/Codegen.java b/buffer/src/test/java/io/netty/buffer/b2/Codegen.java index a9e0cb7..407e20e 100644 --- a/buffer/src/test/java/io/netty/buffer/b2/Codegen.java +++ b/buffer/src/test/java/io/netty/buffer/b2/Codegen.java @@ -1,3 +1,18 @@ +/* + * Copyright 2020 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: + * + * https://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.b2; import java.io.IOException; @@ -42,7 +57,7 @@ public final class Codegen { case BE: return "big-endian"; case LE: return "little-endian"; } - return "the {@link #order() configured} default"; + return "the {@link Buf#order() configured} default"; } } @@ -569,7 +584,7 @@ public final class Codegen { } public static void main(String[] args) throws Exception { - generateCodeInline(Path.of("buffer/src/main/java/io/netty/buffer/b2/Buf.java")); + generateCodeInline(Path.of("buffer/src/main/java/io/netty/buffer/b2/BufAccessors.java")); generateCodeInline(Path.of("buffer/src/main/java/io/netty/buffer/b2/MemSegBuf.java")); generateCodeInline(Path.of("buffer/src/test/java/io/netty/buffer/b2/BufTest.java")); } diff --git a/buffer/src/test/java/io/netty/buffer/b2/CompositeBufTest.java b/buffer/src/test/java/io/netty/buffer/b2/CompositeBufTest.java new file mode 100644 index 0000000..bd3dcf7 --- /dev/null +++ b/buffer/src/test/java/io/netty/buffer/b2/CompositeBufTest.java @@ -0,0 +1,81 @@ +/* + * Copyright 2020 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: + * + * https://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.b2; + +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.function.Supplier; + +@RunWith(Parameterized.class) +public class CompositeBufTest extends BufTest { + @Parameters(name = "{0}") + public static Iterable parameters() { + Map> subAllocators = Map.of( + "heap", Allocator::heap, + "direct", Allocator::direct, + "directWithCleaner", Allocator::directWithCleaner, + "pooledHeap", Allocator::pooledHeap, + "pooledDirect", Allocator::pooledDirect, + "pooledDirectWithCleaner", Allocator::pooledDirectWithCleaner); + List combinations = new ArrayList<>(subAllocators.size() * subAllocators.size()); + for (Entry> first : subAllocators.entrySet()) { + for (Entry> second : subAllocators.entrySet()) { + String name = "compose(" + first.getKey() + ", " + second.getKey() + ')'; + var firstAllocator = first.getValue(); + var secondAllocator = second.getValue(); + Supplier allocator = () -> { + var a = firstAllocator.get(); + var b = secondAllocator.get(); + return new Allocator() { + @Override + public Buf allocate(long size) { + long half = size / 2; + try (Buf firstHalf = a.allocate(half); + Buf secondHalf = b.allocate(size - half)) { + return Buf.compose(firstHalf, secondHalf); + } + } + + @Override + public void close() { + a.close(); + b.close(); + } + }; + }; + combinations.add(new Object[]{name, allocator}); + } + } + return combinations; + } + + private final Supplier allocatorFactory; + + public CompositeBufTest(String testName, Supplier allocatorFactory) { + this.allocatorFactory = allocatorFactory; + } + + @Override + protected Allocator createAllocator() { + return allocatorFactory.get(); + } +} diff --git a/buffer/src/test/java/io/netty/buffer/b2/DirectBufTest.java b/buffer/src/test/java/io/netty/buffer/b2/DirectBufTest.java index 519cf92..d253b54 100644 --- a/buffer/src/test/java/io/netty/buffer/b2/DirectBufTest.java +++ b/buffer/src/test/java/io/netty/buffer/b2/DirectBufTest.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/test/java/io/netty/buffer/b2/DirectBufWithCleanerTest.java b/buffer/src/test/java/io/netty/buffer/b2/DirectBufWithCleanerTest.java index 524b98c..49ced56 100644 --- a/buffer/src/test/java/io/netty/buffer/b2/DirectBufWithCleanerTest.java +++ b/buffer/src/test/java/io/netty/buffer/b2/DirectBufWithCleanerTest.java @@ -1,5 +1,21 @@ +/* + * Copyright 2020 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: + * + * https://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.b2; +import org.junit.Ignore; import org.junit.Test; import static org.hamcrest.Matchers.*; @@ -11,6 +27,7 @@ public class DirectBufWithCleanerTest extends DirectBufTest { return Allocator.directWithCleaner(); } + @Ignore // Precise native memory accounting does not work since recent panama-foreign changes. @Test public void bufferMustBeClosedByCleaner() throws InterruptedException { var allocator = createAllocator(); diff --git a/buffer/src/test/java/io/netty/buffer/b2/HeapBufTest.java b/buffer/src/test/java/io/netty/buffer/b2/HeapBufTest.java index 1cb8540..631109a 100644 --- a/buffer/src/test/java/io/netty/buffer/b2/HeapBufTest.java +++ b/buffer/src/test/java/io/netty/buffer/b2/HeapBufTest.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufTest.java b/buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufTest.java index d9cdf82..dd6bb49 100644 --- a/buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufTest.java +++ b/buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufTest.java @@ -5,7 +5,7 @@ * 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 + * https://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 diff --git a/buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufWithCleanerTest.java b/buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufWithCleanerTest.java index e6c15bc..fffd9de 100644 --- a/buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufWithCleanerTest.java +++ b/buffer/src/test/java/io/netty/buffer/b2/PooledDirectBufWithCleanerTest.java @@ -5,7 +5,7 @@ * 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 + * https://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 @@ -15,6 +15,7 @@ */ package io.netty.buffer.b2; +import org.junit.Ignore; import org.junit.Test; import static org.hamcrest.Matchers.*; @@ -26,6 +27,7 @@ public class PooledDirectBufWithCleanerTest extends DirectBufWithCleanerTest { return Allocator.pooledDirectWithCleaner(); } + @Ignore // Precise native memory accounting does not work since recent panama-foreign changes. @Test public void buffersMustBeReusedByPoolingAllocatorEvenWhenDroppedByCleanerInsteadOfExplicitly() throws InterruptedException { diff --git a/buffer/src/test/java/io/netty/buffer/b2/PooledHeapBufTest.java b/buffer/src/test/java/io/netty/buffer/b2/PooledHeapBufTest.java index 0b9ce34..b535faa 100644 --- a/buffer/src/test/java/io/netty/buffer/b2/PooledHeapBufTest.java +++ b/buffer/src/test/java/io/netty/buffer/b2/PooledHeapBufTest.java @@ -5,7 +5,7 @@ * 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 + * https://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