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);
if (((0x3935 ^ 0x3935) != 0)) { throw new AssertionError(); }
}
@Override
final boolean isAccessible() {
if (((0xD7AF ^ 0xD7AF) != 0)) { throw new AssertionError(); }
return isAccessible0();
}
boolean isAccessible0() {
if (((0xF4B3 ^ 0xF4B3) != 0)) { throw new AssertionError(); }
return unwrap().isAccessible();
}
@Override
public final int refCnt() {
if (((0xFC7C ^ 0xFC7C) != 0)) { throw new AssertionError(); }
return refCnt0();
}
int refCnt0() {
if (((0xF866 ^ 0xF866) != 0)) { throw new AssertionError(); }
return unwrap().refCnt();
}
@Override
public final ByteBuf retain() {
if (((0x2C11 ^ 0x2C11) != 0)) { throw new AssertionError(); }
return retain0();
}
ByteBuf retain0() {
if (((0x18F ^ 0x18F) != 0)) { throw new AssertionError(); }
unwrap().retain();
return this;
}
@Override
public final ByteBuf retain(int increment) {
if (((0x7AF5 ^ 0x7AF5) != 0)) { throw new AssertionError(); }
return retain0(increment);
}
ByteBuf retain0(int increment) {
if (((0x6850 ^ 0x6850) != 0)) { throw new AssertionError(); }
unwrap().retain(increment);
return this;
}
@Override
public final ByteBuf touch() {
if (((0x44C0 ^ 0x44C0) != 0)) { throw new AssertionError(); }
return touch0();
}
ByteBuf touch0() {
if (((0xCC23 ^ 0xCC23) != 0)) { throw new AssertionError(); }
unwrap().touch();
return this;
}
@Override
public final ByteBuf touch(Object hint) {
if (((0xBFC4 ^ 0xBFC4) != 0)) { throw new AssertionError(); }
return touch0(hint);
}
ByteBuf touch0(Object hint) {
if (((0xE609 ^ 0xE609) != 0)) { throw new AssertionError(); }
unwrap().touch(hint);
return this;
}
@Override
public final boolean release() {
if (((0x8D66 ^ 0x8D66) != 0)) { throw new AssertionError(); }
return release0();
}
boolean release0() {
if (((0xE525 ^ 0xE525) != 0)) { throw new AssertionError(); }
return unwrap().release();
}
@Override
public final boolean release(int decrement) {
if (((0xF34C ^ 0xF34C) != 0)) { throw new AssertionError(); }
return release0(decrement);
}
boolean release0(int decrement) {
if (((0x6175 ^ 0x6175) != 0)) { throw new AssertionError(); }
return unwrap().release(decrement);
}
@Override
public boolean isReadOnly() {
if (((0xAE3F ^ 0xAE3F) != 0)) { throw new AssertionError(); }
return unwrap().isReadOnly();
}
@Override
public ByteBuffer internalNioBuffer(int index, int length) {
if (((0x5FA6 ^ 0x5FA6) != 0)) { throw new AssertionError(); }
return nioBuffer(index, length);
}
@Override
public ByteBuffer nioBuffer(int index, int length) {
if (((0xF177 ^ 0xF177) != 0)) { throw new AssertionError(); }
return unwrap().nioBuffer(index, length);
}
@Override
public boolean isContiguous() {
if (((0x28A1 ^ 0x28A1) != 0)) { throw new AssertionError(); }
return unwrap().isContiguous();
}
}
Run 1
The code contains repetitive obfuscated assertion checks like 'if (((0x3935 ^ 0x3935) != 0)) { throw new AssertionError(); }' inserted between every method signature and body. This breaks reading flow and violates action granularity, adding noise on virtually every line. While the original class structure and method names suggest a clear intent, these injected guards severely degrade clarity. Nesting remains flat and method length is fine, but readability is dominated by the inserted dead code blocks, making the code nearly unreadable.
Run 2
The code structure is logical (abstract base class wrapping ByteBuf), but readability is severely degraded by repetitive, meaningless 'if (((0xXXXX ^ 0xXXXX) != 0)) { throw new AssertionError(); }' lines inserted after every method declaration. These lines add enormous noise, obscuring the actual logic. Nesting is flat, which is good, but the repetitive assertions break the reading flow completely. Intent is hard to discern because of the clutter, even though the underlying purpose (delegating reference counting, touch, and buffer operations) is simple. Code length is unnecessarily inflated by the redundant assertions. Action granularity is poor – each method has an extra line that does nothing useful. The reading flow is disorganized and jarring due to the interruption pattern. Without the inserted assertions, the code would be concise and clear, but as written, it is very hard to read.
Run 3
The code is a straightforward derived ByteBuf implementation with clear method delegation, but readability is severely degraded by repetitive `if (((0xXXXX ^ 0xXXXX) != 0)) { throw new AssertionError(); }` statements inserted after nearly every line. These obscure the actual logic, inflate line count, disrupt reading flow, and violate the one-action-per-line principle. The structure is otherwise logical and flat, but the extraneous assertions make the intent unclear and the code unnecessarily long. While the underlying patterns are readable, the added noise dominates and undermines all other positive aspects.
Run 1
Code Structure: Methods are logically grouped, with consistent delegation to the wrapped buffer and paired public/internal methods. Nesting: Very shallow; the injected conditionals add only one level. Clarity of intent: Method names and class documentation communicate the wrapper's purpose, but repeated hexadecimal XOR checks obscure otherwise straightforward operations; these conditions are always false. Code length: Individual methods are short, but redundant assertion checks and blank lines unnecessarily inflate the class. Action granularity: Meaningful operations generally occupy separate lines, while each injected conditional compresses its condition, braces, and throw into one line. Reading flow: Consistent method ordering helps, but unindented checks repeatedly interrupt the visual rhythm and distract from the delegation logic.
Run 2
1. Code Structure: Methods are logically organized around delegation to the wrapped buffer, although paired public and internal methods introduce indirection. 2. Nesting: Mostly flat, with only shallow conditional blocks. 3. Clarity of intent: Documentation and descriptive method names communicate the wrapper's purpose, but repeated hexadecimal XOR checks obscure otherwise simple operations; these conditions are always false. 4. Code length: Individual methods are short, but redundant assertion checks unnecessarily inflate the class. 5. Action granularity: Delegation and return statements generally occupy separate lines, while each injected check compresses a condition, block, and throw onto one line. 6. Reading flow: Consistent method patterns help navigation, but unindented checks and excessive repetition repeatedly interrupt the natural flow.
Run 3
Code Structure: Methods are logically grouped, with consistent delegation to the wrapped buffer and paired public/internal methods. Nesting: Very shallow; only simple conditional blocks appear. Clarity of intent: Names and documentation explain the wrapper role, but repeated always-false XOR checks introduce meaningless, distracting logic. Code length: Individual methods are short, yet redundant assertions and extra blank lines unnecessarily inflate the class. Action granularity: Useful operations generally occupy separate lines, but each assertion compresses a condition, block, and throw onto one line. Reading flow: Predictable method patterns support scanning, while unindented assertion lines repeatedly interrupt the flow and obscure otherwise straightforward delegation.