org.codehaus.groovy.util.AbstractConcurrentMap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of groovy-all Show documentation
Show all versions of groovy-all Show documentation
Groovy: A powerful, dynamic language for the JVM
package org.codehaus.groovy.util;
public abstract class AbstractConcurrentMap extends AbstractConcurrentMapBase {
public AbstractConcurrentMap(Object segmentInfo) {
super(segmentInfo);
}
public Segment segmentFor (int hash) {
return (Segment) super.segmentFor(hash);
}
public V get(K key) {
int hash = hash(key);
return (V) segmentFor(hash).get(key, hash);
}
public Entry getOrPut(K key, V value) {
int hash = hash(key);
return segmentFor(hash).getOrPut(key, hash, value);
}
public void put(K key, V value) {
int hash = hash(key);
segmentFor(hash).put(key, hash, value);
}
public void remove(K key) {
int hash = hash(key);
segmentFor(hash).remove(key, hash);
}
protected abstract static class Segment extends AbstractConcurrentMapBase.Segment {
protected Segment(int initialCapacity) {
super(initialCapacity);
}
V get(K key, int hash) {
Object[] tab = table;
Object o = tab[hash & (tab.length - 1)];
if (o != null) {
if (o instanceof Entry) {
Entry e = (Entry) o;
if (e.isEqual(key, hash)) {
return e.getValue();
}
}
else {
Object arr [] = (Object[]) o;
for (int i = 0; i < arr.length; i++) {
Entry e = (Entry) arr[i];
if (e != null && e.isEqual(key, hash)) {
return e.getValue();
}
}
}
}
return null;
}
Entry getOrPut(K key, int hash, V value) {
Object[] tab = table;
Object o = tab[hash & (tab.length - 1)];
if (o != null) {
if (o instanceof Entry) {
Entry e = (Entry) o;
if (e.isEqual(key, hash)) {
return e;
}
}
else {
Object arr [] = (Object[]) o;
for (int i = 0; i < arr.length; i++) {
Entry e = (Entry) arr[i];
if (e != null && e.isEqual(key, hash)) {
return e;
}
}
}
}
return put(key, hash, value);
}
Entry put(K key, int hash, V value) {
lock();
try {
int c = count;
if (c++ > threshold) {
rehash();
}
Object[] tab = table;
int index = hash & (tab.length - 1);
Object o = tab[index];
if (o != null) {
if (o instanceof Entry) {
Entry e = (Entry) o;
if (e.isEqual(key, hash)) {
e.setValue(value);
return e;
}
else {
Object arr [] = new Object [2];
final Entry ee = createEntry(key, hash, value);
arr [0] = ee;
arr [1] = e;
tab[index] = arr;
count = c;
return ee;
}
}
else {
Object arr [] = (Object[]) o;
for (int i = 0; i < arr.length; i++) {
Entry e = (Entry) arr[i];
if (e != null && e.isEqual(key, hash)) {
e.setValue(value);
return e;
}
}
final Entry ee = createEntry(key, hash, value);
for (int i = 0; i < arr.length; i++) {
Entry e = (Entry) arr[i];
if (e == null) {
arr [i] = ee;
count = c;
return ee;
}
}
Object newArr [] = new Object[arr.length+1];
newArr [0] = ee;
System.arraycopy(arr, 0, newArr, 1, arr.length);
tab [index] = newArr;
count = c;
return ee;
}
}
Entry e = createEntry(key, hash, value);
tab[index] = e;
count = c; // write-volatile
return e;
} finally {
unlock();
}
}
public void remove(K key, int hash) {
lock();
try {
int c = count-1;
final Object[] tab = table;
final int index = hash & (tab.length - 1);
Object o = tab[index];
if (o != null) {
if (o instanceof Entry) {
if (((Entry)o).isEqual(key, hash)) {
tab[index] = null;
count = c;
}
}
else {
Object arr [] = (Object[]) o;
for (int i = 0; i < arr.length; i++) {
Entry e = (Entry) arr[i];
if (e != null && e.isEqual(key, hash)) {
arr [i] = null;
count = c;
break;
}
}
}
}
}
finally {
unlock();
}
}
protected abstract Entry createEntry(K key, int hash, V value);
}
protected static interface Entry extends AbstractConcurrentMapBase.Entry{
boolean isEqual(K key, int hash);
}
}