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 with clear purpose, demonstrating good readability. The class has a focused responsibility (preventing reference count changes) and follows logical organization with methods grouped by related functionality. Nesting is minimal, with only one conditional in the order() method. Variable naming is descriptive (swappedBuf, endianness) and the constructor cleverly unwraps nested instances. Comments explain non-obvious design decisions, particularly regarding potential memory leaks. The code length is appropriate, avoiding unnecessary verbosity while providing meaningful overrides. Action granularity is mostly one action per line. Reading flow is natural, with related methods grouped together. Minor improvements could include extracting the repeated leak-prevention comment into a class-level javadoc, but this doesn't significantly impact readability.
Run 2
The code is highly readable with clear structure and intent. The class serves a single, well-documented purpose: wrapping ByteBuf to prevent reference count changes. Methods are logically organized, flat (no deep nesting), and concise—each method performs one clear action. The use of delegation methods like `slice()`, `duplicate()`, and `readSlice()` is straightforward, though there is minor repetition in comments for retained methods. The constructor handles unwrapping gracefully, and the `order()` method is efficient with proper null checks. Action granularity is excellent—one operation per line. Reading flow is natural, with names clearly expressing intent. Minor improvements could reduce comment repetition, but overall this is exemplary maintainable code.
Run 3
The code is highly readable due to its clear structure, flat nesting, and consistent one-action-per-line granularity. The class purpose is well-documented, and method names clearly express intent. Redundant comments are repeated but helpful in explaining non-obvious design decisions regarding leak prevention. The `order()` method has slightly more complex nesting with lazy initialization, but remains understandable. Overall, the code is concise, logically organized, and follows a natural reading flow.
Run 1
Code Structure: Logically organized wrapper class, with related buffer operations grouped before reference-count methods. Nesting: Very shallow; simple conditionals and early returns keep methods easy to follow. Clarity of intent: Descriptive names, class documentation, and explanatory comments clearly communicate the unreleasable behavior and retained-operation choices. Code length: Methods are concise, although repeated leak-related comments add avoidable length. Action granularity: Most lines perform one clear action; the chained assignment in order() combines local and field updates, slightly reducing readability. Reading flow: Consistent overrides and predictable delegation produce a natural flow. Minor friction comes from the local variable shadowing swappedBuf and compact ternary expressions, but overall readability is high.
Run 2
Code Structure: Well-organized wrapper class with related operations grouped coherently and small, focused overrides. Nesting: Very shallow; simple conditionals and early returns make control flow easy to follow. Clarity of intent: The class documentation, descriptive method names, and explanatory comments clearly establish reference-count suppression and wrapping behavior. Code length: Methods are concise, although repeated leak-explanation comments add avoidable length. Action granularity: Most lines perform a single action; the chained assignment in order() combines cache and local-variable updates, slightly reducing clarity. Reading flow: Consistent formatting and predictable delegation create a natural flow. Minor friction comes from the local variable shadowing the swappedBuf field and repeated comments, but overall readability is high.
Run 3
Code Structure: Well-organized wrapper class with small, focused overrides and related operations grouped together. Nesting: Very shallow; simple conditionals and early returns make control flow easy to follow. 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 unnecessary length. Action granularity: Most lines perform one action, but the chained assignment in order() combines cache initialization and local assignment, slightly reducing clarity. Reading flow: Consistent formatting and predictable delegation patterns support natural reading. Minor friction comes from the local swappedBuf shadowing the field and the constructor's compact conditional expression.