Source code
package org.apache.kafka.clients.admin;
import org.apache.kafka.common.annotation.InterfaceAudience;
import java.util.Collection;
/**
* Options for {@link Admin#alterClientQuotas(Collection, AlterClientQuotasOptions)}.
*/
@InterfaceAudience.Public
public class AlterClientQuotasOptions extends AbstractOptions<AlterClientQuotasOptions> {
private boolean validateOnly = false;
/**
* Returns whether the request should be validated without altering the configs.
*/
public boolean validateOnly() {
return this.validateOnly;
}
/**
* Sets whether the request should be validated without altering the configs.
*/
public AlterClientQuotasOptions validateOnly(boolean validateOnly) {
this.validateOnly = validateOnly;
return this;
}
}
Run 1
The code is well-structured and highly readable. It follows a clear class definition pattern with a single private field, a getter-like method, and a fluent setter. The nesting is flat, with no conditional or loop structures. Intent is explicit through descriptive method names and Javadoc comments. The code is concise, containing only essential logic without redundancy. Each method performs one clear action. The reading flow is natural, moving from field declaration to accessor to mutator. Minor deductions relate to the lack of null checks or validation (though not required for a boolean) and the absence of additional documentation for edge cases, but overall this is exemplary, idiomatic Java code.
Run 2
The code is highly readable. It has a clear, logical structure with a single class definition, well-organized imports, and proper Javadoc comments explaining the class and its methods. Nesting is minimal—essentially flat—with no conditionals or deep blocks. Intent is unambiguous: the class provides options for quota alteration, specifically a 'validateOnly' flag. Code length is concise and appropriate for the functionality. Each method performs one action: reading or setting the flag, with the setter returning 'this' for fluent chaining. Reading flow is natural, moving from class declaration to field, then getter, then setter. The naming is consistent and self-documenting, following Java conventions. Minor deductions could be for the slightly redundant Javadoc on trivial getter/setter, but overall this is exemplary code.
Run 3
The code is a clean, well-structured Java class extending a base options class. It follows standard conventions with a single private field, a getter-like method (validateOnly()), and a fluent setter that returns 'this'. The class is flat with no nesting, and each method performs a single clear action. Javadoc comments explain intent for both methods and the class itself. The import statements are minimal and relevant. The fluent setter pattern is idiomatic for Kafka options classes, enhancing readability and usability. Minor deductions: the class is very small and simple, so the high score reflects clarity rather than complexity handled well. Overall, it is concise, unambiguous, and easy to follow for any Java developer.
Run 1
Code Structure: A logically organized options class with one field, a getter, and a fluent setter. Nesting: Minimal, with no conditional or loop nesting. Clarity of intent: Descriptive names and Javadoc clearly explain validation-only behavior; however, referring to 'configs' rather than client quotas is slightly imprecise. Code length: Short and focused, with no unnecessary logic. Action granularity: Each statement performs one action on its own line. Reading flow: Natural progression from class documentation to state, getter, and setter; additional spacing around the package and imports would slightly improve visual separation.
Run 2
Code Structure: A logically organized options class with one field and clearly separated getter and fluent setter. Nesting: Flat, with no conditional or loop nesting. Clarity of intent: Descriptive names and Javadoc clearly explain validation-only behavior, though 'configs' is less precise than 'client quotas.' Code length: Concise, with minimal boilerplate; explicit initialization to false is redundant but readable. Action granularity: Each statement performs one action on its own line. Reading flow: Natural progression from class documentation to state, getter, and setter. Minor import-spacing and documentation precision issues prevent a perfect score.
Run 3
Code Structure: The class logically groups a single option with its getter and fluent setter. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names and Javadoc clearly explain validation-only behavior, though 'configs' is less precise than 'client quotas.' Code length: The implementation is concise and contains no unnecessary logic. Action granularity: Each statement performs one action on its own line. Reading flow: The field-to-getter-to-setter ordering is natural and easy to follow; additional spacing around the package and import sections would slightly improve presentation.