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 follows a logical structure: package declaration, imports, Javadoc, then annotations and interface declaration. Nesting is minimal—there is no nesting. The intent is clear: this defines a marker annotation for event subscriber methods. The Javadoc effectively explains usage constraints and behavior. Code length is concise, with no unnecessary lines. Each annotation is on its own line, demonstrating good action granularity. Reading flow is natural, progressing from imports to documentation to declaration. Minor deductions: the Javadoc paragraph is somewhat long, and the @Keep annotation is unexplained, but these are negligible.
Run 3
This code is highly readable. The structure is exemplary: package declaration, imports, and annotation definition are logically organized, with all metadata placed conventionally. There is no nesting or complex logic. The intent is immediately clear due to the comprehensive Javadoc, which explains what the annotation does, its constraints, and its interaction with other annotations. The code is concise, containing only the essential annotation declarations without unnecessary elements. Each annotation (@Retention, @Target, @Keep) is on its own line, following a clean one-action-per-line style. The reading flow is natural, moving from package context through imports to documentation and finally the annotation definition, making it effortless to understand the purpose and usage. This is a model of clean, well-documented Java code.
Run 1
Code Structure: The package, imports, documentation, metadata annotations, and declaration are logically organized. Nesting: There is no nested logic; the empty annotation body is immediately understandable. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter constraints, and concurrency behavior. Code length: The implementation is minimal, while the documentation provides useful context without unnecessary detail. Action granularity: Each import and metadata annotation occupies its own line, with no bundled operations. Reading flow: The code progresses naturally from dependencies to explanation to declaration. Blank lines after the package declaration and between import groups would slightly improve visual separation.
Run 2
Code Structure: Logically organized into package, imports, documentation, metadata annotations, and declaration. 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 useful documentation rather than unnecessary verbosity. 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 blank lines between the package, imports, and documentation would improve visual separation.
Run 3
Code Structure: Logically organized into package, imports, documentation, annotations, and declaration. Nesting: No nested logic; the annotation interface is empty. Clarity of intent: The Subscribe name and 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 compact empty declaration remains easy to read. Reading flow: Natural top-to-bottom progression, though blank lines between the package and imports and between import groups would slightly improve visual separation.