Source code
package com.google.common.eventbus;
import com.google.errorprone.annotations.Keep;
import java.lang.annotation.ElementType; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;
/**
* Marks a method as an event subscriber.
*
* <p>The type of event will be indicated by the method's first (and only) parameter, which cannot
* be primitive. If this annotation is applied to methods with zero parameters, or more than one
* parameter, the object containing the method will not be able to register for event delivery from
* the {@link EventBus}.
*
* <p>Unless also annotated with @{@link AllowConcurrentEvents}, event subscriber methods will be
* invoked serially by each event bus that they are registered with.
*
* @author Cliff Biffle
* @since 10.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD) @Keep public @interface Subscribe {}
Run 1
The code is well-structured and highly readable. The Javadoc is clear and describes the annotation's purpose, constraints, and behavior effectively. The annotation declarations are concise and mostly organized, though the placement of multiple annotations on a single line slightly reduces readability. The class length is minimal, and intent is unambiguous. Overall, this is a clean, idiomatic Java annotation definition.
Run 2
The code is highly readable with clear structure and intent. The Javadoc is comprehensive and explains usage constraints well. Annotations are logically grouped, though @Keep shares a line with @Target, slightly reducing granularity. Imports are compressed onto fewer lines, which is concise but slightly unconventional. Overall, the single-purpose annotation is straightforward and easy to understand.
Run 3
The code is highly readable. It has a clear and logical structure, with imports appropriately placed and class-level annotations neatly arranged. Nesting is nonexistent, as this is a simple annotation definition. The intent is explicitly documented through comprehensive Javadoc, making the purpose of the @Subscribe annotation unambiguous. Code length is minimal and appropriate for an annotation type. Action granularity is excellent—each annotation and declaration is on its own line, with only import statements slightly condensed. Reading flow is natural: package declaration, imports, documentation, then annotations and declaration. The only minor readability issue is the multiple imports on a single line and the slightly cramped annotation grouping, but these are common Java style variations and don't significantly impact clarity.
Run 1
Code Structure: logically organized into package, imports, documentation, and annotation declaration, though spacing between sections would help. Nesting: entirely flat, with no complexity. Clarity of intent: the Subscribe name, metadata, and thorough Javadoc clearly explain its purpose and usage constraints. Code length: concise implementation with useful rather than redundant documentation. Action granularity: multiple imports share lines, and @Target, @Keep, and the declaration are compressed onto one line, reducing scanability. Reading flow: generally natural and conventional, but separating imports and annotations onto individual lines would improve readability.
Run 2
Code Structure: Logically organized as a package declaration, imports, documentation, and annotation definition, although compressed formatting weakens separation. Nesting: No nested logic; the empty annotation body is easy to understand. Clarity of intent: The Subscribe name, metadata annotations, and detailed Javadoc clearly explain its purpose and usage constraints. Code length: Concise, with documentation that adds useful context rather than unnecessary verbosity. Action granularity: Multiple imports share lines, and @Target, @Keep, and the declaration are combined on one line, reducing scanability. Reading flow: The overall order is natural, but separate import lines, spacing between sections, and one annotation per line would make reading smoother.
Run 3
Code Structure: Logically organized into package, imports, documentation, and annotation declaration. Nesting: No nested logic, making the code easy to scan. Clarity of intent: The Subscribe name, metadata, and detailed Javadoc clearly explain its purpose and usage constraints. Code length: Concise implementation with appropriately informative documentation. Action granularity: Multiple imports share lines, and @Target, @Keep, and the declaration are compressed onto one line, reducing visual separation. Reading flow: Generally natural, but missing spacing between sections and crowded declarations interrupt scanning. Separate imports and annotation lines would improve readability.