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 fillInStackTrace() {
// 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 newInstance(Class<?> clazz, String method) {
return ThrowableUtil.unknownStackTrace(new StacklessClosedChannelException(), clazz, method);
}
}
Run 1
The code is highly readable. Structure is logical: package, imports, class, field, constructor, override, factory method. Nesting is minimal—only one method override and one static factory, both flat. Intent is clear: a performance-optimized exception that skips stacktrace generation, with Javadoc explaining purpose. Length is concise and appropriate for the functionality. Action granularity is one action per line. Reading flow is natural, moving from class definition to constructor to behavior override to factory method. Minor deductions: the suppressed warning comment could be slightly more specific, and the class could be final (already is). Overall, excellent clarity and simplicity.
Run 2
The code demonstrates excellent readability with a clear, single-purpose class. Structure is logical: imports, class declaration, constructor, override, and factory method are all well-organized. Nesting is minimal (no conditional blocks) and the override method is flat. Intent is explicitly documented via class JavaDoc and inherited exception semantics, plus the 'Stackless' name clearly signals behavior. Code length is concise with no unnecessary methods or fields. Action granularity is one action per line, including the empty constructor and the factory method return. Reading flow is natural, moving from class definition to behavioral override to usage API. Minor deductions: the serialVersionUID adds slight noise, and the factory method could benefit from a more explicit parameter name than 'clazz' (though it is idiomatic). Overall, it is a clean, focused utility class.
Run 3
The code is highly readable. It has a clear, single-purpose class with a logical structure and minimal nesting. The class name and method names explicitly convey intent. The implementation is concise, with each action on a separate line and a natural reading flow. The only minor issue is the slightly misleading comment about suppressing a warning, which could be more specific about why synchronization is unnecessary (no mutable state is initialized).
Run 1
Code Structure: The class is logically organized into a constant, private constructor, override, and factory method. Nesting: There is no nested control flow, making it easy to scan. Clarity of intent: The class name, documentation, and fillInStackTrace override clearly communicate the stackless exception purpose; clazz is slightly generic, and origin assignment relies on understanding unknownStackTrace. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs one focused action, with the factory's inline construction remaining easy to understand. Reading flow: The progression from class purpose to construction and behavior is natural. Minor spacing improvements between the package and imports would improve presentation.
Run 2
Code Structure: The class is logically organized into a constant, private constructor, override, and factory method. Nesting: Methods are flat, with no nested control flow. Clarity of intent: The class name, documentation, and fillInStackTrace override clearly explain the stackless exception behavior; clazz is slightly generic, and the factory's stack-trace adjustment requires familiarity with ThrowableUtil. Code length: The implementation is concise without unnecessary boilerplate. Action granularity: Each statement performs a focused action, although the factory combines construction and stack-trace adjustment in one readable expression. Reading flow: The progression from class purpose to implementation and creation is natural. Minor spacing improvements between the package declaration and imports would enhance presentation.
Run 3
Code Structure: The class is logically organized into a constant, private constructor, overridden method, and factory method. Nesting: There is no nested control flow, making the code easy to scan. Clarity of intent: The class name, documentation, and stack-trace override clearly communicate its purpose; the factory's behavior depends slightly on understanding ThrowableUtil. Code length: The implementation is concise without unnecessary code. Action granularity: Statements generally perform one clear action; the factory combines construction and stack-trace customization in a simple expression. Reading flow: The progression from class definition to behavior and instance creation is natural. Minor formatting improvements, such as separating the package declaration from imports, would improve readability further.