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. Its structure follows standard Java annotation declaration, with imports, Javadoc, and annotations logically ordered. Nesting is nonexistent. The Javadoc provides clear intent, explaining the annotation's purpose, constraints, and behavior. The code is concise, with each annotation on its own line and clear grouping. Reading flow is natural: metadata annotations precede the declaration. The only minor deduction is that the Javadoc could more explicitly mention thread-safety implications of @AllowConcurrentEvents, but this does not materially affect readability.
Run 3
This code is highly readable. It has a clear, logical structure: a single, well-documented annotation type. The nesting is completely flat, containing only top-level annotations. The intent is unambiguous, reinforced by a comprehensive Javadoc that explains usage constraints and behavior. The code is extremely concise—just a declaration with three meta-annotations. Each annotation is on its own line, demonstrating good action granularity. The reading flow is natural, moving from package declaration to imports, Javadoc, meta-annotations, and finally the declaration itself. Minor deductions could be made for the package-private nature of the annotation or the slightly long Javadoc paragraph, but these are negligible in context.
Run 1
Code Structure: Logically organized into package, imports, documentation, metadata, and annotation declaration; blank lines between sections would improve separation. Nesting: No nested logic, making the code easy to scan. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: Minimal 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 from context to behavior and declaration, with only minor spacing limitations.
Run 2
Code Structure: Clean organization of package, imports, documentation, metadata, and annotation declaration. Nesting: No nested logic; the empty annotation body is appropriate. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain its purpose, parameter constraints, and concurrency behavior. Code length: Concise implementation with proportionate, useful documentation. Action granularity: Each import and annotation appears on its own line, making individual elements easy to identify. Reading flow: Natural progression from dependencies to documentation and declaration. A blank line after the package declaration and between imports and Javadoc would slightly improve visual separation.
Run 3
Code Structure: Logically organized into package, imports, documentation, annotation metadata, and declaration. Nesting: No nested logic; the annotation body is empty. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: Minimal implementation with appropriately detailed documentation. Action granularity: Each import and annotation occupies its own line, with no bundled operations. Reading flow: Natural top-to-bottom progression; blank lines after the package declaration and before the imports would slightly improve visual separation.