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 due to its clear structure and concise nature. It defines a single-purpose annotation with well-organized imports and Javadoc. The logic is flat with no nesting, and the intent is explicitly documented. However, the Javadoc is slightly verbose, which slightly impacts conciseness.
Run 3
This code is exceptionally readable. Structure is logical: package, imports, Javadoc, annotations, declaration. Nesting is non-existent. Intent is crystal clear—it defines a simple marker annotation. Length is concise; no unnecessary code. Action granularity is perfect: each annotation is on its own line. Reading flow is natural, with Javadoc providing excellent context and examples. Only minor deduction: the Javadoc could be slightly more concise, but it is informative and appropriate for a public API.
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 detailed Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: The implementation is minimal; the documentation is longer but provides useful context. Action granularity: Each import and annotation occupies its own line, with no combined operations. Reading flow: The code progresses naturally from dependencies to explanation to declaration. A blank line after the package declaration and before the imports would slightly improve visual separation.
Run 2
Code Structure: Logically 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 Javadoc clearly explain subscriber requirements and concurrency behavior; retention and target are explicit. Code length: Minimal implementation with useful, proportionate documentation. Action granularity: Each import and annotation occupies its own line, with no combined operations. Reading flow: Natural top-to-bottom progression; blank lines after the package and before the documentation would slightly improve visual separation.
Run 3
Code Structure: Cleanly organized into package declaration, imports, documentation, metadata annotations, and declaration. Nesting: 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: Minimal implementation with appropriately detailed documentation. Action granularity: Each import and metadata annotation occupies its own line; there are no combined operations. Reading flow: Natural top-to-bottom progression, although blank lines separating the package declaration and imports would slightly improve visual readability.