Source code
package io.netty.handler.codec.socksx.v5;
import io.netty.handler.codec.DecoderResult;
import io.netty.util.NetUtil;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.StringUtil;
import java.net.IDN;
public final class DefaultSocks5CommandResponse extends AbstractSocks5Message implements Socks5CommandResponse {
private final Socks5CommandStatus status;
private final Socks5AddressType bndAddrType;
private final String bndAddr;
private final int bndPort;
public DefaultSocks5CommandResponse(Socks5CommandStatus status, Socks5AddressType bndAddrType) {
this(status, bndAddrType, null, 0);
}
public DefaultSocks5CommandResponse(
Socks5CommandStatus status, Socks5AddressType bndAddrType, String bndAddr, int bndPort) {
ObjectUtil.checkNotNull(status, "status");
ObjectUtil.checkNotNull(bndAddrType, "bndAddrType");
if (bndAddr != null) {
if (bndAddrType == Socks5AddressType.IPv4) {
if (!NetUtil.isValidIpV4Address(bndAddr)) {
throw new IllegalArgumentException("bndAddr: " + bndAddr + " (expected: a valid IPv4 address)");
}
} else if (bndAddrType == Socks5AddressType.DOMAIN) {
bndAddr = IDN.toASCII(bndAddr);
if (bndAddr.length() > 255) {
throw new IllegalArgumentException("bndAddr: " + bndAddr + " (expected: less than 256 chars)");
}
} else if (bndAddrType == Socks5AddressType.IPv6) {
if (!NetUtil.isValidIpV6Address(bndAddr)) {
throw new IllegalArgumentException("bndAddr: " + bndAddr + " (expected: a valid IPv6 address)");
}
}
}
if (bndPort < 0 || bndPort > 65535) {
throw new IllegalArgumentException("bndPort: " + bndPort + " (expected: 0~65535)");
}
this.status = status;
this.bndAddrType = bndAddrType;
this.bndAddr = bndAddr;
this.bndPort = bndPort;
}
@Override
public Socks5CommandStatus status() {
return status;
}
@Override
public Socks5AddressType bndAddrType() {
return bndAddrType;
}
@Override
public String bndAddr() {
return bndAddr;
}
@Override
public int bndPort() {
return bndPort;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder(128);
buf.append(StringUtil.simpleClassName(this));
DecoderResult decoderResult = decoderResult();
if (!decoderResult.isSuccess()) {
buf.append("(decoderResult: ");
buf.append(decoderResult);
buf.append(", status: ");
} else {
buf.append("(status: ");
}
buf.append(status());
buf.append(", bndAddrType: ");
buf.append(bndAddrType());
buf.append(", bndAddr: ");
buf.append(bndAddr());
buf.append(", bndPort: ");
buf.append(bndPort());
buf.append(')');
return buf.toString();
}
}
Run 1
The code is generally readable with clear structure and naming, but suffers from some nested validation logic that reduces clarity. The constructor uses a three-level nested if statement for address validation, which could be flattened using early returns or separate validation methods. Intent is mostly clear through descriptive variable names like bndAddrType and bndPort, and each line generally performs a single action. The toString method is verbose with repeated StringBuilder append calls, which could be more concise using string concatenation or a formatted string. The constructor has multiple overloads and the parameter alignment is good, but the validation logic is mixed with assignment, making it harder to follow the flow. Overall, the code follows Java conventions well but lacks the polish of top-tier readable code due to nesting and verbosity in certain sections.
Run 2
The code is generally readable and well-structured. It follows common Java conventions, has clear naming, and separates concerns logically. The constructor validation has moderate nesting (3 levels deep) but remains understandable. Each line performs a single action, and the flow is natural. String validation logic is slightly verbose but clear. Minor issues include some nested conditionals that could be extracted into helper methods, and the toString() method has slightly awkward branching but remains readable. Overall, it's solid production code with good clarity and organization.
Run 3
The code is well-structured and follows clear conventions. The constructor validates inputs logically with shallow nesting (only one level of 'if' inside a type check), and each validation maps to a single concern. Getters are concise and direct, and toString is flat and readable. Minor issues: the address validation block could be extracted into a private helper to reduce constructor length, and a few comments explaining non-obvious validation rules (e.g., IDN conversion) would improve clarity. Overall, the code is highly readable with clear intent and natural flow.
Run 1
Code Structure: Well organized into immutable fields, constructors, accessors, and string formatting. Nesting: Address validation reaches three conditional levels, adding moderate complexity, while other methods remain flat. Clarity of intent: Class and method names clearly convey a SOCKS5 command response; abbreviated field names such as bndAddr require protocol familiarity. Explicit validation messages clarify constraints. Code length: Reasonably concise, though repetitive validation and StringBuilder calls add some verbosity, and excess blank lines near the imports are distracting. Action granularity: Statements generally perform one action per line, making validation and field assignment easy to inspect. Reading flow: Construction proceeds naturally from null checks through address and port validation to assignment, followed by straightforward accessors and formatting.
Run 2
Code Structure: Fields, constructors, accessors, and string formatting are logically grouped. Nesting: Address validation reaches three conditional levels, adding moderate complexity, while other methods remain flat. Clarity of intent: Types, validation checks, and descriptive exception messages make the purpose clear, although abbreviated names such as bndAddr require domain familiarity. Code length: Generally appropriate, with some repetitive validation and verbose string-building statements. Action granularity: Each statement performs one clear action, making execution easy to follow. Reading flow: Construction proceeds naturally from validation to assignment, followed by accessors and formatting. Excess blank lines near the imports and long exception lines slightly reduce visual consistency.
Run 3
Code Structure: Fields, constructors, accessors, and string formatting are logically organized, with validation grouped before assignment. Nesting: Address validation reaches three conditional levels, adding moderate complexity, but remains manageable. Clarity of intent: Types, method names, and descriptive exception messages communicate purpose clearly; abbreviated bnd names require some protocol familiarity. Code length: Mostly concise, though repetitive validation branches and individual string-builder calls add verbosity, while excess blank lines introduce minor clutter. Action granularity: Each statement performs a single clear action, making execution easy to follow. Reading flow: Constructor delegation, validation, initialization, and straightforward accessors create a natural progression; toString is sequential and predictable.