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. The structure is logical: package declaration, imports, Javadoc, then annotations. It is completely flat with no nesting. The intent is immediately clear — it defines a marker annotation for event subscribers. The Javadoc is concise yet thorough, explaining usage constraints and behavior. Action granularity is excellent, with one annotation or declaration per line. Reading flow is natural, moving from high-level purpose (Javadoc) to implementation details. Only minor nitpick: no blank line between imports and Javadoc, but this is negligible.
Run 3
The code is exceptionally readable. Structure is logical: package, imports, Javadoc, then annotations and interface declaration. Nesting is minimal—there is no nesting at all beyond the annotation definition. Intent is very clear: the Javadoc thoroughly explains the purpose, constraints, and behavior of the @Subscribe annotation. Length is concise and appropriate for a marker annotation. Action granularity is excellent—each annotation (Retention, Target, Keep) is on its own line, making it easy to scan. Reading flow is natural: documentation precedes the declaration, and annotations are grouped logically. Minor deductions could be made for lack of blank lines between imports and Javadoc, but overall this is near-ideal Java code for a simple annotation type.
Run 1
Code Structure: Clean organization into package, imports, documentation, annotations, and declaration; a blank line after the package would improve separation. Nesting: No nested logic, making the code easy to scan. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: The implementation is minimal, and the documentation provides useful context without unnecessary verbosity. Action granularity: Each import and annotation occupies its own line; the empty annotation declaration is appropriately compact. Reading flow: The code progresses naturally from dependencies to explanation, metadata, and declaration.
Run 2
Code Structure: Logically organized into package, imports, documentation, metadata, and annotation declaration. Nesting: No nested logic, making the code immediately accessible. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter constraints, and concurrency behavior. Code length: Minimal implementation with useful, proportionate documentation. Action granularity: Each import and annotation occupies its own line; the empty declaration is appropriately compact. Reading flow: Natural top-to-bottom progression from context to contract to declaration.
Run 3
Code Structure: Logically organized into package, imports, documentation, annotations, and declaration; blank lines between sections would improve separation. Nesting: No nested logic, making it 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 useful documentation rather than unnecessary code. Action granularity: Each import and annotation occupies its own line; the empty declaration is appropriately compact. Reading flow: Follows conventional Java ordering, naturally progressing from context and documentation to metadata and declaration.