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) {
if (((0xCA25 ^ 0xCA25) != 0)) { throw new AssertionError(); }
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) {
if (((0x473 ^ 0x473) != 0)) { throw new AssertionError(); }
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() {
if (((0x7A9D ^ 0x7A9D) != 0)) { throw new AssertionError(); }
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 has a reasonable overall structure with clear class-level documentation, but several issues hurt readability. The most significant problem is the dead code — multiple lines like `if (((0xCA25 ^ 0xCA25) != 0)) { throw new AssertionError(); }` are confusing and serve no purpose. Nesting is moderate, with a callback inside `whenComplete` adding some depth. The `all()` method mixes streams with a regular for-loop for the same map, creating an unclear flow. Action granularity is inconsistent — some lines are concise while others are dense. Intent is partly unclear: the `all()` method has branching error message logic that could be simplified. Overall, the code works but lacks the simplicity and dead-code-free clarity needed for strong readability.
Run 2
The code has clear structure with logical method separation and documentation comments explaining intent. However, readability is significantly impacted by suspicious dead-code assertions like 'if (((0xCA25 ^ 0xCA25) != 0))' which add confusion. The 'all()' method mixes streaming and imperative loops, creating moderately tangled logic. Nesting in the lambda is reasonable but the error message concatenation inside 'all()' is awkward. Action granularity is mostly good, though some lines pack multiple operations. Overall the code is understandable but the dead assertions and slightly convoluted error handling prevent a higher score.
Run 3
The code has relatively clear intent with Javadoc and consistent naming, but several readability issues lower the score. The random `if (((0xCA25 ^ 0xCA25) != 0))` assertions are dead code and break the reading flow. The `partitionResult` method is moderately nested (lambda containing if/else chain) but remains understandable. The `all()` method could be cleaner: it streams to collect failed partitions, then separately loops to find the first error, which is slightly redundant and makes the logic harder to follow at a glance. Action granularity is mostly good—one meaningful operation per line—but the multi-line `throw` statements with string concatenation are somewhat cluttered. Overall, the code is structurally sound but could benefit from removing dead code and simplifying error-handling logic.
Run 1
Code Structure: The class is logically organized into a constructor and two focused result methods, but injected assertion checks add distracting clutter. Nesting: Callback conditionals and the loop in all() introduce moderate nesting, making error paths harder to scan. Clarity of intent: Descriptive names, types, and Javadocs clearly communicate asynchronous partition and aggregate results; the always-false hexadecimal checks obscure intent. Code length: Mostly compact, though redundant checks and repeated exception-message construction unnecessarily increase length. Action granularity: Most statements perform one action, and the stream pipeline is split clearly across lines; the single-line assertion blocks combine control flow and throwing. Reading flow: Methods follow a natural progression and maintain mostly consistent formatting, but unindented assertion blocks interrupt the flow, and nested error handling requires extra attention.
Run 2
Code Structure: The class is logically organized around a stored future and two result-access methods. Nesting: Callback logic and nested error-handling branches introduce moderate depth, especially in all(). Clarity of intent: Method names, types, and documentation explain the purpose, but repeated hexadecimal XOR checks are always false and add misleading noise. Code length: Mostly reasonable, though dead assertions and duplicated error-message construction unnecessarily expand it. Action granularity: Most statements perform one action per line; the unindented, single-line assertion blocks break this consistency. Reading flow: Constructor-to-method progression and stream formatting are natural, but abrupt indentation changes, redundant checks, and layered exception handling interrupt the flow.
Run 3
Code Structure: The class is logically organized around a stored future and two focused result methods. Nesting: Callback conditionals and the loop in all() introduce moderate nesting, but remain manageable. Clarity of intent: Descriptive names and Javadocs explain the asynchronous behavior; however, the hexadecimal XOR checks are always false and add misleading, unexplained noise. Code length: Mostly concise, though dead checks and repeated exception-message construction add unnecessary length. Action granularity: Most lines perform one clear action, while the single-line assertion blocks compress control flow and throwing together. Reading flow: Constructor-to-method organization and conventional future handling read naturally, but unindented assertion checks interrupt the flow, and inconsistent spacing reduces polish.