mirror of
https://github.com/pgpainless/pgpainless.git
synced 2024-12-22 10:57:58 +01:00
Kotlin conversion: MultiMap
Warning: This commit changes the semantics of MultiMap.put() put() now replaces values, while plus() adds them.
This commit is contained in:
parent
b324742a62
commit
841b386226
GPG key ID:
62BEE9264BF17311
6 changed files with 147 additions and 177 deletions
|
|
@ -1,137 +0,0 @@
|
|||
// SPDX-FileCopyrightText: 2018 Paul Schaub <vanitasvitae@fsfe.org>
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package org.pgpainless.util;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
public class MultiMap<K, V> {
|
||||
|
||||
private final Map<K, Set<V>> map;
|
||||
|
||||
public MultiMap() {
|
||||
map = new HashMap<>();
|
||||
}
|
||||
|
||||
public MultiMap(@Nonnull MultiMap<K, V> other) {
|
||||
this.map = new HashMap<>();
|
||||
for (K k : other.map.keySet()) {
|
||||
map.put(k, new LinkedHashSet<>(other.map.get(k)));
|
||||
}
|
||||
}
|
||||
|
||||
public MultiMap(@Nonnull Map<K, Set<V>> content) {
|
||||
this.map = new HashMap<>(content);
|
||||
}
|
||||
|
||||
public int size() {
|
||||
return map.size();
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return map.isEmpty();
|
||||
}
|
||||
|
||||
public boolean containsKey(K o) {
|
||||
return map.containsKey(o);
|
||||
}
|
||||
|
||||
public boolean containsValue(V o) {
|
||||
for (Set<V> values : map.values()) {
|
||||
if (values.contains(o)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public Set<V> get(K o) {
|
||||
return map.get(o);
|
||||
}
|
||||
|
||||
public void put(K k, V v) {
|
||||
Set<V> values = map.get(k);
|
||||
if (values == null) {
|
||||
values = new LinkedHashSet<>();
|
||||
map.put(k, values);
|
||||
}
|
||||
values.add(v);
|
||||
}
|
||||
|
||||
public void put(K k, Set<V> vs) {
|
||||
for (V v : vs) {
|
||||
put(k, v);
|
||||
}
|
||||
}
|
||||
|
||||
public void removeAll(K o) {
|
||||
map.remove(o);
|
||||
}
|
||||
|
||||
public void remove(K o, V v) {
|
||||
Set<V> vs = map.get(o);
|
||||
if (vs == null) return;
|
||||
vs.remove(v);
|
||||
}
|
||||
|
||||
public void putAll(MultiMap<K, V> other) {
|
||||
for (K key : other.keySet()) {
|
||||
put(key, other.get(key));
|
||||
}
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
map.clear();
|
||||
}
|
||||
|
||||
public Set<K> keySet() {
|
||||
return map.keySet();
|
||||
}
|
||||
|
||||
public Collection<Set<V>> values() {
|
||||
return map.values();
|
||||
}
|
||||
|
||||
public Set<Map.Entry<K, Set<V>>> entrySet() {
|
||||
return map.entrySet();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return all values of the {@link MultiMap} in a single {@link LinkedHashSet}.
|
||||
*
|
||||
* @return set of all values
|
||||
*/
|
||||
public Set<V> flatten() {
|
||||
LinkedHashSet<V> flattened = new LinkedHashSet<>();
|
||||
for (Set<V> items : map.values()) {
|
||||
flattened.addAll(items);
|
||||
}
|
||||
return flattened;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (o == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!(o instanceof MultiMap)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return map.equals(((MultiMap<?, ?>) o).map);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return map.hashCode();
|
||||
}
|
||||
}
|
||||
|
|
@ -7,6 +7,7 @@ package org.pgpainless.util.selection.keyring;
|
|||
import javax.annotation.Nonnull;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import org.bouncycastle.openpgp.PGPPublicKeyRing;
|
||||
|
|
@ -33,9 +34,9 @@ public abstract class PublicKeyRingSelectionStrategy<O> implements KeyRingSelect
|
|||
@Override
|
||||
public MultiMap<O, PGPPublicKeyRing> selectKeyRingsFromCollections(@Nonnull MultiMap<O, PGPPublicKeyRingCollection> keyRingCollections) {
|
||||
MultiMap<O, PGPPublicKeyRing> keyRings = new MultiMap<>();
|
||||
for (O identifier : keyRingCollections.keySet()) {
|
||||
for (PGPPublicKeyRingCollection collection : keyRingCollections.get(identifier)) {
|
||||
keyRings.put(identifier, selectKeyRingsFromCollection(identifier, collection));
|
||||
for (Map.Entry<O, Set<PGPPublicKeyRingCollection>> entry : keyRingCollections.entrySet()) {
|
||||
for (PGPPublicKeyRingCollection collection : entry.getValue()) {
|
||||
keyRings.plus(entry.getKey(), selectKeyRingsFromCollection(entry.getKey(), collection));
|
||||
}
|
||||
}
|
||||
return keyRings;
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ package org.pgpainless.util.selection.keyring;
|
|||
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import javax.annotation.Nonnull;
|
||||
|
||||
|
|
@ -32,9 +33,9 @@ public abstract class SecretKeyRingSelectionStrategy<O> implements KeyRingSelect
|
|||
@Override
|
||||
public MultiMap<O, PGPSecretKeyRing> selectKeyRingsFromCollections(@Nonnull MultiMap<O, PGPSecretKeyRingCollection> keyRingCollections) {
|
||||
MultiMap<O, PGPSecretKeyRing> keyRings = new MultiMap<>();
|
||||
for (O identifier : keyRingCollections.keySet()) {
|
||||
for (PGPSecretKeyRingCollection collection : keyRingCollections.get(identifier)) {
|
||||
keyRings.put(identifier, selectKeyRingsFromCollection(identifier, collection));
|
||||
for (Map.Entry<O, Set<PGPSecretKeyRingCollection>> entry : keyRingCollections.entrySet()) {
|
||||
for (PGPSecretKeyRingCollection collection : entry.getValue()) {
|
||||
keyRings.plus(entry.getKey(), selectKeyRingsFromCollection(entry.getKey(), collection));
|
||||
}
|
||||
}
|
||||
return keyRings;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,75 @@
|
|||
// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package org.pgpainless.util
|
||||
|
||||
class MultiMap<K, V> : Iterable<Map.Entry<K, Set<V>>> {
|
||||
|
||||
private val map: Map<K, MutableSet<V>>
|
||||
|
||||
constructor(): this(mutableMapOf())
|
||||
constructor(other: MultiMap<K, V>): this(other.map)
|
||||
constructor(content: Map<K, Set<V>>) {
|
||||
map = mutableMapOf()
|
||||
content.forEach {
|
||||
map[it.key] = it.value.toMutableSet()
|
||||
}
|
||||
}
|
||||
|
||||
override fun iterator(): Iterator<Map.Entry<K, Set<V>>> {
|
||||
return map.iterator()
|
||||
}
|
||||
|
||||
val size: Int
|
||||
get() = map.size
|
||||
fun size() = size
|
||||
val keys: Set<K>
|
||||
get() = map.keys
|
||||
fun keySet() = keys
|
||||
val values: Collection<Set<V>>
|
||||
get() = map.values
|
||||
fun values() = values
|
||||
val entries: Set<Map.Entry<K, Set<V>>>
|
||||
get() = map.entries
|
||||
fun entrySet() = entries
|
||||
fun isEmpty(): Boolean = map.isEmpty()
|
||||
fun containsKey(key: K): Boolean = map.containsKey(key)
|
||||
fun containsValue(value: V): Boolean = map.values.any { it.contains(value) }
|
||||
fun contains(key: K, value: V): Boolean = map[key]?.contains(value) ?: false
|
||||
operator fun get(key: K): Set<V>? = map[key]
|
||||
fun put(key: K, value: V) =
|
||||
(map as MutableMap).put(key, mutableSetOf(value))
|
||||
fun plus(key: K, value: V) =
|
||||
(map as MutableMap).getOrPut(key) { mutableSetOf() }.add(value)
|
||||
fun put(key: K, values: Set<V>) =
|
||||
(map as MutableMap).put(key, values.toMutableSet())
|
||||
fun plus(key: K, values: Set<V>) =
|
||||
(map as MutableMap).getOrPut(key) { mutableSetOf() }.addAll(values)
|
||||
fun putAll(other: MultiMap<K, V>) = other.map.entries.forEach {
|
||||
put(it.key, it.value)
|
||||
}
|
||||
fun plusAll(other: MultiMap<K, V>) = other.map.entries.forEach {
|
||||
plus(it.key, it.value)
|
||||
}
|
||||
fun removeAll(key: K) = (map as MutableMap).remove(key)
|
||||
fun remove(key: K, value: V) = (map as MutableMap)[key]?.remove(value)
|
||||
fun clear() = (map as MutableMap).clear()
|
||||
fun flatten() = map.flatMap { it.value }.toSet()
|
||||
|
||||
override fun equals(other: Any?): Boolean {
|
||||
return if (other == null)
|
||||
false
|
||||
else if (other !is MultiMap<*, *>)
|
||||
false
|
||||
else if (this === other) {
|
||||
true
|
||||
} else {
|
||||
map == other.map
|
||||
}
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
return map.hashCode()
|
||||
}
|
||||
}
|
||||
|
|
@ -41,7 +41,37 @@ public class MultiMapTest {
|
|||
assertTrue(multiMap.containsKey("alice"));
|
||||
assertTrue(multiMap.containsValue("wonderland"));
|
||||
assertNotNull(multiMap.get("alice"));
|
||||
assertTrue(multiMap.get("alice").contains("wonderland"));
|
||||
assertTrue(multiMap.contains("alice", "wonderland"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void putOverwritesExistingElements() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("alice", "wonderland");
|
||||
map.put("alice", "whothefrickisalice");
|
||||
assertFalse(map.containsValue("wonderland"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void plusDoesNotOverwriteButAdd() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("alice", "wonderland");
|
||||
map.plus("alice", "whothefrickisalice");
|
||||
assertTrue(map.containsValue("wonderland"));
|
||||
assertTrue(map.containsValue("whothefrickisalice"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void containsWorks() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("alice", "wonderland");
|
||||
map.plus("alice", "bar");
|
||||
map.put("bob", "builder");
|
||||
|
||||
assertTrue(map.contains("alice", "wonderland"));
|
||||
assertTrue(map.contains("alice", "bar"));
|
||||
assertTrue(map.contains("bob", "builder"));
|
||||
assertFalse(map.contains("bob", "bar"));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -104,7 +134,7 @@ public class MultiMapTest {
|
|||
@Test
|
||||
public void emptyAfterClear() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("test", "foo");
|
||||
map.plus("test", "foo");
|
||||
assertFalse(map.isEmpty());
|
||||
map.clear();
|
||||
assertTrue(map.isEmpty());
|
||||
|
|
@ -113,8 +143,8 @@ public class MultiMapTest {
|
|||
@Test
|
||||
public void addTwoRemoveOneWorks() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("alice", "wonderland");
|
||||
map.put("bob", "builder");
|
||||
map.plus("alice", "wonderland");
|
||||
map.plus("bob", "builder");
|
||||
map.removeAll("alice");
|
||||
|
||||
assertFalse(map.containsKey("alice"));
|
||||
|
|
@ -125,11 +155,11 @@ public class MultiMapTest {
|
|||
@Test
|
||||
public void addMultiValue() {
|
||||
MultiMap<String, String> addOneByOne = new MultiMap<>();
|
||||
addOneByOne.put("foo", "bar");
|
||||
addOneByOne.put("foo", "baz");
|
||||
addOneByOne.plus("foo", "bar");
|
||||
addOneByOne.plus("foo", "baz");
|
||||
|
||||
MultiMap<String, String> addOnce = new MultiMap<>();
|
||||
addOnce.put("foo", new HashSet<>(Arrays.asList("baz", "bar")));
|
||||
addOnce.plus("foo", new HashSet<>(Arrays.asList("baz", "bar")));
|
||||
|
||||
assertEquals(addOneByOne, addOnce);
|
||||
}
|
||||
|
|
@ -138,7 +168,7 @@ public class MultiMapTest {
|
|||
public void addMultiValueRemoveSingle() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("foo", "bar");
|
||||
map.put("foo", "baz");
|
||||
map.plus("foo", "baz");
|
||||
|
||||
map.remove("foo", "bar");
|
||||
assertFalse(map.isEmpty());
|
||||
|
|
@ -149,9 +179,9 @@ public class MultiMapTest {
|
|||
@Test
|
||||
public void addMultiValueRemoveAll() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("foo", "bar");
|
||||
map.put("foo", "baz");
|
||||
map.put("bingo", "bango");
|
||||
map.plus("foo", "bar");
|
||||
map.plus("foo", "baz");
|
||||
map.plus("bingo", "bango");
|
||||
|
||||
map.removeAll("foo");
|
||||
assertFalse(map.isEmpty());
|
||||
|
|
@ -160,23 +190,23 @@ public class MultiMapTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void putAll() {
|
||||
public void plusAll() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("A", "1");
|
||||
map.put("A", "2");
|
||||
map.put("B", "1");
|
||||
map.plus("A", "1");
|
||||
map.plus("A", "2");
|
||||
map.plus("B", "1");
|
||||
|
||||
MultiMap<String, String> other = new MultiMap<>();
|
||||
other.put("A", "1");
|
||||
other.put("B", "2");
|
||||
other.put("C", "3");
|
||||
other.plus("A", "1");
|
||||
other.plus("B", "2");
|
||||
other.plus("C", "3");
|
||||
|
||||
map.putAll(other);
|
||||
assertTrue(map.get("A").contains("1"));
|
||||
assertTrue(map.get("A").contains("2"));
|
||||
assertTrue(map.get("B").contains("1"));
|
||||
assertTrue(map.get("B").contains("2"));
|
||||
assertTrue(map.get("C").contains("3"));
|
||||
map.plusAll(other);
|
||||
assertTrue(map.contains("A", "1"));
|
||||
assertTrue(map.contains("A", "2"));
|
||||
assertTrue(map.contains("B", "1"));
|
||||
assertTrue(map.contains("B", "2"));
|
||||
assertTrue(map.contains("C", "3"));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -188,9 +218,9 @@ public class MultiMapTest {
|
|||
@Test
|
||||
public void flattenMap() {
|
||||
MultiMap<String, String> map = new MultiMap<>();
|
||||
map.put("A", "1");
|
||||
map.put("A", "2");
|
||||
map.put("B", "1");
|
||||
map.plus("A", "1");
|
||||
map.plus("A", "2");
|
||||
map.plus("B", "1");
|
||||
|
||||
Set<String> expected = new LinkedHashSet<>();
|
||||
expected.add("1");
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
package org.pgpainless.util.selection.keyring;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
|
|
@ -19,8 +19,8 @@ import org.bouncycastle.openpgp.PGPSecretKeyRing;
|
|||
import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.pgpainless.key.TestKeys;
|
||||
import org.pgpainless.util.selection.keyring.impl.ExactUserId;
|
||||
import org.pgpainless.util.MultiMap;
|
||||
import org.pgpainless.util.selection.keyring.impl.ExactUserId;
|
||||
|
||||
public class KeyRingsFromCollectionTest {
|
||||
|
||||
|
|
@ -52,7 +52,7 @@ public class KeyRingsFromCollectionTest {
|
|||
MultiMap<String, PGPSecretKeyRing> selected = strategy.selectKeyRingsFromCollections(map);
|
||||
assertEquals(1, selected.get(TestKeys.JULIET_UID).size());
|
||||
assertEquals(1, selected.get(TestKeys.EMIL_UID).size());
|
||||
assertNull(selected.get("invalidId"));
|
||||
assertTrue(selected.get("invalidId").isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -73,16 +73,16 @@ public class KeyRingsFromCollectionTest {
|
|||
PGPPublicKeyRing juliet = TestKeys.getJulietPublicKeyRing();
|
||||
MultiMap<String, PGPPublicKeyRingCollection> map = new MultiMap<>();
|
||||
PGPPublicKeyRingCollection julietCollection = new PGPPublicKeyRingCollection(Arrays.asList(emil, juliet));
|
||||
map.put(TestKeys.JULIET_UID, julietCollection);
|
||||
map.plus(TestKeys.JULIET_UID, julietCollection);
|
||||
PGPPublicKeyRingCollection emilCollection = new PGPPublicKeyRingCollection(Collections.singletonList(emil));
|
||||
map.put(TestKeys.EMIL_UID, emilCollection);
|
||||
map.plus(TestKeys.EMIL_UID, emilCollection);
|
||||
assertEquals(2, julietCollection.size());
|
||||
map.put("invalidId", emilCollection);
|
||||
map.plus("invalidId", emilCollection);
|
||||
|
||||
PublicKeyRingSelectionStrategy<String> strategy = new ExactUserId.PubRingSelectionStrategy();
|
||||
MultiMap<String, PGPPublicKeyRing> selected = strategy.selectKeyRingsFromCollections(map);
|
||||
assertEquals(1, selected.get(TestKeys.JULIET_UID).size());
|
||||
assertEquals(1, selected.get(TestKeys.EMIL_UID).size());
|
||||
assertNull(selected.get("invalidId"));
|
||||
assertTrue(selected.get("invalidId").isEmpty());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue