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 exhibits excellent readability through its clear, consistent structure. Each public method delegates to a corresponding package-private method, creating a logical separation between the final API and extensibility points. The nesting is completely flat with no conditional logic or complex control flow. Intent is unambiguous—every method clearly delegates to the wrapped ByteBuf instance via unwrap(). Code length is appropriate for the functionality, with no unnecessary verbosity. Each line performs a single action, either delegating a call or returning a result. The reading flow is natural and follows a predictable pattern: public override, then internal delegation method. The class-level Javadoc and @Deprecated annotation clearly communicate the purpose and intended usage. Minor deductions could be made for slight repetition in the delegation pattern, but this is idiomatic for Netty and enhances clarity rather than detracting from it.
Run 3
The code is generally readable with a clear structure and consistent pattern. It uses a straightforward delegation pattern where each public method forwards to a corresponding internal method, which then delegates to the unwrapped buffer. The method names are descriptive, and the final/override modifiers make the intention explicit. However, there is some duplication in the method pairs (e.g., `retain()` and `retain0()`), and the nested delegation could be simplified. The code is flat and easy to follow, with no excessive nesting or multi-action lines. The deprecated class and methods are marked appropriately. While it is concise for its purpose, the repetitive pattern reduces the score slightly.
Run 1
Code Structure: Methods are logically grouped, with consistent delegation to the wrapped buffer. Nesting: Flat methods contain no nested control flow. Clarity of intent: The class documentation and descriptive method names clearly communicate its wrapper role, although the purpose of the methods suffixed with '0' is not explained. Code length: Individual methods are concise, but repeated forwarding layers add boilerplate and slightly increase reading effort. Action granularity: Each statement occupies its own line, cleanly separating delegation from returning this. Reading flow: Consistent formatting, adjacent overloads, and predictable implementation patterns make the class easy to scan; the extra helper-method hops modestly interrupt the flow.
Run 2
Code Structure: Well-organized class with consistently paired public methods and delegation helpers. Nesting: Completely flat, with no nested control flow. Clarity of intent: Documentation and explicit delegation through unwrap() clearly communicate the wrapper role, although the purpose of the '0'-suffixed helpers is not explained. Code length: Individual methods are concise, but repeated forwarding layers add length and some redundancy. Action granularity: Each statement performs a single action, with mutations and returns cleanly separated. Reading flow: Consistent formatting and grouping of overloads make the code easy to scan; helper indirection introduces minor navigation overhead.
Run 3
Code Structure: Methods are logically organized, grouping related reference-counting operations and buffer queries. Nesting: Entirely flat, with no nested control flow. Clarity of intent: Documentation and descriptive method names clearly establish a delegating buffer wrapper, although the '0' helper suffixes and extra delegation layer are not explained. Code length: Methods are concise, but repeated public-method/helper pairs add boilerplate and length. Action granularity: Each statement performs one action, with delegation and returning this cleanly separated. Reading flow: Consistent formatting and predictable method patterns make the code easy to scan; tracing through helpers introduces minor friction.