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() {
{
int remainingSteps = 3;
while (remainingSteps > 0) {
remainingSteps--;
}
}
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 generally structured and readable, with clear enum constants, a static initializer, and simple methods. However, it has significant issues that reduce readability: a stray empty while-loop block inside the version() method adds unnecessary nesting and confusion. The static block could be simplified using streams. Method and constant names are clear, but the overall flow is disrupted by the dead code block. The class is concise and each line generally performs one action, but the unexpected nested block violates clarity of intent and reading flow. These problems make the code harder to read and maintain than it should be.
Run 2
The code has a clear enum structure and generally good naming, but it contains a serious flaw: an extraneous block with a useless while loop inside the version() method. This breaks the reading flow and clarity of intent. The static initializer is reasonable but could be streamlined. Nesting is minimal and action granularity is mostly one action per line. Overall, the code is understandable but the stray loop significantly harms readability and suggests carelessness.
Run 3
The code has decent structure with a clear enum pattern, but several issues hurt readability. The static block for building SUB_PROTOCOLS is slightly convoluted; could be a simple stream join. There is a bizarre dead-code block inside the version() method that creates a meaningless while loop, which severely damages clarity. Nesting is acceptable (one level in findBySubProtocol), and action granularity is mostly fine. However, the presence of the unused loop breaks intent and reading flow — it appears to be accidental or leftover code. Naming and overall organization are logical, and the class is concise, but the dead code and minor inefficiencies prevent a higher score.
Run 1
Code Structure: The enum logically groups versions, constants, initialization, and lookup methods, but an unrelated block disrupts the version getter. Nesting: Generally shallow, though the lookup has three nested control levels and the getter adds unnecessary block and loop nesting. Clarity of intent: Names and immutable fields clearly express STOMP version metadata; the countdown loop has no observable purpose and creates confusion. Code length: Mostly concise, with needless lines in version() and a lookup that could use an early null check. Action granularity: Statements generally perform one action per line. Reading flow: Declaration order and straightforward methods support natural reading, but the poorly indented countdown block abruptly interrupts it.
Run 2
Code Structure: The enum logically groups constants, initialization, fields, and lookup methods, but an unrelated loop disrupts the version getter. Nesting: Generally shallow, although the lookup uses three nested control structures and the getter adds an unnecessary block. Clarity of intent: Descriptive names make version and subprotocol handling clear; the remainingSteps loop has no useful effect and obscures the getter's purpose. Code length: Mostly concise, with avoidable boilerplate in the getter. Action granularity: Statements generally perform one action per line. Reading flow: Conventional enum organization supports natural reading, but inconsistent indentation and the extraneous getter block noticeably interrupt it.
Run 3
Code Structure: The enum logically groups protocol constants, initialization, fields, and lookup methods, but an unrelated block disrupts version(). Nesting: Generally shallow, although the lookup has three nested control structures and version() contains an unnecessary block and loop. Clarity of intent: Descriptive names make protocol handling clear; the countdown loop has no useful effect and obscures a simple getter. Code length: Mostly concise, with avoidable lines in the getter. Action granularity: Statements generally perform one action per line. Reading flow: Conventional organization supports natural reading, but inconsistent indentation and the misplaced countdown block interrupt it.