Source code
package io.netty.buffer;
import java.nio.ByteBuffer;
/**
* Abstract base class for {@link ByteBuf} implementations that wrap another
* {@link ByteBuf}.
*
* @deprecated Do not use.
*/
@Deprecated
public abstract class AbstractDerivedByteBuf extends AbstractByteBuf {
protected AbstractDerivedByteBuf(int maxCapacity) {
super(maxCapacity);
}
@Override
final boolean isAccessible() {
return isAccessible0();
}
boolean isAccessible0() {
return unwrap().isAccessible();
}
@Override
public final int refCnt() {
return refCnt0();
}
int refCnt0() {
return unwrap().refCnt();
}
@Override
public final ByteBuf retain() {
return retain0();
}
ByteBuf retain0() {
unwrap().retain();
return this;
}
@Override
public final ByteBuf retain(int increment) {
return retain0(increment);
}
ByteBuf retain0(int increment) {
unwrap().retain(increment);
return this;
}
@Override
public final ByteBuf touch() {
return touch0();
}
ByteBuf touch0() {
unwrap().touch();
return this;
}
@Override
public final ByteBuf touch(Object hint) {
return touch0(hint);
}
ByteBuf touch0(Object hint) {
unwrap().touch(hint);
return this;
}
@Override
public final boolean release() {
return release0();
}
boolean release0() {
return unwrap().release();
}
@Override
public final boolean release(int decrement) {
return release0(decrement);
}
boolean release0(int decrement) {
return unwrap().release(decrement);
}
@Override
public boolean isReadOnly() {
return unwrap().isReadOnly();
}
@Override
public ByteBuffer internalNioBuffer(int index, int length) {
return nioBuffer(index, length);
}
@Override
public ByteBuffer nioBuffer(int index, int length) {
return unwrap().nioBuffer(index, length);
}
@Override
public boolean isContiguous() {
return unwrap().isContiguous();
}
}
Run 1
The code is highly readable. Structure is clear and logical: an abstract class with well-separated, grouped overrides. Nesting is flat, with only a minor two-level pattern in methods that delegate and return 'this'. Intent is explicit—the class wraps another ByteBuf and delegates reference counting, touch, and buffer operations, with naming like 'refCnt0' and 'isAccessible0' indicating internal hooks. Code length is concise; methods are short and avoid redundancy since public final methods delegate to protected/package-private templates. Action granularity is mostly one action per line, though some single-expression bodies avoid unnecessary blocks. Reading flow is natural, grouping related methods (accessibility, ref-counting, buffer metadata) and maintaining consistent delegation patterns. Minor improvements could include reducing redundant delegate methods or clarifying the deprecated nature, but overall it is highly readable.
Run 2
The code is highly readable due to its clear, consistent structure and minimal nesting. Each public method delegates to a corresponding package-private '0' method, creating a logical and predictable pattern. The intent—delegating reference counting and other operations to an underlying buffer—is explicitly clear from the method names and class documentation. Lines are concise, with one action per line, and the reading flow is natural, moving from abstract method definitions to concrete implementations. The only minor deductions are for slight repetition in the delegation pattern and the deprecated nature of the code, which may add confusion for future maintainers, but overall readability is excellent.
Run 3
The code is highly readable. Structure is logical, grouping related methods for retain/touch/release. Nesting is flat with no deep indentation. Clarity of intent is strong: the class transparently delegates to an underlying ByteBuf, with clear delegation via unwrap(). Code length is concise; methods are short and focused. Action granularity is good—each line does one thing, with clean separation of delegation and return. Reading flow is natural due to consistent naming (X vs X0) and predictable ordering.
Run 1
Code Structure: Logically organized, with related operations and overloads grouped together and consistent delegation patterns. Nesting: Entirely flat, with short methods and no nested control flow. Clarity of intent: The class documentation and descriptive API names clearly communicate its wrapper role, though the purpose of the suffix-0 helper methods and final-method indirection is not explained. Code length: Individual methods are concise, but repeated forwarding methods add boilerplate and length. Action granularity: Each statement performs a single action, and delegation and returning this are cleanly separated. Reading flow: Consistent formatting and predictable method patterns make the code easy to scan, although following each public method through a helper introduces minor navigation overhead.
Run 2
Code Structure: Methods are logically organized, grouping related reference-counting operations and buffer access. Nesting: Entirely flat, with no nested control flow. Clarity of intent: Documentation, descriptive method names, and consistent unwrap() delegation make the wrapper's purpose clear; however, the reasons for the final-method/helper split and the '0' suffix are not explained. Code length: Individual methods are concise, though repeated delegation helpers increase overall length and introduce some indirection. Action granularity: Each statement performs one clear action, with mutation and return statements separated. Reading flow: Consistent formatting, annotations, and predictable method patterns make the code easy to scan, although following calls through helper methods slightly interrupts the flow.
Run 3
Code Structure: Well-organized methods group related buffer operations and their overloads. Nesting: Flat, with no nested control flow. Clarity of intent: The class documentation and consistent unwrap() delegation clearly communicate its wrapper role, though the purpose of the intermediate methods suffixed with 0 is not explained. Code length: Individual methods are concise, but repeated forwarding layers increase overall length. Action granularity: Each statement performs one action, with delegation and returning this cleanly separated. Reading flow: Consistent formatting, annotations, and predictable method patterns make the code easy to scan, although following calls through the extra forwarding methods adds minor friction.