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 well-structured with clear public API documentation and logical organization. The `partitionResult` method is readable with flat nesting and clear intent, though it uses a lambda with multiple branches. The `all()` method has increased complexity with nested logic inside a lambda, but remains understandable. Code length is moderate and appropriate. Action granularity is mostly good, though the string concatenation in `all()` is somewhat verbose. Reading flow is natural, with methods returning futures consistently. Overall, the code is maintainable and readable, but could benefit from extracting complex lambda logic into helper methods to reduce nesting and improve clarity.
Run 2
The code is generally well-structured with clear intent, logical organization, and a reasonable nesting depth. Each method has a single responsibility, and the use of streams in `all()` is concise. However, readability is reduced by the inline exception-handling logic in `all()`, which repeats the partition-failure accumulation and loops through all values to find the first non-null exception. A helper method or more descriptive variable names could improve clarity. The lambda inside `thenApply` is somewhat long and mixes stream processing with imperative checks. Indentation and formatting are consistent, but the long string concatenations and conditional branching slightly interrupt natural reading flow.
Run 3
The code is generally well-structured and readable. It has a clear class purpose, intuitive method names, and appropriate Javadoc. Nesting in `partitionResult` is moderate (three levels) but acceptable for async error handling. `all()` has a minor inefficiency: it first collects failed partitions into a list, then iterates values to find the first non-null exception, which slightly obscures intent. The `if ((message != null) && !message.isEmpty())` check adds unnecessary verbosity. Line lengths are reasonable, and action granularity is mostly one action per line. Overall, the code is understandable but could be slightly more concise in `all()`.
Run 1
Code Structure: The class is logically organized around a stored future and two clearly separated result methods. Nesting: Moderate nesting in callbacks, especially the loop and conditional error handling in all(), adds some reading effort. Clarity of intent: Descriptive method and variable names, types, and Javadoc make the purpose clear, although returning null to complete Void futures requires familiarity with asynchronous Java APIs. Code length: Generally concise, but duplicated exception construction and message formatting could be simplified. Action granularity: Statements typically perform one action each; the stream pipeline is appropriately split across lines. Reading flow: Constructor-to-method ordering and straightforward success/error branches support natural reading. Minor formatting inconsistencies and collecting failed partitions before separately scanning exceptions slightly interrupt the flow.
Run 2
Code Structure: The class is logically organized into a constructor and two focused result-access methods. Nesting: partitionResult has moderate conditional nesting, while all combines a callback, loop, and nested checks; guard clauses could flatten both. Clarity of intent: Descriptive method and variable names, explicit error handling, and Javadoc make the purpose clear, although null representing success 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, and the stream pipeline is split into readable steps. Reading flow: Methods progress naturally from checking errors to completing or returning results. Minor formatting inconsistencies, tightly packed imports, and the mixture of stream processing and iteration slightly interrupt an otherwise clear flow.
Run 3
Code Structure: Well organized into a small result wrapper with separate methods for partition-specific and aggregate outcomes. Nesting: Moderate nesting in asynchronous callbacks, particularly the loop and conditionals in all(), slightly increases reading effort. Clarity of intent: Descriptive method and variable names, explicit error handling, and brief documentation make the purpose clear; null-based success semantics require some inference. Code length: Mostly concise, though duplicated exception construction and message formatting could be simplified. Action granularity: Statements generally perform one action each, and the stream pipeline is broken into readable steps. Reading flow: Natural progression from stored future to constructor and public result methods; nested branches and the combination of stream collection with a subsequent loop modestly interrupt the flow.