try new-method

src/com/google/common/collect/AbstractMultiset.java

@@ -0,0 +1,183 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.google.common.collect;
+
+import com.google.common.annotations.GwtCompatible;
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.Multisets;
+import java.util.AbstractCollection;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+@GwtCompatible
+abstract class AbstractMultiset<E>
+extends AbstractCollection<E>
+implements Multiset<E> {
+    private transient Set<E> elementSet;
+    private transient Set<Multiset.Entry<E>> entrySet;
+
+    AbstractMultiset() {
+    }
+
+    @Override
+    public int size() {
+        return Multisets.sizeImpl(this);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.entrySet().isEmpty();
+    }
+
+    @Override
+    public boolean contains(@Nullable Object element) {
+        return this.count(element) > 0;
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return Multisets.iteratorImpl(this);
+    }
+
+    @Override
+    public int count(@Nullable Object element) {
+        for (Multiset.Entry<E> entry : this.entrySet()) {
+            if (!Objects.equal(entry.getElement(), element)) continue;
+            return entry.getCount();
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean add(@Nullable E element) {
+        this.add(element, 1);
+        return true;
+    }
+
+    @Override
+    public int add(@Nullable E element, int occurrences) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean remove(@Nullable Object element) {
+        return this.remove(element, 1) > 0;
+    }
+
+    @Override
+    public int remove(@Nullable Object element, int occurrences) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public int setCount(@Nullable E element, int count) {
+        return Multisets.setCountImpl(this, element, count);
+    }
+
+    @Override
+    public boolean setCount(@Nullable E element, int oldCount, int newCount) {
+        return Multisets.setCountImpl(this, element, oldCount, newCount);
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> elementsToAdd) {
+        return Multisets.addAllImpl(this, elementsToAdd);
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> elementsToRemove) {
+        return Multisets.removeAllImpl(this, elementsToRemove);
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> elementsToRetain) {
+        return Multisets.retainAllImpl(this, elementsToRetain);
+    }
+
+    @Override
+    public void clear() {
+        Iterators.clear(this.entryIterator());
+    }
+
+    @Override
+    public Set<E> elementSet() {
+        Set<E> result = this.elementSet;
+        if (result == null) {
+            this.elementSet = result = this.createElementSet();
+        }
+        return result;
+    }
+
+    Set<E> createElementSet() {
+        return new ElementSet();
+    }
+
+    abstract Iterator<Multiset.Entry<E>> entryIterator();
+
+    abstract int distinctElements();
+
+    @Override
+    public Set<Multiset.Entry<E>> entrySet() {
+        Set<Multiset.Entry<Multiset.Entry<E>>> result = this.entrySet;
+        if (result == null) {
+            this.entrySet = result = this.createEntrySet();
+        }
+        return result;
+    }
+
+    Set<Multiset.Entry<E>> createEntrySet() {
+        return new EntrySet();
+    }
+
+    @Override
+    public boolean equals(@Nullable Object object) {
+        return Multisets.equalsImpl(this, object);
+    }
+
+    @Override
+    public int hashCode() {
+        return this.entrySet().hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return this.entrySet().toString();
+    }
+
+    class EntrySet
+    extends Multisets.EntrySet<E> {
+        EntrySet() {
+        }
+
+        @Override
+        Multiset<E> multiset() {
+            return AbstractMultiset.this;
+        }
+
+        @Override
+        public Iterator<Multiset.Entry<E>> iterator() {
+            return AbstractMultiset.this.entryIterator();
+        }
+
+        @Override
+        public int size() {
+            return AbstractMultiset.this.distinctElements();
+        }
+    }
+
+    class ElementSet
+    extends Multisets.ElementSet<E> {
+        ElementSet() {
+        }
+
+        @Override
+        Multiset<E> multiset() {
+            return AbstractMultiset.this;
+        }
+    }
+}