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. It has a clear structure: a package declaration, imports (implied), a well-documented interface, and a constant implementing it. The nesting is minimal, with only one anonymous class. Intent is clearly communicated through descriptive method names (started, receivedFinalHeaders, terminated) and thorough Javadoc comments. Code length is appropriate for the functionality, avoiding unnecessary verbosity. Each method in the anonymous class performs a single action. The reading flow is natural, from interface definition to its constant implementation.
Run 3
The code is highly readable. The interface is logically structured with clear, well-documented methods. Nesting is minimal, limited to a single anonymous class implementation. Intent is clearly stated through the interface name, method names, and comprehensive Javadoc comments. Code length is appropriate for the abstraction being defined, with no unnecessary verbosity. Each method performs a single action and returns a boolean. The reading flow is natural, following a logical progression from state definition to state query methods. The inclusion of a NO_STATE default implementation is a good pattern that improves clarity.
Run 1
Code Structure: The interface logically groups a stateless default implementation and three state-query methods. Nesting: Minimal; the anonymous implementation adds only one straightforward level. Clarity of intent: Descriptive method names and Javadoc explain the stream lifecycle, although receivedFinalHeaders() sounds receive-only despite documenting both sending and receiving. Code length: Appropriately short, with some redundant wording between descriptions and return documentation. Action granularity: Each statement performs a single action, and each implementation method simply returns false. Reading flow: Consistent formatting and method ordering make the code easy to scan; placing NO_STATE before the method declarations slightly delays discovery of the interface contract. Minor grammatical issues in the documentation do not substantially hinder readability.
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 methods. Clarity of intent: Descriptive method names and Javadoc explain the stream lifecycle, though receivedFinalHeaders() is slightly inconsistent with documentation covering both sending and receiving. Code length: Compact implementation, with some redundant wording between Javadoc descriptions and return documentation. Action granularity: Each method performs a single, simple action, and declarations are cleanly separated. Reading flow: Consistent formatting and spacing make the code easy to scan; the default implementation appearing before the query declarations causes only a minor interruption.
Run 3
Code Structure: The interface is logically organized, with a no-state implementation followed by three clearly documented state queries. Nesting: Minimal nesting; the anonymous implementation adds only a shallow level. Clarity of intent: Descriptive method names and Javadoc make the purpose clear, although receivedFinalHeaders() is named for receiving while its documentation also covers sending. Code length: Concise implementation, with slightly repetitive Javadoc descriptions and return documentation. Action granularity: Each method performs one simple action, and statements occupy separate lines. Reading flow: Consistent formatting, spacing, and method ordering make the code easy to scan and understand.