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 and purpose. The interface defines a small, cohesive set of methods with descriptive Javadoc explaining each contract. The NO_STATE constant provides a clear null-object implementation with flat, simple method bodies. Naming is explicit and consistent. There is no deep nesting, and each method has a single responsibility, making the reading flow natural. The code is concise without sacrificing clarity.
Run 3
The code is well-structured with a clear interface definition and meaningful method names. The NO_STATE implementation follows the null-object pattern cleanly, with methods returning simple boolean values. Documentation is thorough but concise, explaining each method's purpose without excessive verbosity. Nesting is minimal—only one level for the anonymous inner class. Each method contains a single action, maintaining excellent action granularity. Reading flow is natural: interface declaration, constant, then method definitions with their Javadoc. The only minor deductions are for slight redundancy in the Javadoc (the @return statements repeat what's already clear from the method signatures) and the anonymous inner class could potentially be a private static nested class for even better readability. Overall, highly readable code that clearly communicates its intent.
Run 1
Code Structure: The interface logically groups three stream-state queries and a clearly named stateless implementation. Nesting: Minimal; the anonymous implementation adds only one shallow level. Clarity of intent: Descriptive method names and Javadoc explain the states well, though receivedFinalHeaders() suggests receiving only while its documentation also covers sending. Code length: Short overall, but repeated Javadoc descriptions and constant-false implementations add minor verbosity. Action granularity: Each return and method declaration occupies its own line, with no combined actions. Reading flow: Consistent formatting and method ordering make the code easy to scan; the NO_STATE implementation mirrors the interface declarations. Minor documentation issues, such as 'managed no state,' slightly reduce polish.
Run 2
Code Structure: The interface logically groups three state queries and a clearly identified stateless implementation. Nesting: Minimal nesting, limited to the anonymous implementation and its short methods. Clarity of intent: Descriptive method names and Javadoc explain each state, although receivedFinalHeaders() sounds receive-specific while its documentation also covers sending. Code length: The implementation is concise; repeated Javadoc descriptions add minor verbosity. Action granularity: Each method performs one simple action, with statements on separate lines. Reading flow: Consistent formatting and method ordering make the code easy to scan, with the anonymous implementation mirroring the interface declarations.
Run 3
Code Structure: The interface logically groups three state queries and a clearly identified stateless implementation. Nesting: Only the anonymous implementation introduces nesting; its methods are flat and trivial. Clarity of intent: Descriptive method names and Javadoc explain the stream lifecycle, though receivedFinalHeaders() sounds receive-only while its documentation covers sending too. Code length: The code is concise overall, with minor repetition between Javadoc descriptions and return documentation. Action granularity: Each method performs one action, and declarations and annotations occupy separate lines. Reading flow: Consistent formatting and method ordering make the code easy to scan, although placing NO_STATE before the documented method declarations slightly delays discovery of the interface contract.