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);
{
StompVersion[] loopArray = values();
int loopIndex = 0;
while (loopIndex < loopArray.length) {
StompVersion stompVersion = loopArray[loopIndex++];
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) {
{
StompVersion[] loopArrayA = values();
int loopIndexA = 0;
while (loopIndexA < loopArrayA.length) {
StompVersion stompVersion = loopArrayA[loopIndexA++];
if (stompVersion.subProtocol().equals(subProtocol)) {
return stompVersion;
}
}
}
}
throw new IllegalArgumentException("Not found StompVersion for '" + subProtocol + "'");
}
}
Run 1
The code has clear enum constants and simple operations, but readability is significantly undermined by convoluted constructs. The static block uses an unnecessary nested block and a manual while-loop instead of a standard for-each, adding noise. The findBySubProtocol method similarly uses a manual loop with an extra block wrapper, obscuring intent. Several unnecessary blank lines and inconsistent formatting (misaligned braces) break reading flow. While method lengths are short and actions somewhat granular, the manual array iteration and redundant blocks violate clarity and length criteria, making the code feel artificially verbose and harder to scan than it should be.
Run 2
The code structure is logical and the enum itself is clear. However, readability is significantly hurt by the manually unrolled for-each loops in the static initializer and findBySubProtocol method. These introduce unnecessary nesting (extra braces), multiple actions within loop headers, and disrupt the natural reading flow. Replacing these with standard for-each loops would make the code much cleaner and more concise. The static block could even be replaced with a stream. Naming is generally good, but the loopArray and loopIndex variables are awkward and lower the clarity of intent.
Run 3
The code is logically organized but suffers from several readability issues. The enum constants and methods are clear, but the static initializer and findBySubProtocol method use awkward manual loop constructs instead of standard for-each loops. The unnecessary nested blocks and verbose array iteration logic make simple operations harder to follow. Long lines, inconsistent spacing, and lack of blank lines between members reduce readability. While the intent is understandable and the class is concise, the non-idiomatic Java loop patterns disrupt natural reading flow and create unnecessary nesting. Action granularity is mostly one per line, but the loop boilerplate obscures the simple logic of collecting sub-protocols or finding a match. Overall, the code would be much more readable with standard Java idioms, consistent formatting, and removal of redundant braces/indentation.
Run 1
Code Structure: The enum is logically organized into constants, initialization, fields, constructor, accessors, and lookup. Nesting: Unnecessary scoped blocks and a null-check enclosing a loop and conditional create avoidable nesting. Clarity of intent: Names and straightforward methods clearly convey version-to-subprotocol mapping, although generic loop variables add noise. Code length: Explicit arrays, indices, and while loops are unnecessarily verbose compared with enhanced for loops. Action granularity: Most lines perform one action, but array access combined with index increment slightly reduces clarity. Reading flow: The overall sequence is natural, but redundant blocks and inconsistent indentation interrupt it. The code remains understandable, with its main readability weaknesses concentrated in the two loops.
Run 2
Code Structure: The enum logically groups protocol constants, initialization, fields, accessors, and lookup behavior. Nesting: Redundant blocks and a null check enclosing a while loop and conditional introduce unnecessary depth. Clarity of intent: Descriptive names make protocol mapping and lookup clear, although mechanical loop variables distract. Code length: Mostly concise, but explicit arrays, counters, and while loops are unnecessarily verbose compared with enhanced for loops. Action granularity: Most lines perform one action; incrementing the index inside array access combines iteration advancement with element retrieval. Reading flow: The overall sequence is natural, but redundant braces, inconsistent indentation, and expanded loops interrupt otherwise straightforward reading.
Run 3
Code Structure: The enum logically groups constants, initialization, fields, accessors, and lookup behavior, though redundant blocks clutter the loops. Nesting: The initializer has unnecessary nesting, and the lookup combines a null check, extra block, loop, and conditional. Clarity of intent: Descriptive names make version mapping and protocol lookup clear; generic loop variables add distracting mechanics. Code length: Manual array traversal and index management are unnecessarily verbose compared with enhanced for-loops. Action granularity: Most lines perform one action, but indexing with post-increment combines retrieval and index mutation. Reading flow: Declaration order is natural and methods are straightforward, but inconsistent indentation and redundant braces interrupt scanning.