V put(K key, int hash, V value, boolean onlyIfAbsent) {
lock();
try {
int c = count;
HashEntry[] tab = table;
int index = hash & (tab.length - 1);
HashEntry<K, V> first = (HashEntry<K, V>) tab[index];
for (HashEntry<K, V> e = first; e != null; e = (HashEntry<K, V>) e.next) {
if (e.hash == hash && key.equals(e.key)) {
V oldValue = e.value;
if (!onlyIfAbsent) e.value = value;
++modCount;
count = c; // write-volatile
return oldValue;
}
}
tab[index] = new HashEntry<K, V>(hash, key, value, first);
++modCount;
++c;
count = c; // write-volatile
if (c > threshold) setTable(rehash(tab));
return null;
} finally {
unlock();
}
}
boolean replace(K key, int hash, V oldValue, V newValue) {
lock();
try {
int c = count;
HashEntry[] tab = table;
int index = hash & (tab.length - 1);
HashEntry<K, V> first = (HashEntry<K, V>) tab[index];
HashEntry<K, V> e = first;
for (; ; ) {
if (e == null) return false;
if (e.hash == hash && key.equals(e.key)) break;
e = e.next;
}
V v = e.value;
if (v == null || !oldValue.equals(v)) return false;
e.value = newValue;
count = c; // write-volatile
return true;
} finally {
unlock();
}
}
public int lastIndexOfSecond(K k, int index) {
try {
for (int i = index; i >= 0; i--) {
if ((k == null ? get(i).second == null : k.equals(get(i).second))) return i;
}
} catch (final Exception e) {
}
return -1;
}
public synchronized boolean removeSecond(K k) {
Quint<T, K, L, M, N> pair;
for (final Iterator<Quint<T, K, L, M, N>> i = iterator(); i.hasNext(); ) {
pair = i.next();
if ((k == null ? pair.second == null : k.equals(pair.second))) {
i.remove();
return true;
}
}
return false;
}
public boolean containsSecond(K k) {
for (final Iterator<Quint<T, K, L, M, N>> i = iterator(); i.hasNext(); ) {
if ((k == null) ? i.next() == null : k.equals(i.next().second)) return true;
}
return false;
}
/**
* Gets registered object from CacheMap. The algorithm used to look up is <br>
* 1. First check for exact match with clazz and context.<br>
* 2. If didn't find, look for interfaces that clazz implements using the exact context.<br>
* 3. If still didn't find, look for super class of clazz using the exact context. <br>
* 4. If still didn't find, using the exact clazz with default context.<br>
* 5. If still didn't find, return null.<br>
* If found a match in step 1, 2, 3 or 4, it will return the registered object immediately.
*
* @param clazz the class which is used as the primary key.
* @param context the context which is used as the secondary key. This parameter could be null in
* which case the default context is used.
* @return registered object the object associated with the class and the context.
*/
public T getRegisteredObject(Class<?> clazz, K context) {
if (clazz == null) {
return null;
}
Cache<K, T> cache = getCache(clazz);
if (cache == null || !cache.containsKey(context)) {
List<Class<?>> classesToSearch = new ArrayList<>();
classesToSearch.add(clazz);
if (TypeUtils.isPrimitive(clazz)) {
classesToSearch.add(TypeUtils.convertPrimitiveToWrapperType(clazz));
} else if (TypeUtils.isPrimitiveWrapper(clazz)) {
classesToSearch.add(TypeUtils.convertWrapperToPrimitiveType(clazz));
}
// Direct super interfaces, recursively
addAllInterfaces(classesToSearch, clazz);
Class<?> superClass = clazz;
// Direct super class, recursively
while (!superClass.isInterface()) {
superClass = superClass.getSuperclass();
if (superClass != null) {
classesToSearch.add(superClass);
addAllInterfaces(classesToSearch, superClass);
} else {
break;
}
}
if (!classesToSearch.contains(Object.class)) {
classesToSearch.add(Object.class); // use Object as default fallback.
}
// search to match context first
for (Class<?> c : classesToSearch) {
Cache<K, T> cacheForClass = getCache(c);
if (cacheForClass != null) {
T object = cacheForClass.getObject(context);
if (object != null) {
return object;
}
}
}
// fall back to default context
if (!_defaultContext.equals(context)) {
for (Class<?> c : classesToSearch) {
Cache<K, T> cacheForClass = getCache(c);
if (cacheForClass != null) {
T object = cacheForClass.getObject(_defaultContext);
if (object != null) {
return object;
}
}
}
}
}
if (cache != null) {
T object = cache.getObject(context);
if (object == null && !_defaultContext.equals(context)) {
return getRegisteredObject(clazz, _defaultContext);
}
if (object != null) {
return object;
}
}
return null;
}
boolean equals(K key, K key2) {
return csKey ? equalsCS((CharSequence) key, (CharSequence) key2) : key.equals(key2);
}