336 lines
9.9 KiB
Java
336 lines
9.9 KiB
Java
package org.warp.commonutils.type;
|
|
|
|
import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
|
|
import it.unimi.dsi.fastutil.objects.Object2ObjectMaps;
|
|
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
|
|
import it.unimi.dsi.fastutil.objects.ObjectIterator;
|
|
import java.lang.reflect.Array;
|
|
import java.util.Collections;
|
|
import java.util.ConcurrentModificationException;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.NoSuchElementException;
|
|
import java.util.function.BiConsumer;
|
|
import java.util.function.IntFunction;
|
|
import java.util.stream.Stream;
|
|
import org.jetbrains.annotations.NotNull;
|
|
|
|
public interface UnmodifiableMap<K, V> extends UnmodifiableIterableMap<K, V> {
|
|
|
|
/**
|
|
* Returns {@code true} if this map contains a mapping for the specified
|
|
* key. More formally, returns {@code true} if and only if
|
|
* this map contains a mapping for a key {@code k} such that
|
|
* {@code Objects.equals(key, k)}. (There can be
|
|
* at most one such mapping.)
|
|
*
|
|
* @param key key whose presence in this map is to be tested
|
|
* @return {@code true} if this map contains a mapping for the specified
|
|
* key
|
|
* @throws ClassCastException if the key is of an inappropriate type for
|
|
* this map
|
|
* (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
|
|
* @throws NullPointerException if the specified key is null and this map
|
|
* does not permit null keys
|
|
* (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
|
|
*/
|
|
boolean containsKey(Object key);
|
|
|
|
/**
|
|
* Returns the value to which the specified key is mapped,
|
|
* or {@code null} if this map contains no mapping for the key.
|
|
*
|
|
* <p>More formally, if this map contains a mapping from a key
|
|
* {@code k} to a value {@code v} such that
|
|
* {@code Objects.equals(key, k)},
|
|
* then this method returns {@code v}; otherwise
|
|
* it returns {@code null}. (There can be at most one such mapping.)
|
|
*
|
|
* <p>If this map permits null values, then a return value of
|
|
* {@code null} does not <i>necessarily</i> indicate that the map
|
|
* contains no mapping for the key; it's also possible that the map
|
|
* explicitly maps the key to {@code null}. The {@link #containsKey
|
|
* containsKey} operation may be used to distinguish these two cases.
|
|
*
|
|
* @param key the key whose associated value is to be returned
|
|
* @return the value to which the specified key is mapped, or
|
|
* {@code null} if this map contains no mapping for the key
|
|
* @throws ClassCastException if the key is of an inappropriate type for
|
|
* this map
|
|
* (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
|
|
* @throws NullPointerException if the specified key is null and this map
|
|
* does not permit null keys
|
|
* (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
|
|
*/
|
|
V get(Object key);
|
|
|
|
/**
|
|
* Returns the value to which the specified key is mapped, or
|
|
* {@code defaultValue} if this map contains no mapping for the key.
|
|
*
|
|
* @implSpec
|
|
* The default implementation makes no guarantees about synchronization
|
|
* or atomicity properties of this method. Any implementation providing
|
|
* atomicity guarantees must override this method and document its
|
|
* concurrency properties.
|
|
*
|
|
* @param key the key whose associated value is to be returned
|
|
* @param defaultValue the default mapping of the key
|
|
* @return the value to which the specified key is mapped, or
|
|
* {@code defaultValue} if this map contains no mapping for the key
|
|
* @throws ClassCastException if the key is of an inappropriate type for
|
|
* this map
|
|
* (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
|
|
* @throws NullPointerException if the specified key is null and this map
|
|
* does not permit null keys
|
|
* (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
|
|
* @since 1.8
|
|
*/
|
|
default V getOrDefault(Object key, V defaultValue) {
|
|
V v;
|
|
return (((v = get(key)) != null) || containsKey(key))
|
|
? v
|
|
: defaultValue;
|
|
}
|
|
|
|
@NotNull
|
|
ObjectIterator<Object2ObjectMap.Entry<K, V>> fastIterator();
|
|
|
|
/**
|
|
* Performs the given action for each entry in this map until all entries
|
|
* have been processed or the action throws an exception. Unless
|
|
* otherwise specified by the implementing class, actions are performed in
|
|
* the order of entry set iteration (if an iteration order is specified.)
|
|
* Exceptions thrown by the action are relayed to the caller.
|
|
*
|
|
* @implSpec
|
|
* The default implementation is equivalent to, for this {@code map}:
|
|
* <pre> {@code
|
|
* for (Map.Entry<K, V> entry : map.entrySet())
|
|
* action.accept(entry.getKey(), entry.getValue());
|
|
* }</pre>
|
|
*
|
|
* The default implementation makes no guarantees about synchronization
|
|
* or atomicity properties of this method. Any implementation providing
|
|
* atomicity guarantees must override this method and document its
|
|
* concurrency properties.
|
|
*
|
|
* @param action The action to be performed for each entry
|
|
* @throws NullPointerException if the specified action is null
|
|
* @throws ConcurrentModificationException if an entry is found to be
|
|
* removed during iteration
|
|
* @since 1.8
|
|
*/
|
|
void forEach(BiConsumer<? super K, ? super V> action);
|
|
|
|
static <K, V> UnmodifiableMap<K, V> of(K[] keys, V[] values) {
|
|
int keysSize = (keys != null) ? keys.length : 0;
|
|
int valuesSize = (values != null) ? values.length : 0;
|
|
|
|
if (keysSize == 0 && valuesSize == 0) {
|
|
// return mutable map
|
|
return new EmptyUnmodifiableMap<>();
|
|
}
|
|
|
|
return new MappedUnmodifiableMap<>(new Object2ObjectOpenHashMap<>(keys, values, 1.0f));
|
|
}
|
|
|
|
static <K, V> UnmodifiableMap<K, V> of(Map<K, V> map) {
|
|
return new MappedUnmodifiableMap<K, V>(map);
|
|
}
|
|
|
|
@SuppressWarnings("SuspiciousSystemArraycopy")
|
|
static <K, V> UnmodifiableMap<K, V> ofObjects(Object[] keys, Object[] values) {
|
|
if (keys == null || values == null || (keys.length == 0 && values.length == 0)) {
|
|
return UnmodifiableMap.of(null, null);
|
|
} else if (keys.length == values.length) {
|
|
//noinspection unchecked
|
|
K[] keysArray = (K[]) Array.newInstance(keys[0].getClass(), keys.length);
|
|
System.arraycopy(keys, 0, keysArray, 0, keys.length);
|
|
//noinspection unchecked
|
|
V[] valuesArray = (V[]) Array.newInstance(values[0].getClass(), keys.length);
|
|
System.arraycopy(values, 0, valuesArray, 0, values.length);
|
|
return UnmodifiableMap.of(keysArray, valuesArray);
|
|
} else {
|
|
throw new IllegalArgumentException("The number of keys doesn't match the number of values.");
|
|
}
|
|
}
|
|
|
|
class EmptyUnmodifiableMap<K, V> implements UnmodifiableMap<K, V> {
|
|
|
|
private EmptyUnmodifiableMap() {}
|
|
|
|
@Override
|
|
public int size() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean containsKey(Object key) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public V get(Object key) {
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public void forEach(BiConsumer<? super K, ? super V> action) {
|
|
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public Iterator<Entry<K, V>> iterator() {
|
|
return new Iterator<>() {
|
|
@Override
|
|
public boolean hasNext() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public Entry<K, V> next() {
|
|
throw new NoSuchElementException();
|
|
}
|
|
};
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public ObjectIterator<Object2ObjectMap.Entry<K, V>> fastIterator() {
|
|
return new ObjectIterator<>() {
|
|
@Override
|
|
public boolean hasNext() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public Object2ObjectMap.Entry<K, V> next() {
|
|
throw new NoSuchElementException();
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public Map<K, V> toUnmodifiableMap() {
|
|
//noinspection unchecked
|
|
return Object2ObjectMaps.EMPTY_MAP;
|
|
}
|
|
|
|
@Override
|
|
public Stream<Entry<K, V>> stream() {
|
|
return Stream.empty();
|
|
}
|
|
|
|
@Override
|
|
public UnmodifiableIterableSet<K> toUnmodifiableIterableKeysSet(IntFunction<K[]> generator) {
|
|
return UnmodifiableIterableSet.of(null);
|
|
}
|
|
}
|
|
|
|
class MappedUnmodifiableMap<K, V> implements UnmodifiableMap<K, V> {
|
|
|
|
private final Map<K,V> map;
|
|
|
|
private MappedUnmodifiableMap(@NotNull Map<K, V> map) {
|
|
this.map = map;
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return map.size();
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return map.isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public boolean containsKey(Object key) {
|
|
return map.containsKey(key);
|
|
}
|
|
|
|
@Override
|
|
public V get(Object key) {
|
|
return map.get(key);
|
|
}
|
|
|
|
@Override
|
|
public void forEach(BiConsumer<? super K, ? super V> action) {
|
|
map.forEach(action);
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public Iterator<Entry<K, V>> iterator() {
|
|
return map.entrySet().iterator();
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public ObjectIterator<Object2ObjectMap.Entry<K, V>> fastIterator() {
|
|
if (map instanceof Object2ObjectMap) {
|
|
return Object2ObjectMaps.fastIterator((Object2ObjectMap<K, V>) map);
|
|
} else {
|
|
var iterator = map.entrySet().iterator();
|
|
var reusableEntry = new Object2ObjectMap.Entry<K, V>() {
|
|
private K key;
|
|
private V val;
|
|
@Override
|
|
public K getKey() {
|
|
return key;
|
|
}
|
|
|
|
@Override
|
|
public V getValue() {
|
|
return val;
|
|
}
|
|
|
|
@Override
|
|
public V setValue(V value) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
};
|
|
return new ObjectIterator<>() {
|
|
|
|
@Override
|
|
public boolean hasNext() {
|
|
return iterator.hasNext();
|
|
}
|
|
|
|
@Override
|
|
public Object2ObjectMap.Entry<K, V> next() {
|
|
var next = iterator.next();
|
|
reusableEntry.key = next.getKey();
|
|
reusableEntry.val = next.getValue();
|
|
return reusableEntry;
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Map<K, V> toUnmodifiableMap() {
|
|
return Collections.unmodifiableMap(map);
|
|
}
|
|
|
|
@Override
|
|
public Stream<Entry<K, V>> stream() {
|
|
return map.entrySet().stream();
|
|
}
|
|
|
|
@Override
|
|
public UnmodifiableIterableSet<K> toUnmodifiableIterableKeysSet(IntFunction<K[]> generator) {
|
|
return UnmodifiableIterableSet.of(map.keySet().toArray(generator));
|
|
}
|
|
}
|
|
}
|