org.asteriskjava.lock.LockableMap Maven / Gradle / Ivy
Show all versions of asterisk-java Show documentation
package org.asteriskjava.lock;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
public class LockableMap extends Lockable implements Map {
final Map map;
public LockableMap(Map map) {
if (map instanceof Lockable) {
throw new RuntimeException("map is already lockable");
}
this.map = map;
}
public int size() {
return map.size();
}
public boolean isEmpty() {
return map.isEmpty();
}
public boolean containsKey(Object key) {
return map.containsKey(key);
}
public boolean containsValue(Object value) {
return map.containsValue(value);
}
public P get(Object key) {
return map.get(key);
}
public P put(S key, P value) {
return map.put(key, value);
}
public P remove(Object key) {
return map.remove(key);
}
public void putAll(Map m) {
map.putAll(m);
}
public void clear() {
map.clear();
}
public Set keySet() {
return map.keySet();
}
public Collection values() {
return map.values();
}
public Set> entrySet() {
return map.entrySet();
}
public boolean equals(Object o) {
return map.equals(o);
}
public int hashCode() {
return map.hashCode();
}
public P getOrDefault(Object key, P defaultValue) {
return map.getOrDefault(key, defaultValue);
}
public void forEach(BiConsumer action) {
map.forEach(action);
}
public void replaceAll(BiFunction function) {
map.replaceAll(function);
}
public P putIfAbsent(S key, P value) {
return map.putIfAbsent(key, value);
}
public boolean remove(Object key, Object value) {
return map.remove(key, value);
}
public boolean replace(S key, P oldValue, P newValue) {
return map.replace(key, oldValue, newValue);
}
public P replace(S key, P value) {
return map.replace(key, value);
}
public P computeIfAbsent(S key, Function mappingFunction) {
return map.computeIfAbsent(key, mappingFunction);
}
public P computeIfPresent(S key, BiFunction remappingFunction) {
return map.computeIfPresent(key, remappingFunction);
}
public P compute(S key, BiFunction remappingFunction) {
return map.compute(key, remappingFunction);
}
public P merge(S key, P value, BiFunction remappingFunction) {
return map.merge(key, value, remappingFunction);
}
}