Source code
package io.netty.handler.codec.socks;
import io.netty.buffer.ByteBuf;
import io.netty.util.internal.ObjectUtil;
public final class SocksInitResponse extends SocksResponse {
private final SocksAuthScheme authScheme;
public SocksInitResponse(SocksAuthScheme authScheme) {
super(SocksResponseType.INIT);
this.authScheme = ObjectUtil.checkNotNull(authScheme, "authScheme");
}
public SocksAuthScheme authScheme() {
return authScheme;
}
@Override
public void encodeAsByteBuf(ByteBuf byteBuf) {
byteBuf.writeByte(protocolVersion().byteValue());
byteBuf.writeByte(authScheme.byteValue());
}
}
Run 1
The code is highly readable. It follows a clear, logical structure with package and imports at the top, followed by a single class with a constructor, accessor method, and overridden encode method. Nesting is minimal, and the class has a clear, single responsibility. The constructor uses ObjectUtil.checkNotNull for input validation, making intent explicit. The encodeAsByteBuf method is concise, with one action per line, and the flow naturally follows the SOCKS protocol structure. Minor deductions are for unused blank lines and a lack of Javadoc, but overall readability is excellent.
Run 2
The code is well-structured with clear separation of concerns, minimal nesting, and concise implementation. The class has a single responsibility and follows the builder pattern effectively. Intent is clear: a response object carrying an authentication scheme. Lines are short and each performs one action. Minor deductions: unnecessary import whitespace and a blank method section before authScheme() slightly disrupt reading flow, though not severely. Overall, highly readable.
Run 3
The code is highly readable with a clean, logical structure. The class has a single, clear responsibility: representing a SOCKS INIT response. Imports are minimal and relevant. The constructor uses ObjectUtil.checkNotNull for validation, making intent explicit. Methods are concise and well-named (authScheme(), encodeAsByteBuf). Nesting is completely flat, with no conditional logic or deep indentation. Action granularity is ideal—one operation per line in the encode method. The only minor deductions are the slightly excessive blank lines within the class body and a missing newline at the end of the file, which slightly disrupt visual flow. Overall, the code follows standard Java conventions and Netty patterns, making it immediately understandable to any developer familiar with the codebase.
Run 1
Code Structure: Logically organized into a field, constructor, accessor, and encoding method. Nesting: Minimal, with no nested control flow. Clarity of intent: Descriptive class, method, and variable names make the response's purpose clear; constructor validation is explicit. Code length: Implementation is concise, but excessive blank lines add unnecessary visual length. Action granularity: Each statement performs one clear action on its own line. Reading flow: The member order is natural, and encoding steps are easy to follow, though inconsistent whitespace interrupts visual continuity.
Run 2
Code Structure: The class is logically organized into a field, constructor, accessor, and encoding method. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names and straightforward validation make the response's purpose clear. Code length: The implementation is concise, although excessive blank lines add unnecessary visual length. Action granularity: Each statement performs one clear action, and the two encoded values are written on separate lines. Reading flow: The progression from initialization to access and serialization is natural, but inconsistent whitespace interrupts scanning.
Run 3
Code Structure: Logically organized into a field, constructor, accessor, and encoding method. Nesting: Flat and easy to follow, with no nested control flow. Clarity of intent: Descriptive class, field, and method names clearly convey a SOCKS initialization response and its serialization. Code length: The implementation is concise, although excessive blank lines add unnecessary visual length. Action granularity: Each statement performs one clear action. Reading flow: The progression from initialization to access and encoding is natural, but inconsistent whitespace slightly disrupts scanning.