ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/extra166y/CustomConcurrentHashMap.java

Comparing jsr166/src/extra166y/CustomConcurrentHashMap.java (file contents):
Revision 1.26 by jsr166, Wed Jan 16 00:51:11 2013 UTC vs.
Revision 1.27 by jsr166, Fri Jan 18 04:23:27 2013 UTC

#	Line 1793 | Line 1793 | public class CustomConcurrentHashMap<K,
1793
1794		// Strong Keys
1795
1796	<	static abstract class StrongKeyNode implements Node {
1796	>	abstract static class StrongKeyNode implements Node {
1797		final Object key;
1798		final int locator;
1799		StrongKeyNode(int locator, Object key) {
#	Line 1805 | Line 1805 | public class CustomConcurrentHashMap<K,
1805		}
1806
1807
1808	<	static abstract class StrongKeySelfValueNode
1808	>	abstract static class StrongKeySelfValueNode
1809		extends StrongKeyNode {
1810		StrongKeySelfValueNode(int locator, Object key) {
1811		super(locator, key);
#	Line 1852 | Line 1852 | public class CustomConcurrentHashMap<K,
1852		}
1853		}
1854
1855	<	static abstract class StrongKeyStrongValueNode
1855	>	abstract static class StrongKeyStrongValueNode
1856		extends StrongKeyNode {
1857		volatile Object value;
1858		StrongKeyStrongValueNode(int locator, Object key, Object value) {
#	Line 1905 | Line 1905 | public class CustomConcurrentHashMap<K,
1905
1906		// ...
1907
1908	<	static abstract class StrongKeyIntValueNode
1908	>	abstract static class StrongKeyIntValueNode
1909		extends StrongKeyNode {
1910		volatile int value;
1911		StrongKeyIntValueNode(int locator, Object key, Object value) {
#	Line 1960 | Line 1960 | public class CustomConcurrentHashMap<K,
1960
1961		// ...
1962
1963	<	static abstract class StrongKeyWeakValueNode
1963	>	abstract static class StrongKeyWeakValueNode
1964		extends StrongKeyNode {
1965		volatile EmbeddedWeakReference valueRef;
1966		final CustomConcurrentHashMap cchm;
#	Line 2028 | Line 2028 | public class CustomConcurrentHashMap<K,
2028		}
2029
2030
2031	<	static abstract class StrongKeySoftValueNode
2031	>	abstract static class StrongKeySoftValueNode
2032		extends StrongKeyNode {
2033		volatile EmbeddedSoftReference valueRef;
2034		final CustomConcurrentHashMap cchm;
#	Line 2097 | Line 2097 | public class CustomConcurrentHashMap<K,
2097
2098		// Weak keys
2099
2100	<	static abstract class WeakKeyNode extends WeakReference
2100	>	abstract static class WeakKeyNode extends WeakReference
2101		implements Node {
2102		final int locator;
2103		final CustomConcurrentHashMap cchm;
#	Line 2113 | Line 2113 | public class CustomConcurrentHashMap<K,
2113		}
2114		}
2115
2116	<	static abstract class WeakKeySelfValueNode
2116	>	abstract static class WeakKeySelfValueNode
2117		extends WeakKeyNode {
2118		WeakKeySelfValueNode(int locator, Object key,
2119		CustomConcurrentHashMap cchm) {
#	Line 2163 | Line 2163 | public class CustomConcurrentHashMap<K,
2163		}
2164
2165
2166	<	static abstract class WeakKeyStrongValueNode
2166	>	abstract static class WeakKeyStrongValueNode
2167		extends WeakKeyNode {
2168		volatile Object value;
2169		WeakKeyStrongValueNode(int locator, Object key, Object value,
#	Line 2216 | Line 2216 | public class CustomConcurrentHashMap<K,
2216		}
2217		}
2218
2219	<	static abstract class WeakKeyIntValueNode
2219	>	abstract static class WeakKeyIntValueNode
2220		extends WeakKeyNode {
2221		volatile int value;
2222		WeakKeyIntValueNode(int locator, Object key, Object value,
#	Line 2271 | Line 2271 | public class CustomConcurrentHashMap<K,
2271		}
2272		}
2273
2274	<	static abstract class WeakKeyWeakValueNode
2274	>	abstract static class WeakKeyWeakValueNode
2275		extends WeakKeyNode {
2276		volatile EmbeddedWeakReference valueRef;
2277		WeakKeyWeakValueNode(int locator, Object key, Object value,
#	Line 2334 | Line 2334 | public class CustomConcurrentHashMap<K,
2334		}
2335
2336
2337	<	static abstract class WeakKeySoftValueNode
2337	>	abstract static class WeakKeySoftValueNode
2338		extends WeakKeyNode {
2339		volatile EmbeddedSoftReference valueRef;
2340		WeakKeySoftValueNode(int locator, Object key, Object value,
#	Line 2398 | Line 2398 | public class CustomConcurrentHashMap<K,
2398
2399		// Soft keys
2400
2401	<	static abstract class SoftKeyNode extends SoftReference
2401	>	abstract static class SoftKeyNode extends SoftReference
2402		implements Node {
2403		final int locator;
2404		final CustomConcurrentHashMap cchm;
#	Line 2414 | Line 2414 | public class CustomConcurrentHashMap<K,
2414		}
2415		}
2416
2417	<	static abstract class SoftKeySelfValueNode
2417	>	abstract static class SoftKeySelfValueNode
2418		extends SoftKeyNode {
2419		SoftKeySelfValueNode(int locator, Object key,
2420		CustomConcurrentHashMap cchm) {
#	Line 2464 | Line 2464 | public class CustomConcurrentHashMap<K,
2464		}
2465
2466
2467	<	static abstract class SoftKeyStrongValueNode
2467	>	abstract static class SoftKeyStrongValueNode
2468		extends SoftKeyNode {
2469		volatile Object value;
2470		SoftKeyStrongValueNode(int locator, Object key, Object value,
#	Line 2517 | Line 2517 | public class CustomConcurrentHashMap<K,
2517		}
2518		}
2519
2520	<	static abstract class SoftKeyIntValueNode
2520	>	abstract static class SoftKeyIntValueNode
2521		extends SoftKeyNode {
2522		volatile int value;
2523		SoftKeyIntValueNode(int locator, Object key, Object value,
#	Line 2572 | Line 2572 | public class CustomConcurrentHashMap<K,
2572		}
2573		}
2574
2575	<	static abstract class SoftKeyWeakValueNode
2575	>	abstract static class SoftKeyWeakValueNode
2576		extends SoftKeyNode {
2577		volatile EmbeddedWeakReference valueRef;
2578		SoftKeyWeakValueNode(int locator, Object key, Object value,
#	Line 2635 | Line 2635 | public class CustomConcurrentHashMap<K,
2635		}
2636
2637
2638	<	static abstract class SoftKeySoftValueNode
2638	>	abstract static class SoftKeySoftValueNode
2639		extends SoftKeyNode {
2640		volatile EmbeddedSoftReference valueRef;
2641		SoftKeySoftValueNode(int locator, Object key, Object value,
#	Line 2697 | Line 2697 | public class CustomConcurrentHashMap<K,
2697		}
2698		}
2699
2700	<	static abstract class IntKeyNode implements Node {
2700	>	abstract static class IntKeyNode implements Node {
2701		final int key;
2702		IntKeyNode(int locator, Object key) {
2703		this.key = ((Integer)key).intValue();
#	Line 2707 | Line 2707 | public class CustomConcurrentHashMap<K,
2707		}
2708
2709
2710	<	static abstract class IntKeySelfValueNode
2710	>	abstract static class IntKeySelfValueNode
2711		extends IntKeyNode {
2712		IntKeySelfValueNode(int locator, Object key) {
2713		super(locator, key);
#	Line 2754 | Line 2754 | public class CustomConcurrentHashMap<K,
2754		}
2755		}
2756
2757	<	static abstract class IntKeyStrongValueNode
2757	>	abstract static class IntKeyStrongValueNode
2758		extends IntKeyNode {
2759		volatile Object value;
2760		IntKeyStrongValueNode(int locator, Object key, Object value) {
#	Line 2805 | Line 2805 | public class CustomConcurrentHashMap<K,
2805		}
2806		}
2807
2808	<	static abstract class IntKeyIntValueNode
2808	>	abstract static class IntKeyIntValueNode
2809		extends IntKeyNode {
2810		volatile int value;
2811		IntKeyIntValueNode(int locator, Object key, Object value) {
#	Line 2858 | Line 2858 | public class CustomConcurrentHashMap<K,
2858		}
2859		}
2860
2861	<	static abstract class IntKeyWeakValueNode
2861	>	abstract static class IntKeyWeakValueNode
2862		extends IntKeyNode {
2863		volatile EmbeddedWeakReference valueRef;
2864		final CustomConcurrentHashMap cchm;
#	Line 2926 | Line 2926 | public class CustomConcurrentHashMap<K,
2926		}
2927
2928
2929	<	static abstract class IntKeySoftValueNode
2929	>	abstract static class IntKeySoftValueNode
2930		extends IntKeyNode {
2931		volatile EmbeddedSoftReference valueRef;
2932		final CustomConcurrentHashMap cchm;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines