Make the incubating buffers exposable as ByteBuf

Motivation:
This makes it possible to use the new buffer API in Netty as is.

Modification:
Make the MemSegBuffer implementation class implement AsByteBuf and ReferenceCounted.
The produced ByteBuf instance delegates all calls to the underlying Buffer instance as faithfully as possible.
One area where the two deviates, is that it's not possible to create non-retained duplicates and slices with the new buffer API.

Result:
It is now possible to use the new buffer API on both client and server side.
The Echo* examples demonstrate this, and the EchoIT proves it with a test.
The API is used more directly on the client side, since the server-side allocator in Netty does not know how to allocate buffers with the incubating API.

Author: chrisvest

pom.xml

@@ -394,6 +394,12 @@
       <version>${netty.build.version}</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-handler</artifactId>
+      <version>${netty.version}</version>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.openjdk.jmh</groupId>
       <artifactId>jmh-core</artifactId>

src/main/java/io/netty/buffer/api/BufferHolder.java

@@ -190,4 +190,9 @@ protected final Buffer getBuf() {
     protected final Buffer getBufVolatile() {
         return (Buffer) BUF.getVolatile(this);
     }
+
+    @Override
+    public boolean isAccessible() {
+        return buf.isAccessible();
+    }
 }

src/main/java/io/netty/buffer/api/Rc.java

@@ -87,4 +87,13 @@ default boolean isInstanceOf(Class<?> cls) {
      * @return The number of borrows, if any, of this object.
      */
     int countBorrows();
+
+    /**
+     * Check if this object is accessible.
+     *
+     * @return {@code true} if this object is still valid and can be accessed,
+     * otherwise {@code false} if, for instance, this object has been dropped/deallocated,
+     * or been {@linkplain #send() sent} elsewhere.
+     */
+    boolean isAccessible();
 }

src/main/java/io/netty/buffer/api/RcSupport.java

@@ -102,6 +102,11 @@ public int countBorrows() {
         return Math.max(acquires, 0);
     }
 
+    @Override
+    public boolean isAccessible() {
+        return acquires >= 0;
+    }
+
     /**
      * 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

src/main/java/io/netty/buffer/api/adaptor/BufferIntegratable.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2021 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.api.adaptor;
+
+import io.netty.buffer.ByteBufConvertible;
+import io.netty.util.ReferenceCounted;
+
+/**
+ * Interfaces that are required for an object to stand-in for a {@link io.netty.buffer.ByteBuf} in Netty.
+ */
+public interface BufferIntegratable extends ByteBufConvertible, ReferenceCounted {
+}