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() {
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 is highly readable. It uses a clean interface with clear, well-documented methods that describe HTTP/3 stream state. The structure is logical: a constant NO_STATE provides an immutable no-op implementation, and the three state-checking methods are purpose-driven and concise. Nesting is minimal—only one anonymous inner class with flat method overrides. Each method has a single clear action and Javadoc explains intent and edge cases. Reading flow is natural, moving from interface purpose to a default implementation to query methods. Minor deductions: the anonymous class adds slight verbosity, and the Javadoc references could be simplified, but overall the code is nearly ideal in clarity and structure.
Run 2
The code is highly readable due to its clear structure, minimal nesting, and well-documented intent. It defines a single interface with three methods, each with a clear purpose and Javadoc explaining the semantics. The anonymous implementation for NO_STATE is concise and follows a straightforward pattern. The code avoids unnecessary complexity, with no deep nesting or multiple actions per line. Reading flow is natural: interface declaration, constant definition, then method declarations. The only minor issue is that the interface name could be slightly more concise, but overall this is exemplary code for clarity and maintainability.
Run 3
The code is highly readable due to its clear structure, minimal nesting, and well-documented intent. It defines a single interface with three boolean methods and a no-op implementation, keeping each action on its own line. The reading flow is natural: package declaration, imports, Javadoc, interface, constant, and method declarations. The Javadoc comments are informative and explain the purpose of each method and constant well. The NO_STATE anonymous class is concise and avoids unnecessary complexity. The only minor downside is that the interface might benefit from a slightly more descriptive name, but this does not significantly impact readability.
Run 1
Code Structure: The interface cleanly groups a stateless implementation and three related state queries. Nesting: Minimal; the anonymous implementation adds only a shallow level. Clarity of intent: Descriptive method names and Javadoc explain the stream lifecycle, although receivedFinalHeaders() suggests receiving only while its documentation also covers sending. Code length: Compact implementation, with slightly repetitive Javadoc and unavoidable override boilerplate. Action granularity: Each method performs a single action, and declarations and annotations occupy separate lines. Reading flow: Consistent formatting and method ordering make the code easy to scan. Minor grammatical issues in comments and repeated descriptions slightly reduce polish.
Run 2
Code Structure: The interface logically groups three state queries and a clearly named NO_STATE implementation. Nesting: Only shallow nesting is used for the anonymous implementation and its methods. Clarity of intent: Descriptive method names and Javadoc explain the stream lifecycle states, though receivedFinalHeaders() sounds receive-specific despite covering both sending and receiving. Code length: The code is compact, with some repetition between Javadoc descriptions and return documentation. Action granularity: Each method performs a single, simple action, and declarations are clearly separated. Reading flow: Consistent formatting and method ordering make the code easy to follow; placing the NO_STATE implementation before the documented interface methods slightly delays discovery of the contract.
Run 3
Code Structure: The interface logically groups three state queries and a clearly named stateless implementation. Nesting: Minimal nesting, limited to the anonymous implementation and its short methods. Clarity of intent: Descriptive method names and Javadoc explain the stream lifecycle; receivedFinalHeaders() is slightly less consistent with documentation covering both sending and receiving. Code length: Concise implementation, though the Javadoc repeats descriptions in return clauses. Action granularity: Each method performs one simple action, with no combined statements. Reading flow: Consistent formatting and lifecycle-oriented method ordering make the code easy to scan. Minor documentation verbosity and grammatical issues prevent a perfect score.