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 highly readable. It has a clear, logical structure with imports at the top, followed by a comprehensive Javadoc explaining the annotation's purpose and constraints. The annotation definition is minimal and focused. Nesting is flat, with no unnecessary complexity. Clarity of intent is excellent, with clear documentation about parameter requirements and serial invocation behavior. The code is concise, containing no redundant elements. Action granularity is appropriate, with each annotation on its own line. Reading flow is natural, from imports to documentation to implementation. Minor deductions only for unused imports (Target, RetentionPolicy are used indirectly but ElementType is fully qualified).
Run 2
The code is highly readable due to its clear structure, flat hierarchy, and concise single-purpose declaration. The package and import statements are minimal and logically ordered. Javadoc comments clearly explain the annotation's purpose, constraints, and behavior, enhancing clarity of intent. The annotation definition itself is compact, with each meta-annotation on its own line, contributing to excellent action granularity and reading flow. There is no unnecessary nesting or overly long code. The only minor deduction is that the Javadoc could be slightly more concise, but this does not meaningfully impact readability. Overall, the code is nearly ideal for its purpose.
Run 3
The code is exceptionally readable. The package declaration and imports are minimal and clearly organized. The Javadoc provides thorough, well-structured documentation of the annotation's purpose, constraints, and behavior, with appropriate use of HTML tags and cross-references. Annotations are logically grouped — retention, target, and keep — each on its own line. The interface declaration is concise and unambiguous. The code exhibits flat nesting, strong clarity of intent, appropriate length for an annotation definition, and natural reading flow. Only minor improvement could be separating imports with a blank line, but this is negligible. Overall, this is an exemplary model of clean, well-documented Java code.
Run 1
Code Structure: Logically organized into package, imports, documentation, annotations, and declaration; blank lines between sections would improve separation. Nesting: No nested logic, making it easy to scan. Clarity of intent: The Subscribe name, descriptive Javadoc, and explicit retention and target annotations clearly explain its purpose and usage constraints. Code length: Minimal implementation with relevant documentation rather than unnecessary code. Action granularity: Each import and annotation occupies its own line; the compact empty declaration is appropriate. Reading flow: Natural top-to-bottom progression from context to contract to declaration.
Run 2
Code Structure: Clean, conventional organization with package, imports, documentation, annotations, and declaration. Nesting: No nested logic, making the code immediately accessible. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter constraints, and concurrency behavior. Code length: Minimal implementation with appropriately detailed documentation. Action granularity: Each import and annotation occupies its own line; the empty declaration is suitably compact. Reading flow: Natural top-to-bottom progression, though blank lines between the package, imports, and documentation would improve visual separation.
Run 3
Code Structure: Clearly organized into package, imports, documentation, metadata annotations, and declaration. Nesting: No nested logic or unnecessary blocks. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: Minimal implementation with useful, proportionate documentation. Action granularity: Each import and metadata annotation occupies its own line; the empty declaration is appropriately compact. Reading flow: Follows standard Java conventions, progressing naturally from context to behavior and declaration.