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 demonstrates excellent readability with clear structure and single-purpose methods. Each method follows a consistent pattern: wrap operations that create new buffers with UnreleasableByteBuf while making reference counting operations no-ops. The nesting is minimal, with only one level in the order() method. Intent is clear from method names and educational comments explaining why retained operations delegate to non-retained versions. The class has a single responsibility - preventing reference count manipulation. Action granularity is appropriate with single statements per method. The reading flow is natural, grouping similar operations (slices, duplicates, retain/release). Potential minor improvements: the order() method could extract the swapped buffer check, and the repeated comment could be consolidated, but these are negligible concerns.
Run 3
The code is highly readable with clear structure, minimal nesting, and obvious intent. Each method performs a single logical action per line. The class prevents reference count changes by overriding retain/release/touch to return safe values. Method names and comments explain non-obvious choices, such as using slice() instead of retainedSlice(). The constructor's conditional unwrap is concise and purposeful. Overall flow is natural and consistent.
Run 1
Code Structure: Logically organized wrapper with related operations grouped together and consistent overrides. Nesting: Very shallow, with simple conditionals and early returns. Clarity of intent: Class documentation, descriptive method names, and comments explain reference-count protection and retained-operation behavior. Code length: Methods are concise, although repeated explanatory comments add avoidable length. Action granularity: Most lines perform one action; the chained assignment in order() and inline null validation slightly reduce clarity. Reading flow: Consistent formatting and predictable delegation make the code easy to follow, though local-field name shadowing in order() introduces minor friction.
Run 2
Code Structure: Small, clearly separated overrides logically implement the wrapper behavior. Nesting: Almost entirely flat, with simple conditionals and early returns. Clarity of intent: The class documentation, descriptive method names, and explanatory comments make reference-count suppression and derived-buffer wrapping clear. Code length: Methods are concise; repeated explanatory comments add some unnecessary length, though the overrides are appropriate. Action granularity: Most lines perform one action, but the chained assignment in order() combines cache initialization and local assignment, slightly reducing readability. Reading flow: Consistent formatting and grouping of related slice, duplicate, and reference-count methods support natural reading. Minor friction comes from the local swappedBuf shadowing the field and compact ternary expressions.
Run 3
Code Structure: Well-organized wrapper class with related overrides grouped logically and consistent formatting. Nesting: Very shallow; short methods and early returns keep control flow easy to follow. Clarity of intent: Class documentation, descriptive method names, and comments clearly explain reference-count protection and retained-operation behavior. Code length: Methods are concise, although repeated explanatory comments add unnecessary length. Action granularity: Most lines perform one clear action; the chained assignment in order() combines cache initialization and local assignment, slightly reducing readability. Reading flow: Predictable delegation patterns and grouping of slice, duplicate, and reference-count methods support natural reading. Minor friction comes from local-field name shadowing and the compact constructor ternary.