Skip to content

Commit

Permalink
Implement of() methods on Multimaps
Browse files Browse the repository at this point in the history 
Signed-off-by: Hiroshi Ito <Hiroshi.Ito@gs.com>
  • Loading branch information
@itohro
itohro committed Jul 21, 2016
1 parent 6a4e99a commit 9182f3f
Show file tree
Hide file tree
Showing 2 changed files with 216 additions and 40 deletions.
160 changes: 160 additions & 0 deletions eclipse-collections/src/main/java/org/eclipse/collections/impl/factory/Multimaps.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -65,16 +65,31 @@ public <K, V> ImmutableListMultimap<K, V> empty()
return (ImmutableListMultimap<K, V>) EMPTY;
}

public <K, V> ImmutableListMultimap<K, V> of()
{
return this.empty();
}

public <K, V> ImmutableListMultimap<K, V> with()
{
return this.empty();
}

public <K, V> ImmutableListMultimap<K, V> of(K key, V value)
{
return this.with(key, value);
}

public <K, V> ImmutableListMultimap<K, V> with(K key, V value)
{
return new ImmutableListMultimapImpl<>(Maps.immutable.with(key, Lists.immutable.with(value)));
}

public <K, V> ImmutableListMultimap<K, V> of(K key1, V value1, K key2, V value2)
{
return this.with(key1, value1, key2, value2);
}

public <K, V> ImmutableListMultimap<K, V> with(K key1, V value1, K key2, V value2)
{
FastListMultimap<K, V> fastListMultimap = FastListMultimap.newMultimap();
Expand All @@ -83,6 +98,11 @@ public <K, V> ImmutableListMultimap<K, V> with(K key1, V value1, K key2, V value
return fastListMultimap.toImmutable();
}

public <K, V> ImmutableListMultimap<K, V> of(K key1, V value1, K key2, V value2, K key3, V value3)
{
return this.with(key1, value1, key2, value2, key3, value3);
}

public <K, V> ImmutableListMultimap<K, V> with(K key1, V value1, K key2, V value2, K key3, V value3)
{
FastListMultimap<K, V> fastListMultimap = FastListMultimap.newMultimap();
Expand All @@ -106,16 +126,31 @@ public <K, V> ImmutableSetMultimap<K, V> empty()
return (ImmutableSetMultimap<K, V>) EMPTY;
}

public <K, V> ImmutableSetMultimap<K, V> of()
{
return this.empty();
}

public <K, V> ImmutableSetMultimap<K, V> with()
{
return this.empty();
}

public <K, V> ImmutableSetMultimap<K, V> of(K key, V value)
{
return this.with(key, value);
}

public <K, V> ImmutableSetMultimap<K, V> with(K key, V value)
{
return new ImmutableSetMultimapImpl<>(Maps.immutable.with(key, Sets.immutable.with(value)));
}

public <K, V> ImmutableSetMultimap<K, V> of(K key1, V value1, K key2, V value2)
{
return this.with(key1, value1, key2, value2);
}

public <K, V> ImmutableSetMultimap<K, V> with(K key1, V value1, K key2, V value2)
{
UnifiedSetMultimap<K, V> unifiedSetMultimap = UnifiedSetMultimap.newMultimap();
Expand All @@ -124,6 +159,11 @@ public <K, V> ImmutableSetMultimap<K, V> with(K key1, V value1, K key2, V value2
return unifiedSetMultimap.toImmutable();
}

public <K, V> ImmutableSetMultimap<K, V> of(K key1, V value1, K key2, V value2, K key3, V value3)
{
return this.with(key1, value1, key2, value2, key3, value3);
}

public <K, V> ImmutableSetMultimap<K, V> with(K key1, V value1, K key2, V value2, K key3, V value3)
{
UnifiedSetMultimap<K, V> unifiedSetMultimap = UnifiedSetMultimap.newMultimap();
Expand All @@ -140,16 +180,31 @@ private ImmutableSortedSetMultimapFactory()
{
}

public <K, V> ImmutableSortedSetMultimap<K, V> of(Comparator<V> comparator)
{
return this.with(comparator);
}

public <K, V> ImmutableSortedSetMultimap<K, V> with(Comparator<V> comparator)
{
return new ImmutableSortedSetMultimapImpl<>(Maps.immutable.with(), comparator);
}

public <K, V> ImmutableSortedSetMultimap<K, V> of(Comparator<V> comparator, K key, V value)
{
return this.with(comparator, key, value);
}

public <K, V> ImmutableSortedSetMultimap<K, V> with(Comparator<V> comparator, K key, V value)
{
return new ImmutableSortedSetMultimapImpl<>(Maps.immutable.with(key, SortedSets.immutable.with(comparator, value)), comparator);
}

public <K, V> ImmutableSortedSetMultimap<K, V> of(Comparator<V> comparator, K key1, V value1, K key2, V value2)
{
return this.with(comparator, key1, value1, key2, value2);
}

public <K, V> ImmutableSortedSetMultimap<K, V> with(Comparator<V> comparator, K key1, V value1, K key2, V value2)
{
TreeSortedSetMultimap<K, V> treeSortedSetMultimap = TreeSortedSetMultimap.newMultimap(comparator);
Expand All @@ -158,6 +213,11 @@ public <K, V> ImmutableSortedSetMultimap<K, V> with(Comparator<V> comparator, K
return treeSortedSetMultimap.toImmutable();
}

public <K, V> ImmutableSortedSetMultimap<K, V> of(Comparator<V> comparator, K key1, V value1, K key2, V value2, K key3, V value3)
{
return this.with(comparator, key1, value1, key2, value2, key3, value3);
}

public <K, V> ImmutableSortedSetMultimap<K, V> with(Comparator<V> comparator, K key1, V value1, K key2, V value2, K key3, V value3)
{
TreeSortedSetMultimap<K, V> treeSortedSetMultimap = TreeSortedSetMultimap.newMultimap(comparator);
Expand All @@ -181,16 +241,31 @@ public <K, V> ImmutableBagMultimap<K, V> empty()
return (ImmutableBagMultimap<K, V>) EMPTY;
}

public <K, V> ImmutableBagMultimap<K, V> of()
{
return this.empty();
}

public <K, V> ImmutableBagMultimap<K, V> with()
{
return this.empty();
}

public <K, V> ImmutableBagMultimap<K, V> of(K key, V value)
{
return this.with(key, value);
}

public <K, V> ImmutableBagMultimap<K, V> with(K key, V value)
{
return new ImmutableBagMultimapImpl<>(Maps.immutable.with(key, Bags.immutable.with(value)));
}

public <K, V> ImmutableBagMultimap<K, V> of(K key1, V value1, K key2, V value2)
{
return this.with(key1, value1, key2, value2);
}

public <K, V> ImmutableBagMultimap<K, V> with(K key1, V value1, K key2, V value2)
{
HashBagMultimap<K, V> hashBagMultimap = HashBagMultimap.newMultimap();
Expand All @@ -199,6 +274,11 @@ public <K, V> ImmutableBagMultimap<K, V> with(K key1, V value1, K key2, V value2
return hashBagMultimap.toImmutable();
}

public <K, V> ImmutableBagMultimap<K, V> of(K key1, V value1, K key2, V value2, K key3, V value3)
{
return this.with(key1, value1, key2, value2, key3, value3);
}

public <K, V> ImmutableBagMultimap<K, V> with(K key1, V value1, K key2, V value2, K key3, V value3)
{
HashBagMultimap<K, V> hashBagMultimap = HashBagMultimap.newMultimap();
Expand Down Expand Up @@ -233,18 +313,33 @@ public <K, V> MutableListMultimap<K, V> empty()
return FastListMultimap.newMultimap();
}

public <K, V> MutableListMultimap<K, V> of()
{
return this.empty();
}

public <K, V> MutableListMultimap<K, V> with()
{
return this.empty();
}

public <K, V> MutableListMultimap<K, V> of(K key, V value)
{
return this.with(key, value);
}

public <K, V> MutableListMultimap<K, V> with(K key, V value)
{
FastListMultimap<K, V> fastListMultimap = FastListMultimap.newMultimap();
fastListMultimap.put(key, value);
return fastListMultimap;
}

public <K, V> MutableListMultimap<K, V> of(K key1, V value1, K key2, V value2)
{
return this.with(key1, value1, key2, value2);
}

public <K, V> MutableListMultimap<K, V> with(K key1, V value1, K key2, V value2)
{
FastListMultimap<K, V> fastListMultimap = FastListMultimap.newMultimap();
Expand All @@ -253,6 +348,11 @@ public <K, V> MutableListMultimap<K, V> with(K key1, V value1, K key2, V value2)
return fastListMultimap;
}

public <K, V> MutableListMultimap<K, V> of(K key1, V value1, K key2, V value2, K key3, V value3)
{
return this.with(key1, value1, key2, value2, key3, value3);
}

public <K, V> MutableListMultimap<K, V> with(K key1, V value1, K key2, V value2, K key3, V value3)
{
FastListMultimap<K, V> fastListMultimap = FastListMultimap.newMultimap();
Expand All @@ -274,18 +374,33 @@ public <K, V> MutableSetMultimap<K, V> empty()
return UnifiedSetMultimap.newMultimap();
}

public <K, V> MutableSetMultimap<K, V> of()
{
return this.empty();
}

public <K, V> MutableSetMultimap<K, V> with()
{
return this.empty();
}

public <K, V> MutableSetMultimap<K, V> of(K key, V value)
{
return this.with(key, value);
}

public <K, V> MutableSetMultimap<K, V> with(K key, V value)
{
UnifiedSetMultimap<K, V> unifiedSetMultimap = UnifiedSetMultimap.newMultimap();
unifiedSetMultimap.put(key, value);
return unifiedSetMultimap;
}

public <K, V> MutableSetMultimap<K, V> of(K key1, V value1, K key2, V value2)
{
return this.with(key1, value1, key2, value2);
}

public <K, V> MutableSetMultimap<K, V> with(K key1, V value1, K key2, V value2)
{
UnifiedSetMultimap<K, V> unifiedSetMultimap = UnifiedSetMultimap.newMultimap();
Expand All @@ -294,6 +409,11 @@ public <K, V> MutableSetMultimap<K, V> with(K key1, V value1, K key2, V value2)
return unifiedSetMultimap;
}

public <K, V> MutableSetMultimap<K, V> of(K key1, V value1, K key2, V value2, K key3, V value3)
{
return this.with(key1, value1, key2, value2, key3, value3);
}

public <K, V> MutableSetMultimap<K, V> with(K key1, V value1, K key2, V value2, K key3, V value3)
{
UnifiedSetMultimap<K, V> unifiedSetMultimap = UnifiedSetMultimap.newMultimap();
Expand All @@ -310,18 +430,33 @@ private MutableSortedSetMultimapFactory()
{
}

public <K, V> MutableSortedSetMultimap<K, V> of(Comparator<V> comparator)
{
return this.with(comparator);
}

public <K, V> MutableSortedSetMultimap<K, V> with(Comparator<V> comparator)
{
return TreeSortedSetMultimap.newMultimap(comparator);
}

public <K, V> MutableSortedSetMultimap<K, V> of(Comparator<V> comparator, K key, V value)
{
return this.with(comparator, key, value);
}

public <K, V> MutableSortedSetMultimap<K, V> with(Comparator<V> comparator, K key, V value)
{
TreeSortedSetMultimap<K, V> treeSortedSetMultimap = TreeSortedSetMultimap.newMultimap(comparator);
treeSortedSetMultimap.put(key, value);
return treeSortedSetMultimap;
}

public <K, V> MutableSortedSetMultimap<K, V> of(Comparator<V> comparator, K key1, V value1, K key2, V value2)
{
return this.with(comparator, key1, value1, key2, value2);
}

public <K, V> MutableSortedSetMultimap<K, V> with(Comparator<V> comparator, K key1, V value1, K key2, V value2)
{
TreeSortedSetMultimap<K, V> treeSortedSetMultimap = TreeSortedSetMultimap.newMultimap(comparator);
Expand All @@ -330,6 +465,11 @@ public <K, V> MutableSortedSetMultimap<K, V> with(Comparator<V> comparator, K ke
return treeSortedSetMultimap;
}

public <K, V> MutableSortedSetMultimap<K, V> of(Comparator<V> comparator, K key1, V value1, K key2, V value2, K key3, V value3)
{
return this.with(comparator, key1, value1, key2, value2, key3, value3);
}

public <K, V> MutableSortedSetMultimap<K, V> with(Comparator<V> comparator, K key1, V value1, K key2, V value2, K key3, V value3)
{
TreeSortedSetMultimap<K, V> treeSortedSetMultimap = TreeSortedSetMultimap.newMultimap(comparator);
Expand All @@ -351,18 +491,33 @@ public <K, V> MutableBagMultimap<K, V> empty()
return HashBagMultimap.newMultimap();
}

public <K, V> MutableBagMultimap<K, V> of()
{
return this.empty();
}

public <K, V> MutableBagMultimap<K, V> with()
{
return this.empty();
}

public <K, V> MutableBagMultimap<K, V> of(K key, V value)
{
return this.with(key, value);
}

public <K, V> MutableBagMultimap<K, V> with(K key, V value)
{
HashBagMultimap<K, V> hashBagMultimap = HashBagMultimap.newMultimap();
hashBagMultimap.put(key, value);
return hashBagMultimap;
}

public <K, V> MutableBagMultimap<K, V> of(K key1, V value1, K key2, V value2)
{
return this.with(key1, value1, key2, value2);
}

public <K, V> MutableBagMultimap<K, V> with(K key1, V value1, K key2, V value2)
{
HashBagMultimap<K, V> hashBagMultimap = HashBagMultimap.newMultimap();
Expand All @@ -371,6 +526,11 @@ public <K, V> MutableBagMultimap<K, V> with(K key1, V value1, K key2, V value2)
return hashBagMultimap;
}

public <K, V> MutableBagMultimap<K, V> of(K key1, V value1, K key2, V value2, K key3, V value3)
{
return this.with(key1, value1, key2, value2, key3, value3);
}

public <K, V> MutableBagMultimap<K, V> with(K key1, V value1, K key2, V value2, K key3, V value3)
{
HashBagMultimap<K, V> hashBagMultimap = HashBagMultimap.newMultimap();
Expand Down
Loading

0 comments on commit 9182f3f

Please sign in to comment.