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. It uses an enum cleanly to represent versions, with clear static initialization and simple getter methods. Nesting is minimal (one level in findBySubProtocol and static block loop), and each line generally performs a single action, aiding comprehension. Intent is clear: define STOMP versions with associated protocol strings and provide lookup/attribute key. The code is concise for its purpose, without unnecessary complexity. Minor deductions: the static block could be slightly simplified with streams, and the exception message could be more descriptive, but these are minor. Overall, the code follows logical organization and a natural top-to-bottom reading flow.
Run 3
The code is well-structured and highly readable. The enum pattern is clear, with a clean separation of constants, static initialization, fields, and methods. Nesting is minimal - only one level in the static block and findBySubProtocol method. Intent is obvious: define STOMP protocol versions with associated metadata. The code is concise without being cryptic; each line performs a single logical action. Reading flow is natural, moving from constants to static initialization to instance methods to static lookup. Minor deductions: the static initialization block could be replaced with a stream-based approach for slightly better concision, and the null check in findBySubProtocol adds a slight defensive programming pattern that could be documented. Overall, this is exemplary Java enum code that an average developer could understand immediately.
Run 1
Code Structure: The enum is logically organized into version constants, shared metadata, initialization, fields, constructor, accessors, and lookup. Nesting: Most code is flat; the lookup has three nested control-flow levels, which a null guard could simplify. Clarity of intent: Descriptive names and immutable fields make version-to-subprotocol mapping clear. Code length: Compact and appropriately sized, with little unnecessary code. Action granularity: Statements generally perform one action per line; the chained join conversion remains easy to understand. Reading flow: Consistent formatting and conventional organization support natural reading, though spacing between the package declaration and imports would improve presentation. Overall, highly readable with minor opportunities to simplify the lookup and polish formatting.
Run 2
Code Structure: The enum is logically organized into constants, static initialization, fields, constructor, accessors, and lookup logic. Nesting: Most code is flat, although the lookup method nests a loop and conditional inside a null check. Clarity of intent: Descriptive names and straightforward operations clearly communicate version mapping and subprotocol lookup. Code length: Concise overall, with minor verbosity in list construction and null handling. Action granularity: Each statement performs a single clear action, with no compressed multi-action lines. Reading flow: Consistent formatting and conventional organization make the code easy to follow; the nested lookup slightly interrupts an otherwise natural flow.
Run 3
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 structures; an early null check could simplify it. Clarity of intent: Descriptive names and straightforward operations clearly communicate version-to-subprotocol mapping and lookup behavior. Code length: The implementation is concise, with little unnecessary code. Action granularity: Statements generally perform one action per line, making initialization and lookup easy to follow. Reading flow: Consistent formatting and conventional ordering support natural reading, although the nested lookup and slightly awkward exception wording introduce minor friction.