Skip to content

Commit d38af4b

Browse files
blafondblafond
authored
Merge pull request #1690 from mbenson/MODE-2743
Mode 2743
2 parents 27c8960 + 1e249fe commit d38af4b

File tree

2 files changed

+367
-62
lines changed

2 files changed

+367
-62
lines changed

‎modeshape-common/src/main/java/org/modeshape/common/collection/AbstractMultimap.java

+72-58
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@
2828
import java.util.ListIterator;
2929
import java.util.Map;
3030
import java.util.Map.Entry;
31+
import java.util.Optional;
3132
import java.util.Set;
3233
import java.util.SortedMap;
3334
import java.util.SortedSet;
@@ -61,12 +62,12 @@ protected Map<K, Collection<V>> rawData() {
6162

6263
protected abstract Collection<V> createUnmodifiableEmptyCollection();
6364

64-
@SuppressWarnings( {"unchecked", "rawtypes"} )
6565
protected Collection<V> createUnmodifiable( Collection<V> original ) {
66-
if (original instanceof List) {
67-
return Collections.unmodifiableList((List)original);
68-
} else if (original instanceof Set) {
69-
return Collections.unmodifiableSet((Set)original);
66+
if (original instanceof List<?>) {
67+
return Collections.unmodifiableList((List<V>) original);
68+
}
69+
if (original instanceof Set<?>) {
70+
return Collections.unmodifiableSet((Set<V>) original);
7071
}
7172
return Collections.unmodifiableCollection(original);
7273
}
@@ -97,21 +98,18 @@ public boolean containsKey( K key ) {
9798

9899
@Override
99100
public boolean containsValue( Object value ) {
100-
for (Collection<V> collection : data.values()) {
101-
if (collection.contains(value)) return true;
102-
}
103-
return false;
101+
return data.values().stream().anyMatch(c -> c.contains(value));
104102
}
105103

106104
@Override
107105
public boolean containsEntry( Object key,
108106
Object value ) {
109107
Collection<V> values = data.get(key);
110-
return values == null ? false : values.contains(value);
108+
return values != null && values.contains(value);
111109
}
112110

113111
@Override
114-
public java.util.Collection<V> get( K key ) {
112+
public Collection<V> get( K key ) {
115113
Collection<V> collection = data.get(key);
116114
if (collection == null) {
117115
collection = createCollection();
@@ -130,12 +128,7 @@ public boolean put( K key,
130128
}
131129

132130
protected Collection<V> getOrCreateCollection( K key ) {
133-
Collection<V> values = data.get(key);
134-
if (values == null) {
135-
values = createCollection();
136-
data.put(key, values);
137-
}
138-
return values;
131+
return data.computeIfAbsent(key, k -> createCollection());
139132
}
140133

141134
@Override
@@ -153,7 +146,7 @@ public boolean remove( K key,
153146
}
154147

155148
@Override
156-
public java.util.Collection<V> removeAll( K key ) {
149+
public Collection<V> removeAll( K key ) {
157150
Collection<V> values = data.remove(key);
158151
if (values == null) return createUnmodifiableEmptyCollection();
159152
Collection<V> copy = createCollection();
@@ -216,9 +209,6 @@ protected Iterator<Map.Entry<K, V>> createEntryIterator() {
216209

217210
protected Collection<V> wrapCollection( K key,
218211
Collection<V> values ) {
219-
// if (values instanceof Set) {
220-
// return new WrappedSet(key, (Set<V>)values);
221-
// } else
222212
if (values instanceof List) {
223213
return wrapList(key, (List<V>)values);
224214
}
@@ -305,7 +295,7 @@ protected final class EntryIterator implements Iterator<Map.Entry<K, V>> {
305295
if (iter.hasNext()) {
306296
nextKey();
307297
} else {
308-
currentValuesIterator = new EmptyIterator<V>();
298+
currentValuesIterator = new EmptyIterator<>();
309299
}
310300
}
311301

@@ -326,7 +316,7 @@ public Entry<K, V> next() {
326316
if (!currentValuesIterator.hasNext()) {
327317
nextKey();
328318
}
329-
return new ImmutableMapEntry<K, V>(currentKey, currentValuesIterator.next());
319+
return new ImmutableMapEntry<>(currentKey, currentValuesIterator.next());
330320
}
331321

332322
@SuppressWarnings( "synthetic-access" )
@@ -365,8 +355,8 @@ public boolean contains( Object o ) {
365355
}
366356

367357
protected class WrappedCollection implements Collection<V> {
368-
private Collection<V> delegate;
369358
private final K key;
359+
private Collection<V> delegate;
370360

371361
protected WrappedCollection( K key,
372362
Collection<V> values ) {
@@ -403,22 +393,25 @@ protected final void addToMap() {
403393

404394
@Override
405395
public int size() {
406-
return delegate().size();
396+
Collection<V> d = delegate();
397+
return d == null ? 0 : d.size();
407398
}
408399

409400
@Override
410401
public boolean isEmpty() {
411-
return delegate().isEmpty();
402+
Collection<V> d = delegate();
403+
return d == null || d.isEmpty();
412404
}
413405

414406
@Override
415407
public boolean contains( Object o ) {
416-
return delegate().contains(o);
408+
Collection<V> d = delegate();
409+
return d != null && d.contains(o);
417410
}
418411

419412
@Override
420413
public Iterator<V> iterator() {
421-
return delegate().iterator();
414+
return new DelegateIterator();
422415
}
423416

424417
@Override
@@ -435,17 +428,20 @@ public <T> T[] toArray( T[] a ) {
435428

436429
@Override
437430
public boolean add( V e ) {
438-
Collection<V> values = delegate();
439-
boolean wasEmpty = values.isEmpty();
440-
if (!values.add(e)) return false;
441-
incrementSize(1);
442-
if (wasEmpty) addToMap();
443-
return true;
431+
boolean wasEmpty = isEmpty();
432+
try {
433+
return AbstractMultimap.this.put(key, e);
434+
} finally {
435+
if (wasEmpty) {
436+
delegate();
437+
}
438+
}
444439
}
445440

446441
@Override
447442
public boolean remove( Object o ) {
448-
if (!delegate().remove(o)) return false;
443+
Collection<V> d = delegate();
444+
if (d == null || !d.remove(o)) return false;
449445
decrementSize(1);
450446
removeIfEmpty();
451447
return true;
@@ -459,54 +455,59 @@ public boolean containsAll( Collection<?> c ) {
459455
@Override
460456
public boolean addAll( Collection<? extends V> c ) {
461457
if (c.isEmpty()) return false;
462-
Collection<V> delegate = delegate();
463-
int sizeBefore = delegate.size();
464-
if (!delegate.addAll(c)) return false;
465-
incrementSize(delegate.size() - sizeBefore);
466-
if (sizeBefore == 0) addToMap();
458+
if (isEmpty()) getOrCreateCollection(key);
459+
Collection<V> d = delegate();
460+
int sizeBefore = d.size();
461+
if (!d.addAll(c)) return false;
462+
incrementSize(d.size() - sizeBefore);
467463
return true;
468464
}
469465

470466
@Override
471467
public boolean removeAll( Collection<?> c ) {
472-
if (c.isEmpty()) return false;
473-
Collection<V> delegate = delegate();
474-
int sizeBefore = delegate.size();
475-
if (!delegate.removeAll(c)) return false;
476-
incrementSize(delegate.size() - sizeBefore); // will be negative
468+
if (c.isEmpty() || isEmpty()) {
469+
return false;
470+
}
471+
Collection<V> d = delegate();
472+
int sizeBefore = d.size();
473+
if (!d.removeAll(c)) return false;
474+
incrementSize(d.size() - sizeBefore); // will be negative
477475
removeIfEmpty();
478476
return true;
479477
}
480478

481479
@Override
482480
public boolean retainAll( Collection<?> c ) {
483-
if (c.isEmpty()) return false;
484-
Collection<V> delegate = delegate();
485-
int sizeBefore = delegate.size();
486-
if (!delegate.retainAll(c)) return false;
487-
int diff = delegate.size() - sizeBefore;
481+
if (isEmpty()) {
482+
return false;
483+
}
484+
Collection<V> d = delegate();
485+
int sizeBefore = d.size();
486+
if (!d.retainAll(c)) return false;
487+
int diff = d.size() - sizeBefore;
488488
incrementSize(diff); // will change correctly if diff is negative
489489
return true;
490490
}
491491

492492
@Override
493493
public void clear() {
494-
Collection<V> delegate = delegate();
495-
int sizeBefore = delegate.size();
496-
delegate.clear();
494+
if (isEmpty()) return;
495+
Collection<V> d = delegate();
496+
int sizeBefore = d.size();
497+
d.clear();
497498
decrementSize(sizeBefore);
498499
removeIfEmpty();
499500
}
500501

501502
@Override
502503
public int hashCode() {
503-
return delegate().hashCode();
504+
return isEmpty() ? Collections.EMPTY_SET.hashCode() : delegate().hashCode();
504505
}
505506

506507
@Override
507508
public boolean equals( Object obj ) {
508-
if (obj == this) return true;
509-
return delegate().equals(obj);
509+
return obj == this
510+
|| Optional.ofNullable(delegate()).orElseGet(AbstractMultimap.this::createUnmodifiableEmptyCollection).equals(obj);
510511
}
511512

512513
@Override
@@ -515,8 +516,8 @@ public String toString() {
515516
}
516517

517518
protected class DelegateIterator implements Iterator<V> {
518-
private final Collection<V> source;
519519
private final Iterator<V> iterator;
520+
private Collection<V> source;
520521

521522
protected DelegateIterator() {
522523
source = delegate();
@@ -550,6 +551,9 @@ public void remove() {
550551
iterator.remove();
551552
decrementSize(1);
552553
removeIfEmpty();
554+
if (isEmpty()) {
555+
source = null;
556+
}
553557
}
554558
}
555559
}
@@ -634,6 +638,16 @@ public List<V> subList( int fromIndex,
634638
return wrapList(getKey(), valueSublist);
635639
}
636640

641+
/**
642+
* {@inheritDoc}
643+
*
644+
* @see org.modeshape.common.collection.AbstractMultimap.WrappedCollection#hashCode()
645+
*/
646+
@Override
647+
public int hashCode() {
648+
return isEmpty() ? Collections.EMPTY_LIST.hashCode() : delegate().hashCode();
649+
}
650+
637651
protected class DelegateListIterator extends DelegateIterator implements ListIterator<V> {
638652

639653
protected DelegateListIterator() {
@@ -780,7 +794,7 @@ public Map.Entry<K, Collection<V>> next() {
780794
Map.Entry<K, Collection<V>> currentEntry = delegateIterator.next();
781795
currentValues = currentEntry.getValue();
782796
K key = currentEntry.getKey();
783-
return new ImmutableMapEntry<K, Collection<V>>(key, wrapCollection(key, currentValues));
797+
return new ImmutableMapEntry<>(key, wrapCollection(key, currentValues));
784798
}
785799

786800
@Override

0 commit comments

Comments
 (0)