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 highly readable. The enum constants are clearly named, and fields are logically separated with appropriate access modifiers. Nesting is minimal—only one level in the static initializer and lookup method, which is easy to follow. Intent is explicit: the enum represents STOMP protocol versions, and each method has a clear purpose. Code length is concise without unnecessary duplication; helper methods like version(), subProtocol(), and findBySubProtocol() are straightforward. Action granularity is good, with each line performing a single logical operation. Reading flow is natural, moving from constants to static initialization, fields, constructor, accessors, and finally the utility lookup. Minor improvements could include formatting the static block with streams or simplifying the null check, but overall clarity is excellent.
Run 3
The code is well-structured and readable. The enum clearly groups constants and related utilities. Nesting is minimal (one level in the static initializer and findBySubProtocol). Intent is explicit: enum constants represent STOMP versions, and methods are self-explanatory. Code length is appropriate—no excessive verbosity. Each line performs a single action, and the reading flow from enum constants to static block to instance methods to lookup logic is natural. Minor deductions: the static block could be slightly simpler using streams, and findBySubProtocol throws a generic exception with string concatenation, but both are conventional. Overall, highly readable with clear naming and logical organization.
Run 1
Code Structure: The enum is logically organized into constants, static initialization, fields, constructor, accessors, and lookup method. Nesting: Most code is flat, though findBySubProtocol has three nested control levels that could be reduced with an early null check. Clarity of intent: Descriptive names and immutable fields clearly communicate version metadata and subprotocol lookup; the exception wording is slightly awkward. Code length: Compact and appropriately scoped, with little unnecessary code. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: The declaration-to-behavior progression is natural, and consistent formatting supports scanning; spacing between the package declaration and imports would slightly improve readability.
Run 2
Code Structure: The enum logically groups supported versions, shared constants, initialization, fields, accessors, and lookup behavior. Nesting: Most code is flat, though findBySubProtocol has three nested control structures that could be simplified with an early null check. Clarity of intent: Descriptive names and straightforward operations clearly express version-to-subprotocol mapping and lookup. Code length: Compact and appropriate, with little unnecessary code. Action granularity: Each statement performs a single clear action. Reading flow: Conventional organization and consistent formatting make the code easy to follow; the static initialization appearing before instance fields slightly interrupts the flow.
Run 3
Code Structure: The enum logically groups protocol constants, initialization, fields, constructor, accessors, and lookup behavior. Nesting: Most code is flat, though findBySubProtocol nests a loop and condition inside a null check; a guard clause could reduce indentation. Clarity of intent: Descriptive names and straightforward operations make version mapping and lookup easy to understand. Code length: Compact and appropriately sized, with little unnecessary code. Action granularity: Statements generally perform one action per line, supporting easy scanning. Reading flow: Conventional ordering and consistent formatting provide a natural progression, although spacing between the package declaration and imports would improve presentation.