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 well-structured with clear logical organization: standard imports, comprehensive Javadoc, then annotations. Nesting is absent as appropriate. The intent of the annotation is explicitly documented with clear constraints and usage guidelines. Code length is concise—only necessary elements are present. Each annotation occupies its own line, maintaining one action per line. The reading flow progresses naturally from purpose to usage to implementation. The only minor deductions are for a slightly long Javadoc paragraph and the package-private scope, but these are justified by the annotation's importance.
Run 3
The code is highly readable. It has a logical structure with clear package and import declarations. The annotation definition is concise and follows a single, clear purpose. The Javadoc provides meaningful context about usage, constraints, and behavior, enhancing clarity of intent. There is no unnecessary nesting or complexity, and the annotation itself is defined in one line. Action granularity is appropriate, with each annotation attribute on its own line and the interface declaration separate. Reading flow is natural, moving from imports to documentation to annotations. The only minor deduction is the slight verbosity of the Javadoc, but it is justified and not excessive.
Run 1
Code Structure: Standard, logical organization of package, imports, documentation, annotations, and declaration. Nesting: No nested logic or unnecessary complexity. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain its purpose, parameter requirements, and concurrency behavior. Code length: Minimal implementation with 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, although a blank line between the package declaration and imports would improve visual separation.
Run 2
Code Structure: Clearly organized into package, imports, documentation, metadata, and annotation declaration; blank lines between sections would improve separation. Nesting: No nested logic, making it effortless to scan. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain purpose, parameter constraints, and concurrency behavior. Code length: Compact implementation with appropriately informative documentation. Action granularity: Each import and metadata annotation occupies its own line; the empty declaration is naturally concise. Reading flow: Follows conventional Java ordering, moving naturally from context and documentation to the declaration.
Run 3
Code Structure: Standard, logical organization of package, imports, documentation, annotations, and declaration; blank lines between sections would improve separation. Nesting: No nested logic, making the code immediately accessible. Clarity of intent: The Subscribe name and detailed Javadoc clearly explain its purpose, parameter constraints, and concurrency behavior. Code length: Concise implementation with appropriately scoped documentation. Action granularity: Each import and annotation occupies its own line; the empty declaration is suitably compact. Reading flow: Natural top-to-bottom progression from dependencies to usage documentation and annotation metadata.