diff --git a/core/src/main/java/hudson/util/CopyOnWriteHashMap.java b/core/src/main/java/hudson/util/CopyOnWriteMap.java
similarity index 56%
rename from core/src/main/java/hudson/util/CopyOnWriteHashMap.java
rename to core/src/main/java/hudson/util/CopyOnWriteMap.java
index 7f21f10cf4..a412313780 100644
--- a/core/src/main/java/hudson/util/CopyOnWriteHashMap.java
+++ b/core/src/main/java/hudson/util/CopyOnWriteMap.java
@@ -2,12 +2,14 @@ package hudson.util;
import java.util.Collection;
import java.util.Collections;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
+import java.util.TreeMap;
/**
- * {@link Map} that has copy-on-write semantics, backed by {@link HashMap}.
+ * {@link Map} that has copy-on-write semantics.
*
*
* This class is suitable where highly concurrent access is needed, yet
@@ -15,18 +17,18 @@ import java.util.Set;
*
* @author Kohsuke Kawaguchi
*/
-public class CopyOnWriteHashMap implements Map {
- private volatile Map core;
+public abstract class CopyOnWriteMap implements Map {
+ protected volatile Map core;
/**
* Read-only view of {@link #core}.
*/
private volatile Map view;
- public CopyOnWriteHashMap(Map core) {
- update(new HashMap(core));
+ protected CopyOnWriteMap(Map core) {
+ update(core);
}
- public CopyOnWriteHashMap() {
+ protected CopyOnWriteMap() {
update(Collections.emptyMap());
}
@@ -56,7 +58,7 @@ public class CopyOnWriteHashMap implements Map {
}
public synchronized V put(K key, V value) {
- Map m = new HashMap(core);
+ Map m = copy();
V r = m.put(key,value);
update(m);
@@ -64,7 +66,7 @@ public class CopyOnWriteHashMap implements Map {
}
public synchronized V remove(Object key) {
- Map m = new HashMap(core);
+ Map m = copy();
V r = m.remove(key);
update(m);
@@ -72,11 +74,13 @@ public class CopyOnWriteHashMap implements Map {
}
public synchronized void putAll(Map extends K, ? extends V> t) {
- Map m = new HashMap(core);
+ Map m = copy();
m.putAll(t);
update(m);
}
+ protected abstract Map copy();
+
public synchronized void clear() {
update(Collections.emptyMap());
}
@@ -101,4 +105,46 @@ public class CopyOnWriteHashMap implements Map {
public Set> entrySet() {
return view.entrySet();
}
+
+ /**
+ * {@link CopyOnWriteMap} backed by {@link HashMap}.
+ */
+ public static final class Hash extends CopyOnWriteMap {
+ public Hash(Map core) {
+ super(new HashMap(core));
+ }
+
+ public Hash() {
+ }
+
+ protected Map copy() {
+ return new HashMap(core);
+ }
+ }
+
+ /**
+ * {@link CopyOnWriteMap} backed by {@link TreeMap}.
+ */
+ public static final class Tree extends CopyOnWriteMap {
+ private final Comparator comparator;
+
+ public Tree(Map core, Comparator comparator) {
+ this(comparator);
+ putAll(core);
+ }
+
+ public Tree(Comparator comparator) {
+ this.comparator = comparator;
+ }
+
+ public Tree() {
+ this(null);
+ }
+
+ protected Map copy() {
+ TreeMap m = new TreeMap(comparator);
+ m.putAll(core);
+ return m;
+ }
+ }
}