Source code
package io.netty.example.stomp.websocket;
import io.netty.util.AttributeKey;
import io.netty.util.internal.StringUtil;
import java.util.ArrayList;
import java.util.List;
public enum StompVersion {
STOMP_V11("1.1", "v11.stomp"),
STOMP_V12("1.2", "v12.stomp");
public static final AttributeKey<StompVersion> CHANNEL_ATTRIBUTE_KEY = AttributeKey.valueOf("stomp_version");
public static final String SUB_PROTOCOLS;
static {
List<String> subProtocols = new ArrayList<String>(values().length);
for (StompVersion stompVersion : values()) {
subProtocols.add(stompVersion.subProtocol);
}
SUB_PROTOCOLS = StringUtil.join(",", subProtocols).toString();
}
private final String version;
private final String subProtocol;
StompVersion(String version, String subProtocol) {
this.version = version;
this.subProtocol = subProtocol;
}
public String version() {
return version;
}
public String subProtocol() {
return subProtocol;
}
public static StompVersion findBySubProtocol(String subProtocol) {
if (subProtocol != null) {
for (StompVersion stompVersion : values()) {
if (stompVersion.subProtocol().equals(subProtocol)) {
return stompVersion;
}
}
}
throw new IllegalArgumentException("Not found StompVersion for '" + subProtocol + "'");
}
}
Run 1
The code is well-structured, with a logical enum layout: constants first, then static fields, constructor, accessor methods, and a lookup method. Nesting is minimal, with only a single loop inside the static initializer and lookup method. Intent is clear: each enum constant maps a STOMP version to its subprotocol, and the static block builds a comma-separated list for registration. Code length is appropriate for the functionality, and actions are granular, one per line. Reading flow is natural and easy to follow. Minor deductions: the static initializer could be more concise with streams, and error handling in findBySubProtocol is slightly abrupt, but overall readability is excellent.
Run 2
The code is well-structured and readable. The enum is logically organized with clear constants, a static block for initialization, and clean methods. Nesting is minimal, with only one level in the loop and conditional checks. Intent is clear, especially with descriptive names like `findBySubProtocol` and `CHANNEL_ATTRIBUTE_KEY`. Code length is appropriate for the functionality, avoiding unnecessary verbosity. Each line generally performs a single action, and the reading flow is natural, moving from constants to initialization to methods. The static block could be slightly simplified with streams, but the current approach is acceptable and easy to follow. Overall, it’s concise and maintainable.
Run 3
The code is highly readable with clear structure and intent. The enum is well-organized with constants, static initialization, fields, and methods separated logically. Nesting is minimal—only a single-level if and for in findBySubProtocol. Intent is clear: represent STOMP versions, expose their subprotocols, and provide lookup. Code length is appropriate; no unnecessary lines. Action granularity is good—most lines perform one action, though the throw statement is slightly long but acceptable. Reading flow is natural: constants first, then initialization, then fields, constructors, accessors, and utility method. Minor improvements could include a more concise subprotocol list initialization using streams, but overall clarity and maintainability are excellent.
Run 1
Code Structure: The enum is logically organized into constants, static initialization, fields, constructor, accessors, and lookup. Nesting: Most code is flat, although findBySubProtocol has three nested control-flow levels; an early null check could simplify it. Clarity of intent: Descriptive names and immutable fields make version mapping and subprotocol lookup clear. Code length: Compact and proportionate to its functionality, with little unnecessary code. Action granularity: Each statement performs one clear action, and assignments and returns occupy separate lines. Reading flow: Consistent formatting and conventional ordering make the code easy to follow. Minor drawbacks include limited spacing around imports and a slightly awkward exception message.
Run 2
Code Structure: The enum logically groups protocol constants, shared attributes, initialization, instance fields, accessors, and lookup behavior. Nesting: Most code is flat, though the lookup uses three nested control structures; an early null check could reduce nesting. Clarity of intent: Descriptive names and straightforward methods clearly communicate version-to-subprotocol mapping and lookup. Code length: Compact and appropriately sized, with little unnecessary code. Action granularity: Each statement performs one clear action, and initialization steps are separated cleanly. Reading flow: Conventional organization and consistent formatting make the code easy to follow, although the static initializer preceding instance fields slightly interrupts the progression from data definitions to behavior.
Run 3
Code Structure: The enum is logically organized into constants, static initialization, fields, constructor, accessors, and lookup. Nesting: Most code is flat, although the lookup uses three nested control structures; an early null check could reduce nesting. Clarity of intent: Descriptive names and straightforward operations clearly communicate version-to-subprotocol mapping. Code length: Compact and proportionate to its functionality, with little unnecessary code. Action granularity: Each statement performs a single clear action, without compressed multi-action lines. Reading flow: Consistent formatting and conventional ordering support natural reading. Minor drawbacks include the missing blank line between the package and imports and the slightly awkward exception message.