Fixed - BiHashMap usage removed.

pull/6166/head
Nikita Koksharov
parent 583ba95d9b
commit 4c502283c2

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -154,3 +149,101 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -51,10 +51,6 @@ import java.util.concurrent.TimeUnit;
*/
public final class Redisson implements RedissonClient {
static {
RedissonReference.warmUp();
}
private final EvictionScheduler evictionScheduler;
private final WriteBehindService writeBehindService;
private final ConnectionManager connectionManager;

@ -15,11 +15,12 @@
*/
package org.redisson;
import org.redisson.api.*;
import org.redisson.api.RObject;
import org.redisson.api.RObjectReactive;
import org.redisson.api.RObjectRx;
import org.redisson.api.annotation.REntity;
import org.redisson.client.codec.Codec;
import org.redisson.liveobject.misc.ClassUtils;
import org.redisson.misc.BiHashMap;
import java.io.Serializable;
@ -32,47 +33,6 @@ public class RedissonReference implements Serializable {
private static final long serialVersionUID = -2378564460151709127L;
private static final BiHashMap<String, String> REACTIVE_MAP = new BiHashMap<>();
private static final BiHashMap<String, String> RXJAVA_MAP = new BiHashMap<>();
static {
REACTIVE_MAP.put(RAtomicLongReactive.class.getName(), RAtomicLong.class.getName());
REACTIVE_MAP.put(RBitSetReactive.class.getName(), RBitSet.class.getName());
REACTIVE_MAP.put(RBlockingQueueReactive.class.getName(), RBlockingQueue.class.getName());
REACTIVE_MAP.put(RBucketReactive.class.getName(), RBucket.class.getName());
REACTIVE_MAP.put(RDequeReactive.class.getName(), RDeque.class.getName());
REACTIVE_MAP.put(RHyperLogLogReactive.class.getName(), RHyperLogLog.class.getName());
REACTIVE_MAP.put(RLexSortedSetReactive.class.getName(), RLexSortedSet.class.getName());
REACTIVE_MAP.put(RListReactive.class.getName(), RList.class.getName());
REACTIVE_MAP.put(RMapCacheReactive.class.getName(), RMapCache.class.getName());
REACTIVE_MAP.put(RMapReactive.class.getName(), RMap.class.getName());
REACTIVE_MAP.put(RQueueReactive.class.getName(), RQueue.class.getName());
REACTIVE_MAP.put(RScoredSortedSetReactive.class.getName(), RScoredSortedSet.class.getName());
REACTIVE_MAP.put(RSetCacheReactive.class.getName(), RSetCache.class.getName());
REACTIVE_MAP.put(RSetReactive.class.getName(), RSet.class.getName());
REACTIVE_MAP.makeImmutable();
RXJAVA_MAP.put(RAtomicLongRx.class.getName(), RAtomicLong.class.getName());
RXJAVA_MAP.put(RBitSetRx.class.getName(), RBitSet.class.getName());
RXJAVA_MAP.put(RBlockingQueueRx.class.getName(), RBlockingQueue.class.getName());
RXJAVA_MAP.put(RBucketRx.class.getName(), RBucket.class.getName());
RXJAVA_MAP.put(RDequeRx.class.getName(), RDeque.class.getName());
RXJAVA_MAP.put(RHyperLogLogRx.class.getName(), RHyperLogLog.class.getName());
RXJAVA_MAP.put(RLexSortedSetRx.class.getName(), RLexSortedSet.class.getName());
RXJAVA_MAP.put(RListRx.class.getName(), RList.class.getName());
RXJAVA_MAP.put(RMapCacheRx.class.getName(), RMapCache.class.getName());
RXJAVA_MAP.put(RMapRx.class.getName(), RMap.class.getName());
RXJAVA_MAP.put(RQueueRx.class.getName(), RQueue.class.getName());
RXJAVA_MAP.put(RScoredSortedSetRx.class.getName(), RScoredSortedSet.class.getName());
RXJAVA_MAP.put(RSetCacheRx.class.getName(), RSetCache.class.getName());
RXJAVA_MAP.put(RSetRx.class.getName(), RSet.class.getName());
RXJAVA_MAP.makeImmutable();
}
public static void warmUp() {}
public enum ReferenceType {RXJAVA, REACTIVE, DEFAULT}
private String type;
@ -94,15 +54,17 @@ public class RedissonReference implements Serializable {
throw new IllegalArgumentException("Class reference has to be a type of either RObject/RLiveObject/RObjectReactive/RObjectRx");
}
if (RObjectReactive.class.isAssignableFrom(type)) {
this.type = REACTIVE_MAP.get(type.getName());
if (this.type == null) {
throw new IllegalArgumentException("There is no Reactive compatible type for " + type);
String t = type.getName().replaceFirst("Reactive", "");
if (!isAvailable(t)) {
throw new IllegalArgumentException("There is no compatible type for " + type);
}
this.type = t;
} else if (RObjectRx.class.isAssignableFrom(type)) {
this.type = RXJAVA_MAP.get(type.getName());
if (this.type == null) {
throw new IllegalArgumentException("There is no RxJava compatible type for " + type);
String t = type.getName().replaceFirst("Rx", "");
if (!isAvailable(t)) {
throw new IllegalArgumentException("There is no compatible type for " + type);
}
this.type = t;
} else {
this.type = type.getName();
}
@ -121,8 +83,9 @@ public class RedissonReference implements Serializable {
}
public Class<?> getRxJavaType() throws ClassNotFoundException {
if (RXJAVA_MAP.containsValue(type)) {
return Class.forName(RXJAVA_MAP.reverseGet(type)); //live object is not supported in reactive client
String rxName = type + "Rx";
if (isAvailable(rxName)) {
return Class.forName(rxName); //live object is not supported in reactive client
}
throw new ClassNotFoundException("There is no RxJava compatible type for " + type);
}
@ -132,8 +95,9 @@ public class RedissonReference implements Serializable {
* @throws java.lang.ClassNotFoundException - if the class cannot be located
*/
public Class<?> getReactiveType() throws ClassNotFoundException {
if (REACTIVE_MAP.containsValue(type)) {
return Class.forName(REACTIVE_MAP.reverseGet(type)); //live object is not supported in reactive client
String reactiveName = type + "Reactive";
if (isAvailable(reactiveName)) {
return Class.forName(reactiveName); //live object is not supported in reactive client
}
throw new ClassNotFoundException("There is no Reactive compatible type for " + type);
}
@ -173,4 +137,13 @@ public class RedissonReference implements Serializable {
}
return null;
}
private boolean isAvailable(String type) {
try {
Class.forName(type);
return true;
} catch (ClassNotFoundException e) {
return false;
}
}
}

@ -1,127 +0,0 @@
/**
* Copyright (c) 2013-2024 Nikita Koksharov
*
* 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.redisson.misc;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* This is not a concurrent map.
*
* @author Rui Gu (https://github.com/jackygurui)
* @param <K> key
* @param <V> value
*/
public class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

@ -6,13 +6,8 @@ import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;
import org.redisson.misc.BiHashMap;
/**
*
@ -166,3 +161,102 @@ public class ClusterRunner {
}
}
}
class BiHashMap<K, V> implements Map<K, V> {
private Map<K, V> keyValueMap = new HashMap<K, V>();
private Map<V, K> valueKeyMap = new HashMap<V, K>();
@Override
public int size() {
return keyValueMap.size();
}
@Override
public boolean isEmpty() {
return keyValueMap.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return keyValueMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return valueKeyMap.containsKey(value);
}
@Override
public V get(Object key) {
return keyValueMap.get(key);
}
public K reverseGet(Object key) {
return valueKeyMap.get(key);
}
@Override
public V put(K key, V value) {
if (keyValueMap.containsKey(key)) {
valueKeyMap.remove(keyValueMap.get(key));
}
valueKeyMap.put(value, key);
return keyValueMap.put(key, value);
}
@Override
public V remove(Object key) {
V removed = keyValueMap.remove(key);
if (removed != null) {
valueKeyMap.remove(removed);
}
return removed;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
@Override
public void clear() {
keyValueMap.clear();
valueKeyMap.clear();
}
@Override
public Set<K> keySet() {
return keyValueMap.keySet();
}
public Set<V> valueSet() {
return valueKeyMap.keySet();
}
@Override
public Collection<V> values() {
return keyValueMap.values();
}
public Collection<K> keys() {
return valueKeyMap.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return keyValueMap.entrySet();
}
public Set<Entry<V, K>> reverseEntrySet() {
return valueKeyMap.entrySet();
}
public void makeImmutable() {
keyValueMap = Collections.unmodifiableMap(keyValueMap);
valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
}
}

Loading…
Cancel
Save