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. It has a clear, logical structure: a single-purpose class with a constructor, a getter, and an encode method. Nesting is minimal—only inside the encodeAsByteBuf method, which is flat. Intent is evident from the class name, field name, and Javadoc comments, all of which use domain-specific terminology (Socks, authScheme, protocolVersion). Code length is concise; each method does exactly what its name suggests, with no unnecessary lines. Action granularity is appropriate: one statement per line, promoting clarity. Reading flow is natural—declarations, constructor, accessor, then behavior method—matching typical Java conventions. Overall, the code is easy to understand and maintain.
Run 3
The code is highly readable due to its clear structure, minimal nesting, and concise implementation. The class has a single responsibility, and the constructor validates input effectively. The encodeAsByteBuf method is straightforward, with one action per line. The Javadoc comments provide useful context, though they could be slightly more descriptive. Overall, the code demonstrates good practices and is easy to follow.
Run 1
Code Structure: The class is logically organized into a field, constructor, accessor, and encoding method. Nesting: There is no nested control flow, making the code easy to scan. Clarity of intent: Descriptive class, field, and method names clearly communicate the response's purpose; constructor validation is explicit. Code length: The implementation is concise, though the accessor documentation is slightly repetitive. Action granularity: Each statement performs one clear action, including separate writes for protocol version and authentication scheme. Reading flow: The progression from initialization to access and serialization is natural. Minor polish issues include the grammatical error in the class comment and the lack of a blank line between the package declaration and imports.
Run 2
Code Structure: The class is logically organized into a field, constructor, accessor, and encoding method. Nesting: Methods are flat, with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit types, null validation, and documentation make the response's purpose clear. Code length: The implementation is concise; 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, and encoding statements clearly show byte order. Minor presentation issues include the missing blank line between the package declaration and imports and the grammatical error in the class comment.
Run 3
Code Structure: The class is logically organized into a field, constructor, accessor, and encoding method. Nesting: Methods are flat, with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit null validation, and documentation clearly communicate the response's purpose. Code length: The implementation is concise, though the accessor documentation is somewhat repetitive. Action granularity: Each statement performs a single clear action on its own line. Reading flow: The progression from initialization to access and serialization is natural; a blank line between the package declaration and imports would slightly improve formatting.