MultiMap.java
/**
*
* Copyright © 2015-2021 Florian Schmaus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smack.util;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* A lightweight implementation of a MultiMap, that is a Map that is able to hold multiple values for every key.
* <p>
* This MultiMap uses a {@link LinkedHashMap} together with a {@link ArrayList} in order to keep the order of its entries.
* </p>
*
* @param <K> the type of the keys the map uses.
* @param <V> the type of the values the map uses.
*/
public class MultiMap<K, V> {
/**
* The constant value {@value}.
*/
public static final int DEFAULT_MAP_SIZE = 6;
private static final int ENTRY_LIST_SIZE = 3;
private final Map<K, List<V>> map;
/**
* Constructs a new MultiMap with a initial capacity of {@link #DEFAULT_MAP_SIZE}.
*/
public MultiMap() {
this(DEFAULT_MAP_SIZE);
}
/**
* Constructs a new MultiMap.
*
* @param size the initial capacity.
*/
public MultiMap(int size) {
this(new LinkedHashMap<>(size));
}
private MultiMap(Map<K, List<V>> map) {
this.map = map;
}
public int size() {
int size = 0;
for (List<V> list : map.values()) {
size += list.size();
}
return size;
}
public boolean isEmpty() {
return map.isEmpty();
}
public boolean containsKey(K key) {
return map.containsKey(key);
}
public boolean containsValue(V value) {
for (List<V> list : map.values()) {
if (list.contains(value)) {
return true;
}
}
return false;
}
/**
* Get the first value for the given key, or <code>null</code> if there are no entries.
*
* @param key TODO javadoc me please
* @return the first value or null.
*/
public V getFirst(K key) {
List<V> res = getAll(key);
if (res.isEmpty()) {
return null;
} else {
return res.iterator().next();
}
}
/**
* Get all values for the given key. Returns the empty set if there are none.
* <p>
* Changes to the returned set will update the underlying MultiMap if the return set is not empty.
* </p>
*
* @param key TODO javadoc me please
* @return all values for the given key.
*/
public List<V> getAll(K key) {
List<V> res = map.get(key);
if (res == null) {
res = Collections.emptyList();
}
return res;
}
public boolean put(K key, V value) {
return putInternal(key, list -> list.add(value));
}
public boolean putFirst(K key, V value) {
return putInternal(key, list -> list.add(0, value));
}
private boolean putInternal(K key, Consumer<List<V>> valueListConsumer) {
boolean keyExisted;
List<V> list = map.get(key);
if (list == null) {
list = new ArrayList<>(ENTRY_LIST_SIZE);
map.put(key, list);
keyExisted = false;
} else {
keyExisted = true;
}
valueListConsumer.accept(list);
return keyExisted;
}
/**
* Removes all mappings for the given key and returns the first value if there where mappings or <code>null</code> if not.
*
* @param key TODO javadoc me please
* @return the first value of the given key or null.
*/
public V remove(K key) {
List<V> res = map.remove(key);
if (res == null) {
return null;
}
assert !res.isEmpty();
return res.iterator().next();
}
/**
* Remove the mapping of the given key to the value.
* <p>
* Returns <code>true</code> if the mapping was removed and <code>false</code> if the mapping did not exist.
* </p>
*
* @param key TODO javadoc me please
* @param value TODO javadoc me please
* @return true if the mapping was removed, false otherwise.
*/
public boolean removeOne(K key, V value) {
List<V> list = map.get(key);
if (list == null) {
return false;
}
boolean res = list.remove(value);
if (list.isEmpty()) {
// Remove the key also if the value set is now empty
map.remove(key);
}
return res;
}
/**
* Remove the given number of values for a given key. May return less values then requested.
*
* @param key the key to remove from.
* @param num the number of values to remove.
* @return a list of the removed values.
* @since 4.4.0
*/
public List<V> remove(K key, int num) {
List<V> values = map.get(key);
if (values == null) {
return Collections.emptyList();
}
final int resultSize = values.size() > num ? num : values.size();
final List<V> result = new ArrayList<>(resultSize);
for (int i = 0; i < resultSize; i++) {
result.add(values.get(0));
}
if (values.isEmpty()) {
map.remove(key);
}
return result;
}
public void putAll(Map<? extends K, ? extends V> map) {
for (Map.Entry<? extends K, ? extends V> entry : map.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
public void clear() {
map.clear();
}
public Set<K> keySet() {
return map.keySet();
}
/**
* Returns a new list containing all values of this multi map.
*
* @return a new list with all values.
*/
public List<V> values() {
List<V> values = new ArrayList<>(size());
for (List<V> list : map.values()) {
values.addAll(list);
}
return values;
}
public Set<Map.Entry<K, V>> entrySet() {
Set<Map.Entry<K, V>> entrySet = new LinkedHashSet<>(size());
for (Map.Entry<K, List<V>> entries : map.entrySet()) {
K key = entries.getKey();
for (V value : entries.getValue()) {
entrySet.add(new SimpleMapEntry<>(key, value));
}
}
return entrySet;
}
public MultiMap<K, V> asUnmodifiableMultiMap() {
LinkedHashMap<K, List<V>> mapCopy = new LinkedHashMap<>(map.size());
for (Map.Entry<K, List<V>> entry : map.entrySet()) {
K key = entry.getKey();
List<V> values = entry.getValue();
mapCopy.put(key, Collections.unmodifiableList(values));
}
return new MultiMap<K, V>(Collections.unmodifiableMap(mapCopy));
}
@Override
public MultiMap<K, V> clone() {
Map<K, List<V>> clonedMap = new LinkedHashMap<>(map.size());
// TODO: Use Map.forEach() once Smack's minimum Android API is 24 or higher.
for (Map.Entry<K, List<V>> entry : map.entrySet()) {
List<V> clonedList = CollectionUtil.newListWith(entry.getValue());
clonedMap.put(entry.getKey(), clonedList);
}
return new MultiMap<>(clonedMap);
}
private static final class SimpleMapEntry<K, V> implements Map.Entry<K, V> {
private final K key;
private V value;
private SimpleMapEntry(K key, V value) {
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public V setValue(V value) {
V tmp = this.value;
this.value = value;
return tmp;
}
}
}