Source code
package io.netty.buffer;
import io.netty.util.internal.ObjectUtil;
import java.nio.ByteOrder;
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) {
return readSlice(length);
}
@Override
public ByteBuf slice() {
return new UnreleasableByteBuf(buf.slice());
}
@Override
public ByteBuf retainedSlice() {
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) {
return slice(index, length);
}
@Override
public ByteBuf duplicate() {
return new UnreleasableByteBuf(buf.duplicate());
}
@Override
public ByteBuf retainedDuplicate() {
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 demonstrates good readability with clear class structure and intent. The purpose of each method is straightforward - making a ByteBuf unreleasable while maintaining standard buffer operations. Nesting is shallow with only one level of conditional logic in the order() method. Action granularity is excellent with single operations per line. The methods are concise and follow predictable patterns. However, there are minor issues: the empty comment blocks and multiple blank lines create visual noise. The order() method slightly violates the single responsibility principle by handling null checks, order comparison, and cache initialization together. The repeated pattern of wrapping returned buffers could be extracted to a helper method to reduce duplication. Reading flow is generally natural, though the empty comments in retainedSlice/readRetainedSlice/retainedDuplicate methods are distracting and unclear in purpose. Overall, the code is well-structured and readable but could benefit from removing unnecessary comments and minor refactoring.
Run 2
The code is generally well-structured and readable. It follows a logical class hierarchy and maintains flat nesting throughout. Method names clearly express intent, and each method performs a single action. The use of a lazy-initialized SwappedByteBuf is a clear, common pattern. However, readability is slightly reduced by the presence of empty multi-line comments in several methods (e.g., readRetainedSlice, retainedSlice, retainedDuplicate), which are ambiguous and break reading flow. These comments appear to be intentional placeholders or suppression markers, but without context they create visual noise. The constructor's ternary operation is concise but slightly reduces immediate clarity. Overall, the code is maintainable and easy to follow, with only minor stylistic inconsistencies.
Run 3
The code is highly readable with clear, logical structure and flat nesting. Each method performs a single, well-defined action, maintaining one action per line. The class purpose is evident: wrapping a ByteBuf to prevent reference counting operations. Methods like retain(), release(), and touch() are concise no-ops that clearly communicate intent. The order() method demonstrates good lazy initialization pattern without excessive nesting. One minor issue is the repeated pattern of three empty comment lines in readRetainedSlice(), retainedSlice(), and retainedDuplicate() methods, which slightly disrupts reading flow. The constructor's conditional unwrapping logic is slightly dense but acceptable given its brevity. Overall, the code is clean, maintainable, and follows good practices for wrapper class design in Java.
Run 1
Code Structure: Methods are logically grouped around byte ordering, buffer views, and reference-count operations. Nesting: Control flow is shallow, with simple conditionals and early returns. Clarity of intent: The class name and consistent overrides clearly convey an unreleasable wrapper, although retained methods delegating to non-retained variants and no-op reference-count methods would benefit from brief explanations. Code length: Most methods are concise; repetition largely follows the interface, but excessive blank lines add unnecessary length. Action granularity: Most lines perform one action, though the chained assignment in order() combines local assignment, field assignment, and object creation. Reading flow: Consistent formatting and predictable delegation make the code easy to follow, with minor interruptions from whitespace and the local variable shadowing swappedBuf.
Run 2
Code Structure: Methods are logically organized in a cohesive wrapper class, with related operations grouped together. Nesting: Control flow is shallow, using simple conditionals and direct returns. Clarity of intent: Class and method names clearly convey an unreleasable buffer wrapper, although the retained-operation delegation and no-op reference-counting methods could benefit from brief explanations. Code length: Methods are concise; repetitive overrides are appropriate for the wrapper interface, but excessive blank lines add unnecessary length. Action granularity: Most lines perform one action, though the chained assignment in order() combines local and field updates, and null validation is embedded in a comparison. Reading flow: Consistent signatures and straightforward delegation make the class easy to scan, with minor interruptions from whitespace and local variable shadowing.
Run 3
Code Structure: Methods are logically grouped around buffer views and reference-counting operations, with consistent overrides. Nesting: Control flow is shallow, using simple conditionals and early returns. Clarity of intent: The class name and no-op retain/release methods communicate an unreleasable wrapper, though retained-view behavior and swapped-buffer caching could benefit from brief explanations. Code length: Methods are concise; repetition largely reflects the overridden API, but excessive blank lines unnecessarily expand the code. Action granularity: Most lines perform one action, except the chained assignment in order(), which combines cache initialization and local assignment. Reading flow: Consistent method formatting and related-method grouping make scanning natural, while local field-name shadowing and irregular whitespace introduce minor friction.