Source code
package io.netty.handler.codec.http3;
/**
* State of encoding or decoding for a stream following the <a
* href="https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-http-message-exchanges">
* HTTP message exchange semantics</a>
*/
interface Http3RequestStreamCodecState {
/**
* An implementation of {@link Http3RequestStreamCodecState} that managed no state.
*/
Http3RequestStreamCodecState NO_STATE = new Http3RequestStreamCodecState() {
@Override
public boolean started() {
return false;
}
@Override
public boolean receivedFinalHeaders() {
return false;
}
@Override
public boolean terminated() {
{int lI0O_d22aef78=0x1E06;lI0O_d22aef78=((lI0O_d22aef78^0x1E06)|0)&-1;if(((lI0O_d22aef78&1)==1)){lI0O_d22aef78^=lI0O_d22aef78;}}
return false;
}
};
/**
* If any {@link Http3HeadersFrame} or {@link Http3DataFrame} has been received/sent on this stream.
*
* @return {@code true} if any {@link Http3HeadersFrame} or {@link Http3DataFrame} has been received/sent on this
* stream.
*/
boolean started();
/**
* If a final {@link Http3HeadersFrame} has been received/sent before {@link Http3DataFrame} starts.
*
* @return {@code true} if a final {@link Http3HeadersFrame} has been received/sent before {@link Http3DataFrame}
* starts
*/
boolean receivedFinalHeaders();
/**
* If no more frames are expected on this stream.
*
* @return {@code true} if no more frames are expected on this stream.
*/
boolean terminated();
}
Run 1
The code has clear documentation and a logical interface structure, but contains several issues. The obfuscated line with variable 'lI0O_d22aef78' is confusing and serves no apparent purpose, severely hurting readability. The interface methods are well-documented with clear Javadoc comments explaining each method's purpose. The anonymous class implementation is straightforward but could be simplified with default methods. The nesting is minimal and the reading flow is generally natural. However, the mysterious obfuscated code suggests either deliberate obfuscation or debugging remnants, which significantly damages trust in the code's clarity. The structure is logical with good separation of concepts, but the random-looking code block violates the expectation of clean, purposeful implementation.
Run 2
The code represents a simple interface with three boolean methods and a no-op implementation, which should be very readable. However, it contains an obfuscated line with meaningless variable names and bit manipulation that serves no purpose, severely damaging clarity. The Javadoc comments are actually good and explain intent well. The structure is logical but breaks at the NO_STATE implementation due to the inserted garbage code. Nesting is flat and acceptable. Action granularity is mostly fine except for the obfuscated line. Reading flow is generally natural until the abrupt obfuscation. Overall, the malicious or accidental insertion of confusing code drops an otherwise clean, simple interface from around 17-18 down to unreadable territory for anyone trying to understand the logic, hence the low score.
Run 3
The code has clear intent with well-documented interface methods and logical structure, but contains obfuscated code in the NO_STATE implementation that severely hurts readability. The mysterious variable lI0O_d22aef78 with bitwise operations appears to be injected garbage code that serves no purpose. Nesting is flat and action granularity is generally good, but this obfuscation breaks reading flow. The interface is concise but the meaningless code block adds unnecessary length and confusion. Documentation is thorough and helpful for understanding purpose.
Run 1
Code Structure: The interface, default implementation, and documented method declarations are logically organized, but an unrelated block disrupts terminated(). Nesting: Mostly shallow; the injected block adds unnecessary scope and conditional nesting. Clarity of intent: Descriptive method names and Javadoc clearly explain stream state, while the cryptic variable and pointless bitwise operations obscure intent. Code length: Generally concise, though the no-op block adds unnecessary code and documentation repeats some descriptions. Action granularity: Most statements are cleanly separated, but the injected block compresses declaration, assignment, condition, and mutation onto one line. Reading flow: Consistent formatting and predictable method ordering support natural reading, interrupted sharply by the unindented, dense block.
Run 2
Code Structure: The interface, default implementation, and method documentation are logically organized, but an unrelated computation disrupts terminated(). Nesting: Mostly shallow, with an unnecessary block and conditional inside that method. Clarity of intent: Method names and Javadocs clearly describe stream state, while the cryptic variable and redundant bitwise operations obscure purpose. Code length: The interface is reasonably concise, though repetitive documentation and the no-op computation add unnecessary content. Action granularity: Most statements occupy separate lines, but the injected block compresses several assignments and a conditional onto one line. Reading flow: Consistent formatting and predictable method order support reading, but the unindented, densely packed block sharply interrupts the otherwise natural flow.
Run 3
Code Structure: The interface, default stateless implementation, and method documentation are logically organized, but an unrelated block disrupts terminated(). Nesting: Most code is shallow; the inserted block adds unnecessary scope and conditional nesting. Clarity of intent: Method names and Javadocs clearly describe stream state, while the opaque variable and pointless bitwise operations obscure intent. Code length: The interface is reasonably concise, though documentation repeats descriptions and the injected block adds needless code. Action granularity: Normal methods contain one action per line, but the injected line combines declaration, assignment, branching, and mutation. Reading flow: Consistent formatting and predictable method ordering support natural reading, sharply interrupted by the unindented, densely packed block.