ViewVC Help

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

root/jsr166/jsr166/src/jsr166x/ConcurrentSkipListMap.java

Comparing jsr166/src/jsr166x/ConcurrentSkipListMap.java (file contents):
Revision 1.9 by jsr166, Tue Nov 24 03:57:04 2009 UTC vs.
Revision 1.15 by jsr166, Tue Oct 25 18:46:37 2011 UTC

#	Line 1 | Line 1
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 jsr166x;
#	Line 865 | Line 865 | public class ConcurrentSkipListMap<K,V>
865		}
866		if (c == 0) {
867		Object v = r.node.value;
868	<	return (v != null)? (V)v : getUsingFindNode(key);
868	>	return (v != null) ? (V)v : getUsingFindNode(key);
869		}
870		bound = rk;
871		}
#	Line 878 | Line 878 | public class ConcurrentSkipListMap<K,V>
878		int c = key.compareTo(nk);
879		if (c == 0) {
880		Object v = n.value;
881	<	return (v != null)? (V)v : getUsingFindNode(key);
881	>	return (v != null) ? (V)v : getUsingFindNode(key);
882		}
883		if (c < 0)
884		return null;
#	Line 1246 | Line 1246 | public class ConcurrentSkipListMap<K,V>
1246		findFirst(); // retry
1247		clearIndexToFirst();
1248		K key = n.key;
1249	<	return (keyOnly)? key : new SnapshotEntry<K,V>(key, (V)v);
1249	>	return keyOnly ? key : new SnapshotEntry<K,V>(key, (V)v);
1250		}
1251		}
1252
#	Line 1306 | Line 1306 | public class ConcurrentSkipListMap<K,V>
1306		Node<K,V> n = b.next;
1307		for (;;) {
1308		if (n == null)
1309	<	return (b.isBaseHeader())? null : b;
1309	>	return b.isBaseHeader() ? null : b;
1310		Node<K,V> f = n.next;            // inconsistent read
1311		if (n != b.next)
1312		break;
#	Line 1368 | Line 1368 | public class ConcurrentSkipListMap<K,V>
1368		if (head.right == null)
1369		tryReduceLevel();
1370		}
1371	<	return (keyOnly)? key : new SnapshotEntry<K,V>(key, (V)v);
1371	>	return keyOnly ? key : new SnapshotEntry<K,V>(key, (V)v);
1372		}
1373		}
1374		}
#	Line 1432 | Line 1432 | public class ConcurrentSkipListMap<K,V>
1432		Node<K,V> n = b.next;
1433		for (;;) {
1434		if (n == null)
1435	<	return ((rel & LT) == 0 || b.isBaseHeader())? null : b;
1435	>	return ((rel & LT) == 0 || b.isBaseHeader()) ? null : b;
1436		Node<K,V> f = n.next;
1437		if (n != b.next)                  // inconsistent read
1438		break;
#	Line 1448 | Line 1448 | public class ConcurrentSkipListMap<K,V>
1448		(c <  0 && (rel & LT) == 0))
1449		return n;
1450		if ( c <= 0 && (rel & LT) != 0)
1451	<	return (b.isBaseHeader())? null : b;
1451	>	return b.isBaseHeader() ? null : b;
1452		b = n;
1453		n = f;
1454		}
#	Line 1476 | Line 1476 | public class ConcurrentSkipListMap<K,V>
1476		* Return ceiling, or first node if key is <tt>null</tt>
1477		*/
1478		Node<K,V> findCeiling(K key) {
1479	<	return (key == null)? findFirst() : findNear(key, GT|EQ);
1479	>	return (key == null) ? findFirst() : findNear(key, GT|EQ);
1480		}
1481
1482		/**
1483		* Return lower node, or last node if key is <tt>null</tt>
1484		*/
1485		Node<K,V> findLower(K key) {
1486	<	return (key == null)? findLast() : findNear(key, LT);
1486	>	return (key == null) ? findLast() : findNear(key, LT);
1487		}
1488
1489		/**
#	Line 1513 | Line 1513 | public class ConcurrentSkipListMap<K,V>
1513		K k = n.key;
1514		V v = n.getValidValue();
1515		if (v != null)
1516	<	return keyOnly? k : new SnapshotEntry<K,V>(k, v);
1516	>	return keyOnly ? k : new SnapshotEntry<K,V>(k, v);
1517		}
1518		}
1519
#	Line 1534 | Line 1534 | public class ConcurrentSkipListMap<K,V>
1534		return null;
1535		V v = doRemove(k, null);
1536		if (v != null)
1537	<	return (keyOnly)? k : new SnapshotEntry<K,V>(k, v);
1537	>	return keyOnly ? k : new SnapshotEntry<K,V>(k, v);
1538		}
1539		}
1540
#	Line 1555 | Line 1555 | public class ConcurrentSkipListMap<K,V>
1555		return null;
1556		V v = doRemove(k, null);
1557		if (v != null)
1558	<	return (keyOnly)? k : new SnapshotEntry<K,V>(k, v);
1558	>	return keyOnly ? k : new SnapshotEntry<K,V>(k, v);
1559		}
1560		}
1561
#	Line 1689 | Line 1689 | public class ConcurrentSkipListMap<K,V>
1689		/* ---------------- Serialization -------------- */
1690
1691		/**
1692	<	* Save the state of the <tt>Map</tt> instance to a stream.
1692	>	* Saves the state of the <tt>Map</tt> instance to a stream.
1693		*
1694		* @serialData The key (Object) and value (Object) for each
1695		* key-value mapping represented by the Map, followed by
#	Line 1714 | Line 1714 | public class ConcurrentSkipListMap<K,V>
1714		}
1715
1716		/**
1717	<	* Reconstitute the <tt>Map</tt> instance from a stream.
1717	>	* Reconstitutes the <tt>Map</tt> instance from a stream.
1718		*/
1719		private void readObject(final java.io.ObjectInputStream s)
1720		throws java.io.IOException, ClassNotFoundException {
#	Line 1883 | Line 1883 | public class ConcurrentSkipListMap<K,V>
1883		if (n.getValidValue() != null)
1884		++count;
1885		}
1886	<	return (count >= Integer.MAX_VALUE)? Integer.MAX_VALUE : (int)count;
1886	>	return (count >= Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int)count;
1887		}
1888
1889		/**
#	Line 2064 | Line 2064 | public class ConcurrentSkipListMap<K,V>
2064		try {
2065		return (containsAllMappings(this, t) &&
2066		containsAllMappings(t, this));
2067	<	} catch(ClassCastException unused) {
2067	>	} catch (ClassCastException unused) {
2068		return false;
2069	<	} catch(NullPointerException unused) {
2069	>	} catch (NullPointerException unused) {
2070		return false;
2071		}
2072		}
#	Line 2250 | Line 2250 | public class ConcurrentSkipListMap<K,V>
2250		* <tt>fromKey</tt> and <tt>toKey</tt> are equal, the returned sorted map
2251		* is empty.)  The returned sorted map is backed by this map, so changes
2252		* in the returned sorted map are reflected in this map, and vice-versa.
2253	<
2253	>	*
2254		* @param fromKey low endpoint (inclusive) of the subMap.
2255		* @param toKey high endpoint (exclusive) of the subMap.
2256		*
#	Line 2343 | Line 2343 | public class ConcurrentSkipListMap<K,V>
2343		*/
2344		public K ceilingKey(K key) {
2345		Node<K,V> n = findNear(key, GT|EQ);
2346	<	return (n == null)? null : n.key;
2346	>	return (n == null) ? null : n.key;
2347		}
2348
2349		/**
#	Line 2376 | Line 2376 | public class ConcurrentSkipListMap<K,V>
2376		*/
2377		public K lowerKey(K key) {
2378		Node<K,V> n = findNear(key, LT);
2379	<	return (n == null)? null : n.key;
2379	>	return (n == null) ? null : n.key;
2380		}
2381
2382		/**
#	Line 2410 | Line 2410 | public class ConcurrentSkipListMap<K,V>
2410		*/
2411		public K floorKey(K key) {
2412		Node<K,V> n = findNear(key, LT|EQ);
2413	<	return (n == null)? null : n.key;
2413	>	return (n == null) ? null : n.key;
2414		}
2415
2416		/**
#	Line 2443 | Line 2443 | public class ConcurrentSkipListMap<K,V>
2443		*/
2444		public K higherKey(K key) {
2445		Node<K,V> n = findNear(key, GT);
2446	<	return (n == null)? null : n.key;
2446	>	return (n == null) ? null : n.key;
2447		}
2448
2449		/**
#	Line 3050 | Line 3050 | public class ConcurrentSkipListMap<K,V>
3050		* Creates a new submap.
3051		* @param least inclusive least value, or <tt>null</tt> if from start
3052		* @param fence exclusive upper bound or <tt>null</tt> if to end
3053	<	* @throws IllegalArgumentException if least and fence nonnull
3053	>	* @throws IllegalArgumentException if least and fence non-null
3054		*  and least greater than fence
3055		*/
3056		ConcurrentSkipListSubMap(ConcurrentSkipListMap<K,V> map,
#	Line 3128 | Line 3128 | public class ConcurrentSkipListMap<K,V>
3128
3129		public V get(Object key) {
3130		K k = (K)key;
3131	<	return ((!inHalfOpenRange(k)) ? null : m.get(k));
3131	>	return (!inHalfOpenRange(k)) ? null : m.get(k);
3132		}
3133
3134		public V put(K key, V value) {
#	Line 3138 | Line 3138 | public class ConcurrentSkipListMap<K,V>
3138
3139		public V remove(Object key) {
3140		K k = (K)key;
3141	<	return (!inHalfOpenRange(k))? null : m.remove(k);
3141	>	return (!inHalfOpenRange(k)) ? null : m.remove(k);
3142		}
3143
3144		public int size() {
#	Line 3149 | Line 3149 | public class ConcurrentSkipListMap<K,V>
3149		if (n.getValidValue() != null)
3150		++count;
3151		}
3152	<	return count >= Integer.MAX_VALUE? Integer.MAX_VALUE : (int)count;
3152	>	return (count >= Integer.MAX_VALUE) ?
3153	>	Integer.MAX_VALUE : (int)count;
3154		}
3155
3156		public boolean isEmpty() {

Diff Legend

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