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 extremely readable. It has a clean, logical package and import structure, with all necessary annotations (Retention, Target, Keep) placed at the end in conventional order. Nesting is essentially nonexistent since this is a marker interface with no methods or logic. The intent is crystal clear: it defines a runtime annotation to mark event subscriber methods. The code is concise, with zero unnecessary lines beyond the standard Javadoc. Each action—package declaration, imports, Javadoc, annotations, declaration—occupies its own logical line or block. Reading flow is natural: package, imports, documentation, metadata, then declaration. The only minor detractor is the Javadoc's slight length relative to the trivial nature of the annotation, but it provides essential contract details (method signature restrictions, serial invocation default) that justify its verbosity. This is exemplary annotation definition style.
Run 3
This code is highly readable. It has a clear logical structure with package, imports, Javadoc, and annotations in conventional order. Nesting is minimal—only the annotation declaration itself. Intent is unambiguous: defining a marker annotation for event subscribers, well-documented with Javadoc explaining usage and constraints. Code length is concise and appropriate for a marker interface. Action granularity is clean, with annotations and declaration on separate lines for clarity. Reading flow is natural, following standard Java conventions. Minor deductions could be made for lack of blank lines between imports, but overall this is exemplary readability.
Run 1
Code Structure: Logically organized into package, imports, documentation, metadata, and declaration; a blank line after the package would improve separation. Nesting: No nested logic, making scanning effortless. 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 compact empty declaration is appropriate. Reading flow: Natural top-to-bottom progression from context and usage rules to annotation configuration and declaration.
Run 2
Code Structure: Logically organized into package declaration, imports, documentation, metadata annotations, and declaration. Nesting: No nested logic; the empty annotation body is immediately understandable. Clarity of intent: Subscribe clearly identifies the purpose, and the Javadoc explains parameter constraints and concurrency behavior. Code length: Concise implementation with appropriately detailed documentation. Action granularity: Each import and metadata annotation occupies its own line; no unrelated operations are combined. Reading flow: Natural top-to-bottom progression, though blank lines after the package declaration and between import groups would improve visual separation.
Run 3
Code Structure: Standard, logical organization of package, imports, documentation, annotations, and declaration. Nesting: No nested logic; the annotation declaration is flat and easy to scan. Clarity of intent: The Subscribe name and Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: Minimal implementation with relevant documentation and no unnecessary code. Action granularity: Each import and annotation occupies its own line; the empty declaration is appropriately concise. Reading flow: Natural top-to-bottom progression from context to usage contract to implementation.