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, standard package/import ordering, and proper Javadoc on both the class and its methods. Nesting is flat—just one field and two simple methods. Intent is explicit: the class name and method names clearly convey the purpose of managing an options object for altering client quotas. The code is concise, with no unnecessary boilerplate. Action granularity is appropriate: each method contains one logical action (return the field or assign the field and return this). Reading flow is natural, following the standard JavaBean/Builder pattern. The only minor deduction is the redundant 'this' references, which some style guides discourage, but they do not harm clarity.
Run 3
This code is highly readable. It follows a clear and logical structure: package declaration, imports, class-level Javadoc, class declaration, a single field, and two well-documented methods. Nesting is minimal and appropriate. The intent of each method is unambiguous, with descriptive names like 'validateOnly' and clear Javadoc explaining both getter and setter behavior. The code is concise without being cryptic—each method performs exactly one task. Action granularity is excellent, with a single statement per line. The reading flow is natural, moving from field declaration to getter to setter, and the fluent return pattern (returning 'this') is a common and expected convention in such API classes. Minor points: no validation logic exists to justify the 'validateOnly' flag beyond storage, but this is acceptable for a simple options class. Overall, the code sets a strong example of clean, maintainable Java.
Run 1
1. Code Structure: Logically organized into a single options class with a field, getter, and fluent setter. 2. Nesting: Minimal nesting and no conditional branches make it easy to follow. 3. Clarity of intent: Descriptive class and method names, supported by Javadoc, clearly explain validation-only behavior; 'configs' is slightly less precise than 'quotas'. 4. Code length: Compact and appropriate for its purpose, with no unnecessary complexity. 5. Action granularity: Each statement performs one action on its own line. 6. Reading flow: Natural progression from class documentation to state and accessor methods; spacing between the package declaration and imports would slightly improve presentation.
Run 2
Code Structure: A logically organized options class with one field, a getter, and a fluent setter. Nesting: Flat methods with no conditional or loop nesting. Clarity of intent: Descriptive class and method names, supported by Javadoc, clearly communicate validation-only behavior; 'configs' is slightly less precise than 'client quotas.' Code length: Concise, with no unnecessary logic or excessive documentation. Action granularity: Each statement performs one action on its own line. Reading flow: Natural progression from class documentation to state, getter, and setter; a blank line after the package declaration would slightly improve visual separation.
Run 3
Code Structure: A logically organized options class with a single field, getter, and fluent setter. Nesting: No nested control flow, making it easy to scan. Clarity of intent: Descriptive names and Javadoc clearly explain validation-only behavior, though referring to 'configs' rather than quotas slightly reduces precision. Code length: Short and focused, with no unnecessary logic. Action granularity: Each statement performs one action on its own line. Reading flow: The field-to-getter-to-setter sequence is natural; a blank line after the package declaration would improve visual separation.