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 structured cleanly as an abstract class with clear delegation to an underlying buffer. Methods are short, focused, and follow a consistent pattern, making intent obvious. Nesting is minimal, and each action is on its own line, aiding readability. The use of final wrappers and non-final delegate methods is logical, though slightly repetitive. Overall, the code is concise and easy to follow.
Run 3
The code is highly readable due to its clear structure and consistent patterns. Each public final method delegates to a corresponding package-private method, which then calls the wrapped buffer and returns 'this' or the result. This separation maintains clarity and prevents accidental overrides. The class has a single responsibility—delegation to an underlying ByteBuf—with minimal nesting and flat control flow. Method names clearly convey intent, and the code is concise, with each action on its own line. The reading flow is natural, moving from access checks to reference counting, touch, release, and buffer metadata. Minor deductions: the deprecated status may confuse new users, and the distinction between final and non-final methods could be explained with a brief class-level comment, but overall readability is excellent.
Run 1
Code Structure: Logically organized into small delegation methods, with related overloads grouped together. Nesting: Flat methods with no nested control flow make the code easy to scan. Clarity of intent: The class documentation and descriptive public method names clearly communicate its wrapper role; however, the purpose of the intermediate methods suffixed with '0' is not explained. Code length: Individual methods are concise, though repeated forwarding layers add boilerplate and length. Action granularity: Each statement performs one action, and delegation and return statements are cleanly separated where needed. Reading flow: Consistent formatting and predictable method patterns support natural reading, although following public methods through intermediate helpers introduces minor indirection.
Run 2
Code Structure: Methods are logically organized, with related overloads and delegation helpers adjacent. Nesting: There is no nested control flow, making every method easy to scan. Clarity of intent: Class documentation and descriptive method names clearly convey a wrapper that delegates to an underlying buffer; however, the purpose of the extra methods ending in '0' is not explained. Code length: Individual methods are concise, although repeated forwarding layers add some verbosity. Action granularity: Each statement performs one action, with delegation and returning this separated cleanly. Reading flow: Consistent formatting, annotations, and predictable method patterns support natural top-to-bottom reading, with minor interruptions from the additional helper indirection.
Run 3
Code Structure: Logically organized as a wrapper base class, grouping related reference-counting and buffer operations. Nesting: Flat methods with no nested control flow make scanning easy. Clarity of intent: Documentation, descriptive API names, and consistent delegation to unwrap() clearly communicate the purpose; helper names ending in 0 are less informative, and their extra indirection is unexplained. Code length: Individual methods are concise, though repeated public/helper method pairs add boilerplate. Action granularity: Each statement performs one action, with mutation and return statements cleanly separated. Reading flow: Consistent formatting, annotations, and repeated delegation patterns create a predictable flow, slightly interrupted by the additional helper layer.