Source code
package io.netty.resolver.dns;
import io.netty.channel.AddressedEnvelope;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.handler.codec.dns.DefaultDnsQuery;
import io.netty.handler.codec.dns.DnsQuery;
import io.netty.handler.codec.dns.DnsQuestion;
import io.netty.handler.codec.dns.DnsRecord;
import io.netty.handler.codec.dns.DnsResponse;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.Promise;
import java.net.InetSocketAddress;
final class TcpDnsQueryContext extends DnsQueryContext {
TcpDnsQueryContext(Channel channel,
InetSocketAddress nameServerAddr,
DnsQueryContextManager queryContextManager,
DnsQueryLifecycleObserver lifecycleObserver,
int maxPayLoadSize, boolean recursionDesired,
long queryTimeoutMillis,
DnsQuestion question, DnsRecord[] additionals,
Promise<AddressedEnvelope<DnsResponse, InetSocketAddress>> promise) {
super(channel, nameServerAddr, queryContextManager, lifecycleObserver, maxPayLoadSize, recursionDesired,
// No retry via TCP.
queryTimeoutMillis, question, additionals, promise, null, false);
}
@Override
protected DnsQuery newQuery(int id, InetSocketAddress nameServerAddr) {
return new DefaultDnsQuery(id);
}
@Override
protected String protocol() {
return "TCP";
}
}
Run 1
The code is well-structured and readable. It has a clear class hierarchy with a single inheritance from DnsQueryContext. The constructor is straightforward, with parameters clearly named and a concise super() call that uses a helpful comment to explain the null and false arguments. Methods are short and focused, each performing a single action. There is minimal nesting, with no conditional logic or loops. The code is concise and follows standard Java conventions. Minor deductions: the long constructor parameter list could be wrapped differently, and the 'protocol()' method is trivially simple. Overall, this code is easy to understand and maintain.
Run 2
The code is highly readable. It has a clear, logical structure with a single-purpose class extending a parent context. Imports are organized, and the constructor delegates cleanly to the superclass with a clarifying comment. Nesting is minimal, and action granularity is appropriate—each statement performs one clear action. The methods are concise and focused, with obvious intent (e.g., protocol() returns 'TCP'). The reading flow is natural: package, imports, class declaration, constructor, then overridden methods in logical order. Only minor deductions could be made for the long parameter list in the constructor, which slightly impacts readability, but overall this is exemplary code.
Run 3
The code is highly readable with a clear, focused purpose. It follows a logical structure with a single class extending a base context, minimal nesting, and concise method implementations. Each line performs a distinct action, and the constructor simply delegates to the superclass with a clear comment explaining the 'no retry' decision. Method names and return values are self-documenting, and the overall flow is natural and easy to follow. The only minor deductions are the slightly long constructor parameter list and a comment that could be more explicit about why retries are disabled for TCP, but these do not significantly impact readability.
Run 1
Code Structure: A focused class with a constructor and two small overrides is logically organized. Nesting: No nested control flow, making the code easy to scan. Clarity of intent: Class and method names clearly identify TCP DNS behavior, and the comment explains the lack of TCP retry. However, the long superclass argument list and trailing null and false require knowledge of the parent constructor. Code length: Concise overall, though unused ChannelFuture and Future imports add clutter. Action granularity: Each statement performs one action; wrapped constructor arguments remain understandable. Reading flow: The constructor followed by query creation and protocol identification is natural, with consistent indentation. The dense constructor signature slightly interrupts readability.
Run 2
Code Structure: The class is logically organized into a constructor and two focused overrides. Nesting: There is no nested control flow, making it easy to scan. Clarity of intent: Class and method names clearly identify a TCP DNS query context, and the comment explains the absence of TCP retries. However, the long superclass argument list, including null and false, requires knowledge of the parent constructor. Code length: The implementation is concise with no unnecessary logic, though ChannelFuture and Future imports are unused. Action granularity: Each method performs a single action, and statements are cleanly separated. Reading flow: The constructor followed by query creation and protocol identification provides a natural progression; dense parameter lists and inconsistent grouping of constructor parameters slightly reduce readability.
Run 3
Code Structure: The class is logically organized into a constructor and two small overrides. Nesting: There is no nested control flow, making it easy to scan. Clarity of intent: Descriptive class and method names clearly identify a TCP DNS query context; the comment explains the lack of TCP retry. However, the long superclass argument list, especially null and false, requires knowledge of the parent constructor. Code length: The implementation is concise with little unnecessary code, though two imports are unused. Action granularity: Each statement performs a single action; wrapping the constructor call improves readability. Reading flow: The constructor-to-overrides sequence is natural, but the lengthy parameter list and limited spacing around imports slightly interrupt scanning.