1 |
|
/* |
2 |
|
* Written by Doug Lea with assistance from members of JCP JSR-166 |
3 |
|
* Expert Group and released to the public domain, as explained at |
4 |
< |
* http://creativecommons.org/licenses/publicdomain |
4 |
> |
* http://creativecommons.org/publicdomain/zero/1.0/ |
5 |
|
*/ |
6 |
|
|
7 |
|
package extra166y; |
236 |
|
* simple. The most common usage is to construct a new object |
237 |
|
* serving as an initial mapped value. |
238 |
|
* |
239 |
< |
* @param key the (nonnull) key |
239 |
> |
* @param key the (non-null) key |
240 |
|
* @return a value, or null if none |
241 |
|
*/ |
242 |
|
V map(K key); |
1069 |
|
/** |
1070 |
|
* If the specified key is not already associated with a value, |
1071 |
|
* computes its value using the given mappingFunction, and if |
1072 |
< |
* nonnull, enters it into the map. This is equivalent to |
1072 |
> |
* non-null, enters it into the map. This is equivalent to |
1073 |
|
* |
1074 |
|
* <pre> |
1075 |
|
* if (map.containsKey(key)) |
1414 |
|
if (!(o instanceof Map.Entry)) |
1415 |
|
return false; |
1416 |
|
Map.Entry<?,?> e = (Map.Entry<?,?>)o; |
1417 |
< |
return CustomConcurrentHashMap.this.remove(e.getKey(), e.getValue()); |
1417 |
> |
return CustomConcurrentHashMap.this.remove(e.getKey(), |
1418 |
> |
e.getValue()); |
1419 |
|
} |
1420 |
|
public int size() { |
1421 |
|
return CustomConcurrentHashMap.this.size(); |
1551 |
|
} |
1552 |
|
|
1553 |
|
/** |
1554 |
< |
* Save the state of the instance to a stream (i.e., serialize |
1555 |
< |
* it). |
1554 |
> |
* Saves the state of the instance to a stream (i.e., serializes it). |
1555 |
> |
* |
1556 |
|
* @param s the stream |
1557 |
|
* @serialData |
1558 |
|
* the key (Object) and value (Object) |
1570 |
|
} |
1571 |
|
|
1572 |
|
/** |
1573 |
< |
* Reconstitute the instance from a stream (i.e., deserialize it). |
1573 |
> |
* Reconstitutes the instance from a stream (that is, deserializes it). |
1574 |
|
* @param s the stream |
1575 |
|
*/ |
1576 |
|
private void readObject(java.io.ObjectInputStream s) |
2115 |
|
|
2116 |
|
static abstract class WeakKeySelfValueNode |
2117 |
|
extends WeakKeyNode { |
2118 |
< |
WeakKeySelfValueNode(int locator, Object key, CustomConcurrentHashMap cchm) { |
2118 |
> |
WeakKeySelfValueNode(int locator, Object key, |
2119 |
> |
CustomConcurrentHashMap cchm) { |
2120 |
|
super(locator, key, cchm); |
2121 |
|
} |
2122 |
|
public final Object getValue() { return get(); } |
2136 |
|
static final class LinkedWeakKeySelfValueNode |
2137 |
|
extends WeakKeySelfValueNode { |
2138 |
|
volatile Node linkage; |
2139 |
< |
LinkedWeakKeySelfValueNode(int locator, Object key, CustomConcurrentHashMap cchm, |
2139 |
> |
LinkedWeakKeySelfValueNode(int locator, Object key, |
2140 |
> |
CustomConcurrentHashMap cchm, |
2141 |
|
Node linkage) { |
2142 |
|
super(locator, key, cchm); |
2143 |
|
this.linkage = linkage; |
2166 |
|
static abstract class WeakKeyStrongValueNode |
2167 |
|
extends WeakKeyNode { |
2168 |
|
volatile Object value; |
2169 |
< |
WeakKeyStrongValueNode(int locator, Object key, Object value, CustomConcurrentHashMap cchm) { |
2169 |
> |
WeakKeyStrongValueNode(int locator, Object key, Object value, |
2170 |
> |
CustomConcurrentHashMap cchm) { |
2171 |
|
super(locator, key, cchm); |
2172 |
|
this.value = value; |
2173 |
|
} |
2178 |
|
static final class TerminalWeakKeyStrongValueNode |
2179 |
|
extends WeakKeyStrongValueNode { |
2180 |
|
TerminalWeakKeyStrongValueNode(int locator, |
2181 |
< |
Object key, Object value, CustomConcurrentHashMap cchm) { |
2181 |
> |
Object key, Object value, |
2182 |
> |
CustomConcurrentHashMap cchm) { |
2183 |
|
super(locator, key, value, cchm); |
2184 |
|
} |
2185 |
|
public final Node getLinkage() { return null; } |
2190 |
|
extends WeakKeyStrongValueNode { |
2191 |
|
volatile Node linkage; |
2192 |
|
LinkedWeakKeyStrongValueNode(int locator, |
2193 |
< |
Object key, Object value, CustomConcurrentHashMap cchm, |
2193 |
> |
Object key, Object value, |
2194 |
> |
CustomConcurrentHashMap cchm, |
2195 |
|
Node linkage) { |
2196 |
|
super(locator, key, value, cchm); |
2197 |
|
this.linkage = linkage; |
2416 |
|
|
2417 |
|
static abstract class SoftKeySelfValueNode |
2418 |
|
extends SoftKeyNode { |
2419 |
< |
SoftKeySelfValueNode(int locator, Object key, CustomConcurrentHashMap cchm) { |
2419 |
> |
SoftKeySelfValueNode(int locator, Object key, |
2420 |
> |
CustomConcurrentHashMap cchm) { |
2421 |
|
super(locator, key, cchm); |
2422 |
|
} |
2423 |
|
public final Object getValue() { return get(); } |
2426 |
|
|
2427 |
|
static final class TerminalSoftKeySelfValueNode |
2428 |
|
extends SoftKeySelfValueNode { |
2429 |
< |
TerminalSoftKeySelfValueNode(int locator, Object key, CustomConcurrentHashMap cchm) { |
2429 |
> |
TerminalSoftKeySelfValueNode(int locator, Object key, |
2430 |
> |
CustomConcurrentHashMap cchm) { |
2431 |
|
super(locator, key, cchm); |
2432 |
|
} |
2433 |
|
public final Node getLinkage() { return null; } |
2437 |
|
static final class LinkedSoftKeySelfValueNode |
2438 |
|
extends SoftKeySelfValueNode { |
2439 |
|
volatile Node linkage; |
2440 |
< |
LinkedSoftKeySelfValueNode(int locator, Object key, CustomConcurrentHashMap cchm, |
2440 |
> |
LinkedSoftKeySelfValueNode(int locator, Object key, |
2441 |
> |
CustomConcurrentHashMap cchm, |
2442 |
|
Node linkage) { |
2443 |
|
super(locator, key, cchm); |
2444 |
|
this.linkage = linkage; |
2467 |
|
static abstract class SoftKeyStrongValueNode |
2468 |
|
extends SoftKeyNode { |
2469 |
|
volatile Object value; |
2470 |
< |
SoftKeyStrongValueNode(int locator, Object key, Object value, CustomConcurrentHashMap cchm) { |
2470 |
> |
SoftKeyStrongValueNode(int locator, Object key, Object value, |
2471 |
> |
CustomConcurrentHashMap cchm) { |
2472 |
|
super(locator, key, cchm); |
2473 |
|
this.value = value; |
2474 |
|
} |
2479 |
|
static final class TerminalSoftKeyStrongValueNode |
2480 |
|
extends SoftKeyStrongValueNode { |
2481 |
|
TerminalSoftKeyStrongValueNode(int locator, |
2482 |
< |
Object key, Object value, CustomConcurrentHashMap cchm) { |
2482 |
> |
Object key, Object value, |
2483 |
> |
CustomConcurrentHashMap cchm) { |
2484 |
|
super(locator, key, value, cchm); |
2485 |
|
} |
2486 |
|
public final Node getLinkage() { return null; } |
2491 |
|
extends SoftKeyStrongValueNode { |
2492 |
|
volatile Node linkage; |
2493 |
|
LinkedSoftKeyStrongValueNode(int locator, |
2494 |
< |
Object key, Object value, CustomConcurrentHashMap cchm, |
2494 |
> |
Object key, Object value, |
2495 |
> |
CustomConcurrentHashMap cchm, |
2496 |
|
Node linkage) { |
2497 |
|
super(locator, key, value, cchm); |
2498 |
|
this.linkage = linkage; |
3045 |
|
} |
3046 |
|
|
3047 |
|
// Fenced store into segment table array. Unneeded when we have Fences |
3048 |
< |
static final void storeNode(Node[] table, |
3049 |
< |
int i, Node r) { |
3048 |
> |
static final void storeNode(Node[] table, |
3049 |
> |
int i, Node r) { |
3050 |
|
long nodeOffset = ((long) i << tableShift) + tableBase; |
3051 |
|
UNSAFE.putOrderedObject(table, nodeOffset, r); |
3052 |
|
} |
3053 |
|
|
3054 |
< |
static final void storeSegment(Segment[] segs, |
3055 |
< |
int i, Segment s) { |
3054 |
> |
static final void storeSegment(Segment[] segs, |
3055 |
> |
int i, Segment s) { |
3056 |
|
long segmentOffset = ((long) i << segmentsShift) + segmentsBase; |
3057 |
|
UNSAFE.putOrderedObject(segs, segmentOffset, s); |
3058 |
|
} |