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
This code is exceptionally readable. The structure is logical: package declaration, imports, Javadoc, annotations, and interface declaration follow standard Java conventions. Nesting is nonexistent since it's an annotation definition. Intent is crystal clear — it defines a marker annotation for event subscriber methods, thoroughly documented with semantic constraints and usage notes. Length is concise with no redundancy; the ample Javadoc is appropriate for a public API contract. Each annotation is on its own line, maintaining action granularity. Reading flow is natural: you first understand what the annotation does, then see its retention, target, and preservation policies. Minor deductions only because there is no opportunity to demonstrate complex structural organization, but for what it is, it is exemplary.
Run 3
The code is highly readable. It has a clear, logical structure: package declaration, imports, Javadoc, annotations, and interface definition. Nesting is minimal—essentially flat. The intent is explicit through comprehensive Javadoc that explains usage, constraints, and behavior. Code length is concise and appropriate for an annotation type. Each annotation is on its own line, maintaining clear action granularity. Reading flow is natural, progressing from metadata to documentation to the declaration. Minor deductions: missing blank lines between import groups and lack of an empty line before the interface declaration could slightly improve visual separation.
Run 1
Code Structure: The package, imports, documentation, annotations, and declaration follow a logical Java layout. Nesting: There is no nested logic, making the code easy to scan. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: The implementation is minimal, while the documentation adds useful context without unnecessary detail. Action granularity: Each import and annotation occupies its own line; the empty declaration is appropriately compact. Reading flow: The code progresses naturally from context to documentation to metadata and declaration. A blank line after the package declaration and before the Javadoc would slightly improve visual separation.
Run 2
Code Structure: Logically ordered package, imports, documentation, metadata annotations, and declaration. Nesting: No nested logic, making the code easy to scan. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter restrictions, and concurrency behavior. Code length: Concise implementation with proportionate documentation. Action granularity: Each import and metadata annotation occupies its own line; the empty declaration is appropriately compact. Reading flow: Natural top-to-bottom progression, though a blank line between the package declaration and imports would improve visual separation.
Run 3
Code Structure: Clearly organized into package, imports, documentation, metadata, and annotation declaration. Nesting: No nested logic, making it easy to scan. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain its purpose, parameter constraints, and concurrency behavior. Code length: Minimal implementation with proportionate, useful documentation. Action granularity: Each import and annotation occupies its own line; the empty declaration is appropriately compact. Reading flow: Natural top-to-bottom progression, with only a minor formatting weakness: no blank line separates the package declaration from the imports.