ViewVC Help

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

root/jsr166/jsr166/src/jsr166e/ConcurrentHashMapV8.java

Comparing jsr166/src/jsr166e/ConcurrentHashMapV8.java (file contents):
Revision 1.53 by jsr166, Mon Aug 13 18:13:30 2012 UTC vs.
Revision 1.57 by dl, Mon Aug 13 19:52:33 2012 UTC

#	Line 712 | Line 712 | public class ConcurrentHashMapV8<K, V>
712		}
713
714		/**
715	<	* Return the TreeNode (or null if not found) for the given key
715	>	* Returns the TreeNode (or null if not found) for the given key
716		* starting at given root.
717		*/
718		@SuppressWarnings("unchecked") // suppress Comparable cast warning
#	Line 2327 | Line 2327 | public class ConcurrentHashMapV8<K, V>
2327		}
2328
2329		public final void remove() {
2330	<	if (nextVal == null)
2330	>	if (nextVal == null && last == null)
2331		advance();
2332		Node e = last;
2333		if (e == null)
#	Line 2657 | Line 2657 | public class ConcurrentHashMapV8<K, V>
2657		*
2658		* @param key key with which the specified value is to be associated
2659		* @param remappingFunction the function to compute a value
2660	<	* @return the new value associated with
2661	<	*         the specified key, or null if none.
2660	>	* @return the new value associated with the specified key, or null if none
2661		* @throws NullPointerException if the specified key or remappingFunction
2662		*         is null
2663		* @throws IllegalStateException if the computation detectably
#	Line 2704 | Line 2703 | public class ConcurrentHashMapV8<K, V>
2703		*
2704		* @param key key with which the specified value is to be associated
2705		* @param remappingFunction the function to compute a value
2706	<	* @return the new value associated with
2708	<	*         the specified key, or null if none.
2706	>	* @return the new value associated with the specified key, or null if none
2707		* @throws NullPointerException if the specified key or remappingFunction
2708		*         is null
2709		* @throws IllegalStateException if the computation detectably
#	Line 2898 | Line 2896 | public class ConcurrentHashMapV8<K, V>
2896		}
2897
2898		/**
2899	<	* Returns a partionable iterator of the keys in this map.
2899	>	* Returns a partitionable iterator of the keys in this map.
2900		*
2901	<	* @return a partionable iterator of the keys in this map
2901	>	* @return a partitionable iterator of the keys in this map
2902		*/
2903		public Spliterator<K> keySpliterator() {
2904		return new KeyIterator<K,V>(this);
2905		}
2906
2907		/**
2908	<	* Returns a partionable iterator of the values in this map.
2908	>	* Returns a partitionable iterator of the values in this map.
2909		*
2910	<	* @return a partionable iterator of the values in this map
2910	>	* @return a partitionable iterator of the values in this map
2911		*/
2912		public Spliterator<V> valueSpliterator() {
2913		return new ValueIterator<K,V>(this);
2914		}
2915
2916		/**
2917	<	* Returns a partionable iterator of the entries in this map.
2917	>	* Returns a partitionable iterator of the entries in this map.
2918		*
2919	<	* @return a partionable iterator of the entries in this map
2919	>	* @return a partitionable iterator of the entries in this map
2920		*/
2921		public Spliterator<Map.Entry<K,V>> entrySpliterator() {
2922		return new EntryIterator<K,V>(this);
#	Line 3518 | Line 3516 | public class ConcurrentHashMapV8<K, V>
3516
3517		/**
3518		* An extended view of a ConcurrentHashMap supporting bulk
3519	<	* parallel operations. These operations are designed to be be
3519	>	* parallel operations. These operations are designed to be
3520		* safely, and often sensibly, applied even with maps that are
3521		* being concurrently updated by other threads; for example, when
3522		* computing a snapshot summary of the values in a shared
#	Line 3750 | Line 3748 | public class ConcurrentHashMapV8<K, V>
3748		}
3749
3750		/**
3751	<	* Performs the given action for each key
3751	>	* Performs the given action for each key.
3752		*
3753		* @param action the action
3754		*/
#	Line 3761 | Line 3759 | public class ConcurrentHashMapV8<K, V>
3759
3760		/**
3761		* Performs the given action for each non-null transformation
3762	<	* of each key
3762	>	* of each key.
3763		*
3764		* @param transformer a function returning the transformation
3765		* for an element, or null of there is no transformation (in
#	Line 3880 | Line 3878 | public class ConcurrentHashMapV8<K, V>
3878		}
3879
3880		/**
3881	<	* Performs the given action for each value
3881	>	* Performs the given action for each value.
3882		*
3883		* @param action the action
3884		*/
#	Line 3891 | Line 3889 | public class ConcurrentHashMapV8<K, V>
3889
3890		/**
3891		* Performs the given action for each non-null transformation
3892	<	* of each value
3892	>	* of each value.
3893		*
3894		* @param transformer a function returning the transformation
3895		* for an element, or null of there is no transformation (in
#	Line 4009 | Line 4007 | public class ConcurrentHashMapV8<K, V>
4007		}
4008
4009		/**
4010	<	* Perform the given action for each entry
4010	>	* Performs the given action for each entry.
4011		*
4012		* @param action the action
4013		*/
#	Line 4019 | Line 4017 | public class ConcurrentHashMapV8<K, V>
4017		}
4018
4019		/**
4020	<	* Perform the given action for each non-null transformation
4021	<	* of each entry
4020	>	* Performs the given action for each non-null transformation
4021	>	* of each entry.
4022		*
4023		* @param transformer a function returning the transformation
4024		* for an element, or null of there is no transformation (in
#	Line 4304 | Line 4302 | public class ConcurrentHashMapV8<K, V>
4302
4303		/**
4304		* Returns a task that when invoked, performs the given action
4305	<	* for each key
4305	>	* for each key.
4306		*
4307		* @param map the map
4308		* @param action the action
#	Line 4319 | Line 4317 | public class ConcurrentHashMapV8<K, V>
4317
4318		/**
4319		* Returns a task that when invoked, performs the given action
4320	<	* for each non-null transformation of each key
4320	>	* for each non-null transformation of each key.
4321		*
4322		* @param map the map
4323		* @param transformer a function returning the transformation
#	Line 4472 | Line 4470 | public class ConcurrentHashMapV8<K, V>
4470
4471		/**
4472		* Returns a task that when invoked, performs the given action
4473	<	* for each value
4473	>	* for each value.
4474		*
4475		* @param map the map
4476		* @param action the action
#	Line 4486 | Line 4484 | public class ConcurrentHashMapV8<K, V>
4484
4485		/**
4486		* Returns a task that when invoked, performs the given action
4487	<	* for each non-null transformation of each value
4487	>	* for each non-null transformation of each value.
4488		*
4489		* @param map the map
4490		* @param transformer a function returning the transformation
#	Line 4640 | Line 4638 | public class ConcurrentHashMapV8<K, V>
4638
4639		/**
4640		* Returns a task that when invoked, perform the given action
4641	<	* for each entry
4641	>	* for each entry.
4642		*
4643		* @param map the map
4644		* @param action the action
#	Line 4654 | Line 4652 | public class ConcurrentHashMapV8<K, V>
4652
4653		/**
4654		* Returns a task that when invoked, perform the given action
4655	<	* for each non-null transformation of each entry
4655	>	* for each non-null transformation of each entry.
4656		*
4657		* @param map the map
4658		* @param transformer a function returning the transformation
#	Line 4811 | Line 4809 | public class ConcurrentHashMapV8<K, V>
4809
4810		/**
4811		* Base for FJ tasks for bulk operations. This adds a variant of
4812	<	* CountedCompleters and some split and merge bookeeping to
4812	>	* CountedCompleters and some split and merge bookkeeping to
4813		* iterator functionality. The forEach and reduce methods are
4814		* similar to those illustrated in CountedCompleter documentation,
4815		* except that bottom-up reduction completions perform them within
#	Line 4842 | Line 4840 | public class ConcurrentHashMapV8<K, V>
4840		// FJ methods
4841
4842		/**
4843	<	* Propagate completion. Note that all reduce actions
4843	>	* Propagates completion. Note that all reduce actions
4844		* bypass this method to combine while completing.
4845		*/
4846		final void tryComplete() {
#	Line 4860 | Line 4858 | public class ConcurrentHashMapV8<K, V>
4858		}
4859
4860		/**
4861	<	* Force root task to throw exception unless already complete.
4861	>	* Forces root task to throw exception unless already complete.
4862		*/
4863		final void tryAbortComputation(Throwable ex) {
4864		for (BulkTask<K,V,?> a = this;;) {
#	Line 4893 | Line 4891 | public class ConcurrentHashMapV8<K, V>
4891		}
4892
4893		/**
4894	<	* Return approx exp2 of the number of times (minus one) to
4894	>	* Returns approx exp2 of the number of times (minus one) to
4895		* split task by two before executing leaf action. This value
4896		* is faster to compute and more convenient to use as a guide
4897		* to splitting than is the depth, since it is used while
#	Line 4916 | Line 4914 | public class ConcurrentHashMapV8<K, V>
4914		"Unexpected null function";
4915
4916		/**
4917	<	* Return exportable snapshot entry
4917	>	* Returns exportable snapshot entry.
4918		*/
4919		static <K,V> AbstractMap.SimpleEntry<K,V> entryFor(K k, V v) {
4920		return new AbstractMap.SimpleEntry(k, v);

Diff Legend

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