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: package declaration, imports, Javadoc, annotations, and interface declaration. Nesting is non-existent. Intent is unambiguous—defining a marker annotation for event subscription. Length is concise and appropriate, with no unnecessary code. Action granularity is one concept per line, especially in the annotation section. Reading flow is natural, aided by informative Javadoc and standard Java conventions. Minor deduction for slightly dense Javadoc but overall excellent.
Run 3
The code is a simple annotation definition with clear structure and intent. It uses standard Java annotations (@Retention, @Target, @Keep) in a logical order. The Javadoc is concise but informative, explaining usage constraints and behavior. Nesting is nonexistent; the file is exceptionally flat. Each annotation and declaration sits on its own line, improving readability. The reading flow is natural: package, imports, documentation, metadata, then the declaration. Length is minimal and appropriate. The only minor deduction is that the Javadoc could be slightly more explicit about the 'primitive parameter' restriction, but overall this is highly readable, idiomatic Java code.
Run 1
Code Structure: The package, imports, documentation, annotations, and declaration are logically ordered. Nesting: There is no nested logic, making the code easy to scan. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain its purpose, parameter restrictions, 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. A blank line after the package declaration would slightly improve visual separation.
Run 2
Code Structure: Package, imports, documentation, annotations, and declaration follow a logical Java layout. Nesting: No nested logic or unnecessary complexity. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: Minimal implementation with relevant documentation rather than redundant code. 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 documentation, metadata, and declaration.
Run 3
Code Structure: Logically organized into package declaration, imports, documentation, and annotation definition. Nesting: No nested logic, making the code easy to scan. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain its purpose, parameter constraints, and concurrency behavior. Code length: Concise implementation with appropriately sized documentation. Action granularity: Each import and annotation occupies its own line; the empty declaration is suitably compact. Reading flow: Natural top-to-bottom progression, although blank lines after the package declaration and between import groups would improve visual separation.