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. It has a clear, logical structure with a single annotation declaration preceded by comprehensive Javadoc. Nesting is minimal and appropriate. Intent is unambiguous: defining a marker annotation for event subscriber methods. Code length is concise yet includes essential documentation and metadata. Action granularity is appropriate, with one annotation per line. Reading flow is natural, from package declaration through imports, Javadoc, annotations, and finally the interface declaration.
Run 3
This code is highly readable. The structure is logical: package declaration, imports, Javadoc, and annotations are cleanly organized. Nesting is nonexistent, as this is a simple annotation definition. The Javadoc clearly explains the intent, constraints, and behavior of the annotation. Code length is minimal and appropriate for its purpose. Each annotation is on its own line, maintaining clear action granularity. The reading flow is natural — documentation first, then metadata, then the declaration. A near-perfect example of concise, well-documented code.
Run 1
Code Structure: Package, imports, documentation, and annotation declaration are logically ordered. Nesting: The declaration is flat, with no nested logic. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter constraints, and concurrency behavior. Code length: The implementation is minimal, and the documentation adds useful context rather than unnecessary verbosity. Action granularity: Each import and annotation occupies its own line; the empty declaration is appropriately compact. Reading flow: The code progresses naturally from dependencies to explanation to declaration. Missing blank lines between the package, imports, and Javadoc slightly reduce visual separation.
Run 2
Code Structure: Standard Java organization cleanly separates the package, imports, documentation, metadata, and declaration. Nesting: No nested logic or control flow. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain the annotation's purpose, parameter constraints, and concurrency behavior. Code length: The implementation is minimal, with documentation providing useful context rather than unnecessary verbosity. Action granularity: Each import and annotation occupies its own line, and the empty declaration is appropriately compact. Reading flow: The code progresses naturally from dependencies to explanation to annotation definition.
Run 3
Code Structure: Clearly organized into package declaration, imports, documentation, annotations, and declaration. Nesting: No nested logic; the empty annotation body is 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 useful documentation rather than unnecessary code. Action granularity: Each import and annotation appears on its own line. Reading flow: Natural top-to-bottom progression, though blank lines after the package declaration and imports would improve visual separation.