Source code
package io.netty.handler.codec.socks;
import io.netty.buffer.ByteBuf;
import io.netty.util.internal.ObjectUtil;
/**
* An socks init response.
*
* @see SocksInitRequest
* @see SocksInitResponseDecoder
*/
public final class SocksInitResponse extends SocksResponse {
private final SocksAuthScheme authScheme;
public SocksInitResponse(SocksAuthScheme authScheme) {
super(SocksResponseType.INIT);
this.authScheme = ObjectUtil.checkNotNull(authScheme, "authScheme");
}
/**
* Returns the {@link SocksAuthScheme} of this {@link SocksInitResponse}
*
* @return The {@link SocksAuthScheme} of this {@link SocksInitResponse}
*/
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 has a clear, single-purpose class with a flat structure and minimal nesting. The constructor and methods are straightforward, each performing one clear action. Javadoc comments adequately explain the class, constructor parameter, and return value. Naming is consistent with Netty conventions, and the code is concise without being overly terse. The encodeAsByteBuf method reads naturally, writing the protocol version then the auth scheme. Minor points: the class-level comment is slightly terse ('An socks init response') and could be more descriptive, but this does not meaningfully impact readability. Overall, it follows clean code principles effectively.
Run 2
The code is highly readable, with clear structure and purpose. It follows standard Java conventions: a well-named class extending a clear hierarchy, a single immutable field with validation, a constructor that ensures non-null state, a simple getter, and a concise override. Nesting is minimal, and the encoding method has one action per line, making the flow natural. The only minor deduction is the redundant Javadoc for a simple getter, which adds slight length without much value. Overall, the code is easy to understand at a glance.
Run 3
The code is highly readable. It has a clear single-purpose class with minimal responsibilities. The structure is logical, with fields, constructor, accessor, and encode method in a natural order. Nesting is non-existent. Intent is explicit through clear naming and concise Javadoc. The code is concise without being cryptic. Each statement performs one action. The dependency on ObjectUtil for null-checking is appropriate. Minor deductions: Javadoc could elaborate slightly on encoding format, but this does not meaningfully affect readability.
Run 1
Code Structure: Cleanly organized into a field, constructor, accessor, and encoding method. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive class, field, and method names make the response's purpose clear; constructor validation explicitly enforces a non-null authentication scheme. Code length: Concise implementation, although the accessor documentation is repetitive. Action granularity: Each statement performs one focused action, and the two encoded bytes are written on separate lines. Reading flow: Natural progression from initialization to access and serialization. Minor presentation issues include missing spacing between the package declaration and imports and the grammatical error 'An socks init response.'
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, explicit null validation, and straightforward byte writes clearly communicate the response's purpose. Code length: The implementation is concise, though the accessor documentation is slightly repetitive. Action granularity: Each statement performs one clear action on its own line. Reading flow: The progression from initialization to access and serialization is natural. Minor issues include missing spacing between the package declaration and imports and the grammatical error 'An socks init response.'
Run 3
Code Structure: The class is logically organized into a field, constructor, accessor, and encoder. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names, explicit null validation, and straightforward byte writes make the purpose clear. Code length: The implementation is concise, though the accessor documentation is slightly repetitive. Action granularity: Each statement performs one distinct action on its own line. Reading flow: The progression from initialization to access and encoding is natural. Minor formatting and documentation issues, such as no blank line after the package declaration and the phrase 'An socks init response,' slightly reduce polish.