Source code
package io.netty.buffer;
import io.netty.util.internal.ObjectUtil;
import java.nio.ByteOrder;
/**
* A {@link ByteBuf} implementation that wraps another buffer to prevent a user from increasing or decreasing the
* wrapped buffer's reference count.
*/
final class UnreleasableByteBuf extends WrappedByteBuf {
private SwappedByteBuf swappedBuf;
UnreleasableByteBuf(ByteBuf buf) {
super(buf instanceof UnreleasableByteBuf ? buf.unwrap() : buf);
}
@Override
public ByteBuf order(ByteOrder endianness) {
if (ObjectUtil.checkNotNull(endianness, "endianness") == order()) {
return this;
}
SwappedByteBuf swappedBuf = this.swappedBuf;
if (swappedBuf == null) {
this.swappedBuf = swappedBuf = new SwappedByteBuf(this);
}
return swappedBuf;
}
@Override
public ByteBuf asReadOnly() {
return buf.isReadOnly() ? this : new UnreleasableByteBuf(buf.asReadOnly());
}
@Override
public ByteBuf readSlice(int length) {
return new UnreleasableByteBuf(buf.readSlice(length));
}
@Override
public ByteBuf readRetainedSlice(int length) {
// We could call buf.readSlice(..), and then call buf.release(). However this creates a leak in unit tests
// because the release method on UnreleasableByteBuf will never allow the leak record to be cleaned up.
// So we just use readSlice(..) because the end result should be logically equivalent.
return readSlice(length);
}
@Override
public ByteBuf slice() {
return new UnreleasableByteBuf(buf.slice());
}
@Override
public ByteBuf retainedSlice() {
// We could call buf.retainedSlice(), and then call buf.release(). However this creates a leak in unit tests
// because the release method on UnreleasableByteBuf will never allow the leak record to be cleaned up.
// So we just use slice() because the end result should be logically equivalent.
return slice();
}
@Override
public ByteBuf slice(int index, int length) {
return new UnreleasableByteBuf(buf.slice(index, length));
}
@Override
public ByteBuf retainedSlice(int index, int length) {
// We could call buf.retainedSlice(..), and then call buf.release(). However this creates a leak in unit tests
// because the release method on UnreleasableByteBuf will never allow the leak record to be cleaned up.
// So we just use slice(..) because the end result should be logically equivalent.
return slice(index, length);
}
@Override
public ByteBuf duplicate() {
return new UnreleasableByteBuf(buf.duplicate());
}
@Override
public ByteBuf retainedDuplicate() {
// We could call buf.retainedDuplicate(), and then call buf.release(). However this creates a leak in unit tests
// because the release method on UnreleasableByteBuf will never allow the leak record to be cleaned up.
// So we just use duplicate() because the end result should be logically equivalent.
return duplicate();
}
@Override
public ByteBuf retain(int increment) {
return this;
}
@Override
public ByteBuf retain() {
return this;
}
@Override
public ByteBuf touch() {
return this;
}
@Override
public ByteBuf touch(Object hint) {
return this;
}
@Override
public boolean release() {
return false;
}
@Override
public boolean release(int decrement) {
return false;
}
}
Run 1
The code is well-structured and readable. It uses clear class naming (UnreleasableByteBuf) and follows a consistent pattern of overriding methods to wrap ByteBuf operations. The structure is logical, grouping related methods (retain/release, slice/duplicate) together. Nesting is minimal with only a single level in the order() method. Intent is clear from the class documentation and method names. Code length is appropriate for the functionality - each method is concise. Action granularity is excellent with one action per line. Reading flow is natural with related methods clustered together. The comments explaining design decisions for readRetainedSlice and similar methods add clarity by explaining non-obvious choices. Minor improvements could include using Objects.requireNonNull instead of ObjectUtil.checkNotNull for consistency with standard Java, but this is a library-specific choice. Overall, the code demonstrates excellent maintainability and readability characteristics.
Run 2
The code is highly readable with clear structure and intent. It uses a flat class hierarchy, minimal nesting, and consistent method patterns that make the purpose of each override immediately obvious. Each method performs a single action or returns a wrapped result, maintaining one-action-per-line discipline. The comments explaining why retained methods delegate to non-retained versions show thoughtful reasoning without being verbose. Naming is descriptive, and the lazy initialization in the order() method is straightforward. Minor deductions: repeated comments could be consolidated, and the ternary in the constructor adds slight cognitive overhead, but overall flow and organization are excellent.
Run 3
This code is highly readable due to its clear structure and consistent patterns. The class has a single responsibility - preventing reference count modifications - and each method is concise with minimal nesting. The constructor intelligently unwraps existing UnreleasableByteBuf instances to avoid unnecessary wrapping. Method naming is clear and follows standard ByteBuf conventions. The code makes excellent use of delegation, with each method performing one clear action. Comments are used sparingly and only where they add significant value, explaining non-obvious design decisions about avoiding memory leaks. The only minor drawbacks are slight redundancy in the release/retain methods and the need for domain knowledge about ByteBuf semantics, but these are unavoidable given the wrapper pattern. The flat hierarchy and consistent one-line implementations contribute to excellent readability.
Run 1
Code Structure: Well-organized wrapper class with related overrides grouped logically. Nesting: Minimal, with shallow conditionals and simple method bodies. Clarity of intent: The class documentation, descriptive method names, and explanatory comments clearly communicate reference-count suppression and wrapper behavior. Code length: Methods are concise, although repeated leak-related comments add avoidable length. Action granularity: Most lines perform one action; the chained assignment in order() and its combined validation/comparison slightly reduce clarity. Reading flow: Consistent formatting and predictable delegation make the code easy to follow, though local-field name shadowing in order() requires extra attention. Overall, highly readable with minor opportunities to simplify repeated explanations and assignment syntax.
Run 2
Code Structure: Well-organized wrapper class with small, consistently implemented overrides and related methods grouped together. Nesting: Very shallow; only simple conditionals appear in order(). Clarity of intent: The class documentation clearly explains reference-count protection, and comments explain the retained-view behavior. Understanding inherited buffer operations requires some API familiarity. Code length: Methods are concise, although repeated explanatory comments add avoidable length. Action granularity: Most lines perform one clear action; the chained assignment in order() combines local assignment, field assignment, and construction, slightly reducing readability. Reading flow: Consistent formatting, descriptive method names, and predictable delegation make the class easy to scan. Local shadowing of swappedBuf and compact ternary expressions introduce minor reading friction.
Run 3
Code Structure: Well-organized wrapper class with small, focused overrides and related methods grouped together. Nesting: Very shallow; simple conditionals and early returns make control flow easy to follow. Clarity of intent: Class documentation, descriptive method names, and explanatory comments clearly communicate reference-count protection and retained-view behavior. Code length: Methods are concise, though repeated explanatory comments add avoidable bulk. Action granularity: Most lines perform one action; the chained assignment in order() combines local and field updates, slightly reducing clarity. Reading flow: Consistent formatting and predictable delegation create a natural flow. Minor friction comes from the local variable shadowing swappedBuf and the constructor's inline conditional.