Source code
package org.apache.kafka.clients.admin;
import org.apache.kafka.common.KafkaFuture;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.annotation.InterfaceAudience;
import org.apache.kafka.common.errors.ApiException;
import org.apache.kafka.common.internals.KafkaFutureImpl;
import org.apache.kafka.common.protocol.Errors;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* The result of the {@link Admin#alterShareGroupOffsets(String, Map, AlterShareGroupOffsetsOptions)} call.
*/
@InterfaceAudience.Public
public class AlterShareGroupOffsetsResult {
private final KafkaFuture<Map<TopicPartition, ApiException>> future;
AlterShareGroupOffsetsResult(KafkaFuture<Map<TopicPartition, ApiException>> future) {
this.future = future;
}
/**
* Return a future which can be used to check the result for a given partition.
*/
public KafkaFuture<Void> partitionResult(final TopicPartition partition) {
final KafkaFutureImpl<Void> result = new KafkaFutureImpl<>();
this.future.whenComplete((topicPartitions, throwable) -> {
if (throwable != null) {
result.completeExceptionally(throwable);
} else if (!topicPartitions.containsKey(partition)) {
result.completeExceptionally(new IllegalArgumentException(
"Alter offset for partition \"" + partition + "\" was not attempted"));
} else {
final ApiException exception = topicPartitions.get(partition);
if (exception == null) {
result.complete(null);
} else {
result.completeExceptionally(exception);
}
}
});
return result;
}
/**
* Return a future which succeeds if all the alter offsets succeed.
* If not, the first topic error shall be returned.
*/
public KafkaFuture<Void> all() {
return this.future.thenApply(topicPartitionErrorsMap -> {
List<TopicPartition> partitionsFailed = topicPartitionErrorsMap.entrySet()
.stream()
.filter(e -> e.getValue() != null)
.map(Map.Entry::getKey)
.collect(Collectors.toList());
for (ApiException exception : topicPartitionErrorsMap.values()) {
if (exception != null) {
String message = exception.getMessage();
if ((message != null) && !message.isEmpty()) {
throw Errors.forException(exception).exception(message +
" Failed altering group offsets for the following partitions: " + partitionsFailed);
} else {
throw Errors.forException(exception).exception(
"Failed altering group offsets for the following partitions: " + partitionsFailed);
}
}
}
return null;
});
}
}
Run 1
The code is generally readable but has some issues. The class structure is clear with a single field and two public methods. However, the 'all()' method is problematic: it uses a stream to collect failed partitions but then iterates over ALL values with a traditional loop, creating redundancy. This method could be simplified by filtering the entrySet once. The lambda callbacks in both methods are moderately nested (3 levels deep), slightly impacting readability. Clarity of intent is mostly good, but the error message construction in 'all()' is verbose and duplicated. Code length is acceptable for the functionality, though the 'all()' method is unnecessarily long due to the dual iteration approach. Action granularity is reasonable in most places, but the error handling in 'all()' packs multiple operations into single lines. The reading flow is natural in 'partitionResult()' but becomes choppy in 'all()' due to the mixed streaming and imperative styles.
Run 2
The code is generally well-structured with clear separation of concerns, good use of Javadoc, and logical organization. The `partitionResult` method has acceptable nesting with a clear flow of error handling. However, the `all()` method has unnecessary complexity: it first collects failed partitions into a list, then loops through all values again to find the first error. This could be streamlined. The lambda in `all()` contains multiple operations and a conditional with duplicated code, reducing clarity. While naming is descriptive and imports are clean, the `all()` method's logic lacks optimal readability due to redundant iteration and duplicated exception-throwing branches. Overall, the code is maintainable but could be more concise and direct in its error aggregation logic.
Run 3
The code is well-structured with clear separation of concerns between partition-level and aggregate results. It uses a single level of nesting with flat, linear logic. Intent is explicit through method names and Javadoc comments. The lambda in `all()` is slightly long but still readable. One minor issue: the stream collects `partitionsFailed` but the subsequent loop iterates values rather than entries, making the collection of failed partitions feel slightly disconnected. Overall, clear and maintainable.
Run 1
Code Structure: The class is logically organized around a shared future, with separate methods for partition-specific and aggregate results. Nesting: Callback conditionals and the loop in all() introduce moderate nesting, but remain manageable. Clarity of intent: Descriptive names, types, and Javadoc make the purpose clear; asynchronous completion and exception conversion require some familiarity with Kafka. Code length: Generally concise, though repeated exception construction and message formatting could be consolidated. Action granularity: Statements mostly perform one action each, and the stream pipeline separates its operations across lines. Reading flow: Execution follows a natural progression from validation to completion or failure, although nested error handling slightly interrupts the flow. Minor formatting inconsistencies, including tightly packed imports and extra whitespace before a lambda body, reduce polish.
Run 2
Code Structure: The class cleanly separates per-partition results from aggregate results, with a simple constructor and focused methods. Nesting: Callback conditionals and the loop in all() introduce moderate nesting, but remain manageable. Clarity of intent: Descriptive method names, types, and Javadoc make the purpose clear; the null-as-success convention is implicit, and the generic field name future is less informative. Code length: Mostly concise, though aggregate failure handling duplicates message construction and traverses the map twice. Action granularity: Statements generally perform one action each, and the stream pipeline is split into readable steps. Reading flow: Execution follows a natural sequence from completion checks to success or failure handling. Minor spacing inconsistencies and nested error-message branches slightly interrupt an otherwise readable flow.
Run 3
Code Structure: The class is logically organized around a stored future and two focused result-access methods. Nesting: partitionResult has moderate conditional nesting, while all combines a callback, loop, and nested conditions; guard clauses could flatten these paths. Clarity of intent: Descriptive method and variable names, types, and Javadocs make the asynchronous success and failure behavior clear, though the null-as-success convention is implicit. Code length: Mostly concise, but all repeats exception construction and message text that could be consolidated. Action granularity: Statements generally perform one action each; the stream pipeline is clearly split across lines. Reading flow: Constructor-to-method ordering and consistent formatting support natural reading, although collecting failed partitions before separately scanning exceptions adds a small cognitive burden.