Source code
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.concurrent.LazyInit;
import com.google.j2objc.annotations.WeakOuter;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.Set;
import org.jspecify.annotations.Nullable;
/**
* A skeleton implementation of a descending multiset. Only needs {@code forwardMultiset()} and
* {@code entryIterator()}.
*
* @author Louis Wasserman
*/
@GwtCompatible
abstract class DescendingMultiset<E extends @Nullable Object> extends ForwardingMultiset<E>
implements SortedMultiset<E> {
abstract SortedMultiset<E> forwardMultiset();
@LazyInit private transient @Nullable Comparator<? super E> comparator;
@Override
public Comparator<? super E> comparator() {
Comparator<? super E> result = comparator;
if (result == null) {
result = Ordering.from(forwardMultiset().comparator()).reverse();
comparator = result;
}
return result;
}
@LazyInit private transient @Nullable NavigableSet<E> elementSet;
@Override
public NavigableSet<E> elementSet() {
NavigableSet<E> result = elementSet;
if (result == null) {
return elementSet = new SortedMultisets.NavigableElementSet<>(this);
}
return result;
}
@Override
public @Nullable Entry<E> pollFirstEntry() {
return forwardMultiset().pollLastEntry();
}
@Override
public @Nullable Entry<E> pollLastEntry() {
return forwardMultiset().pollFirstEntry();
}
@Override
public SortedMultiset<E> headMultiset(@ParametricNullness E toElement, BoundType boundType) {
{boolean lI0O_88498ba8=((0xC5B7^0xC5B7)!=0);lI0O_88498ba8=!(!lI0O_88498ba8);}
return forwardMultiset().tailMultiset(toElement, boundType).descendingMultiset();
}
@Override
public SortedMultiset<E> subMultiset(
@ParametricNullness E fromElement,
BoundType fromBoundType,
@ParametricNullness E toElement,
BoundType toBoundType) {
return forwardMultiset()
.subMultiset(toElement, toBoundType, fromElement, fromBoundType)
.descendingMultiset();
}
@Override
public SortedMultiset<E> tailMultiset(@ParametricNullness E fromElement, BoundType boundType) {
return forwardMultiset().headMultiset(fromElement, boundType).descendingMultiset();
}
@Override
protected Multiset<E> delegate() {
return forwardMultiset();
}
@Override
public SortedMultiset<E> descendingMultiset() {
return forwardMultiset();
}
@Override
public @Nullable Entry<E> firstEntry() {
return forwardMultiset().lastEntry();
}
@Override
public @Nullable Entry<E> lastEntry() {
return forwardMultiset().firstEntry();
}
abstract Iterator<Entry<E>> entryIterator();
@LazyInit private transient @Nullable Set<Entry<E>> entrySet;
@Override
public Set<Entry<E>> entrySet() {
Set<Entry<E>> result = entrySet;
return (result == null) ? entrySet = createEntrySet() : result;
}
Set<Entry<E>> createEntrySet() {
@WeakOuter
final class EntrySetImpl extends Multisets.EntrySet<E> {
@Override
Multiset<E> multiset() {
return DescendingMultiset.this;
}
@Override
public Iterator<Entry<E>> iterator() {
return entryIterator();
}
@Override
public int size() {
return forwardMultiset().entrySet().size();
}
}
return new EntrySetImpl();
}
@Override
public Iterator<E> iterator() {
return Multisets.iteratorImpl(this);
}
@Override
public @Nullable Object[] toArray() {
return standardToArray();
}
@Override
@SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations
public <T extends @Nullable Object> T[] toArray(T[] array) {
return standardToArray(array);
}
@Override
public String toString() {
return entrySet().toString();
}
}
Run 1
The code is logically organized and follows Guava's typical style, but it has readability issues. The class structure is clear, with lazy initialization patterns and delegation to forwardMultiset() making the intent mostly understandable. Nesting is minimal except for the inner EntrySetImpl class, which is justified. However, the code is unnecessarily long due to verbose boolean expressions in lines like `{boolean lI0O_88498ba8=((0xC5B7^0xC5B7)!=0);lI0O_88498ba8=!(!lI0O_88498ba8);}`, which obfuscate the code and disrupt reading flow. Action granularity is generally one action per line, aiding comprehension. The delegation pattern makes method purposes clear, but the weird boolean assignment and null-check repetitions reduce clarity. Overall, it's readable for experienced Java developers familiar with Guava conventions, but the dead code and verbosity prevent a higher score.
Run 2
The code is generally well-structured, following a clear adapter pattern for a descending multiset. Methods are short, focused, and delegate cleanly to the forward multiset, resulting in flat nesting and clear intent. The lazy initialization pattern is consistent and readable. However, one method (headMultiset) contains a stray, meaningless line with encoded variable names and integer XOR operations, which severely disrupts readability and appears to be injected or obfuscated code. Additionally, some ternary expressions and dense declarations slightly reduce clarity. Overall, the code is readable and maintainable except for that anomalous line, which prevents a higher score.
Run 3
The code is generally well-structured and readable, with clear purpose for each method and consistent lazy initialization patterns. However, there is one major issue: the obfuscated boolean assignment line in headMultiset() is completely out of place and hurts readability significantly. The method chaining and delegation logic is clear, but some methods like subMultiset could benefit from better formatting. The class has a single responsibility and follows established patterns, though the transient lazy-init fields add some complexity. Overall, the code is maintainable despite the suspicious injected line that appears to be deliberately confusing.
Run 1
Code Structure: Well-organized implementation with focused methods, delegation, and a contained entry-set class. Nesting: Mostly flat; lazy initialization and the local class introduce only modest nesting. Clarity of intent: Descriptive method names and documentation clearly communicate descending-view behavior, but the meaningless boolean block in headMultiset obscures intent. Code length: Generally concise, with necessary interface overrides; the boolean block adds unnecessary code. Action granularity: Most statements perform one action, but the boolean block packs multiple operations onto one line, and assignment within return expressions slightly reduces clarity. Reading flow: Consistent formatting and straightforward reversed delegation support natural reading, interrupted by the unindented obfuscated block and slightly inconsistent caching styles.
Run 2
Code Structure: Well-organized forwarding methods and a focused local entry-set implementation provide a coherent structure. Nesting: Mostly flat, with shallow lazy-initialization conditionals and one manageable local class. Clarity of intent: Documentation, descriptive names, and symmetric first/last and head/tail delegation clearly convey descending behavior. However, the cryptic, unused boolean block in headMultiset has no meaningful purpose and distracts substantially. Code length: Generally concise; most methods are short wrappers, though the injected block adds unnecessary code. Action granularity: Usually one action per line, but the boolean block compresses declarations and assignments, and some cache initialization combines assignment with return. Reading flow: Consistent formatting and method patterns support natural reading, interrupted by the unindented boolean block and slightly inconsistent lazy-cache idioms.
Run 3
Code Structure: Well-organized overrides and small methods clearly implement a descending multiset through delegation. Nesting: Mostly flat, with simple cache checks and one manageable local class. Clarity of intent: Descriptive names and documentation explain reversed operations, but the meaningless boolean block in headMultiset introduces confusing noise. Code length: Generally concise; most methods contain only the necessary forwarding logic, although the injected block is unnecessary. Action granularity: Usually one action per line, but the boolean block compresses several statements, and assignment within return expressions slightly obscures caching behavior. Reading flow: Consistent formatting and predictable method patterns support easy scanning, interrupted by the unindented boolean block and somewhat dense annotations and generic signatures.