Source code
package io.netty.channel;
import io.netty.util.internal.ThrowableUtil;
import io.netty.util.internal.UnstableApi;
import java.nio.channels.ClosedChannelException;
/**
* Cheap {@link ClosedChannelException} that does not fill in the stacktrace.
*/
@UnstableApi
public final class StacklessClosedChannelException extends ClosedChannelException {
private static final long serialVersionUID = -2214806025529435136L;
private StacklessClosedChannelException() { }
@Override
public Throwable fill() {
// Suppress a warning since this method doesn't need synchronization
return this;
}
/**
* Creates a new {@link StacklessClosedChannelException} which has the origin of the given {@link Class} and method.
*/
public static StacklessClosedChannelException new2(Class<?> cla, String met) {
return ThrowableUtil.unknownStackTrace(new StacklessClosedChannelException(), cla, met);
}
}
Run 1
The code is highly readable with clear structure and intent. It follows standard Java conventions, has a single responsibility (cheap closed channel exception), and maintains flat nesting. The class is concise, well-documented, and each action is on its own line. The only minor issues are the slightly cryptic parameter names 'cla' and 'met', and the somewhat unusual 'new2' method name, which could be clearer. However, the factory method's purpose is documented, and overall the code is easy to understand and maintain.
Run 2
The code is well-structured with clear separation of concerns: imports, class documentation, and methods. Nesting is minimal—only a single class level with a flat method hierarchy. Intent is explicit through comprehensive Javadoc comments explaining the purpose of the class and methods. The code is concise, avoiding unnecessary boilerplate while maintaining clarity. Action granularity is appropriate—each line performs a distinct operation without crowding multiple actions. Reading flow follows a natural progression from class declaration to constructor to methods, with logical grouping of related functionality. The only minor deductions are the abbreviated parameter names ('cla', 'met') in new2() which slightly reduce readability compared to fully descriptive names, and the method name 'new2' could be more descriptive.
Run 3
The code is highly readable with clear structure and intent. It has a single class with a private constructor, overriding a method, and a static factory method. Nesting is minimal, with no deep indentation or complex control flow. The purpose is evident from the class name and Javadoc: a performance-optimized ClosedChannelException that avoids stacktrace generation. The code length is concise and appropriate for its functionality. Action granularity is good, with one logical operation per line. Reading flow is natural, following standard Java conventions: package, imports, Javadoc, class declaration, fields, constructor, method override, and factory method. Minor deductions could be made for the abbreviated parameter names 'cla' and 'met' in the factory method, which slightly reduce clarity compared to fuller names like 'clazz' and 'method'. Overall, this is exemplary code that follows Netty's established patterns for stackless exceptions.
Run 1
Code Structure: The class is logically organized into a constant, constructor, override, and factory method. Nesting: There is no nested control flow, making it easy to scan. Clarity of intent: Documentation explains the stackless exception purpose, but names such as fill, new2, cla, and met obscure meaning. Furthermore, fill does not override a ClosedChannelException method, so the annotation and stated stack-trace suppression behavior are misleading. Code length: The implementation is concise without unnecessary boilerplate. Action granularity: Each statement performs a single action, although the factory return combines construction and stack-trace customization in a manageable expression. Reading flow: The top-to-bottom progression is natural; additional spacing between the package and imports would improve presentation.
Run 2
Code Structure: The class is logically organized into a constant, constructor, override, and factory method. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Documentation explains the stackless exception's purpose, but names such as fill, new2, cla, and met obscure intent; fill also does not match the standard fillInStackTrace override, undermining confidence in the implementation. Code length: The implementation is concise without unnecessary code. Action granularity: Each statement performs one clear action, although the factory return combines construction and stack-trace adjustment. Reading flow: The class reads naturally from declaration to creation, but minimal spacing around the package and imports and weak method names slightly disrupt readability.
Run 3
Code Structure: The class is logically organized into a constant, constructor, override, and factory method. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Documentation clearly describes a lightweight exception, but names such as fill, new2, cla, and met obscure intent. The fill method also does not match the standard fillInStackTrace override, creating confusion about the stated behavior. Code length: The implementation is concise without unnecessary boilerplate. Action granularity: Each statement performs one cohesive action; the factory expression is compact and understandable. Reading flow: Conventional ordering and whitespace support easy scanning, although missing separation between the package declaration and imports slightly reduces polish.