ViewVC Help

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

root/jsr166/jsr166/src/main/java/util/concurrent/ConcurrentHashMap.java

Comparing jsr166/src/main/java/util/concurrent/ConcurrentHashMap.java (file contents):
Revision 1.170 by jsr166, Mon Jan 28 17:27:03 2013 UTC vs.
Revision 1.171 by dl, Fri Feb 1 01:02:37 2013 UTC

#	Line 2953 | Line 2953 | public class ConcurrentHashMap<K, V>
2953
2954		public Iterator<K> iterator() { return this; }
2955
2956	<	public void forEach(Block<? super K> action) {
2956	>	public void forEach(Consumer<? super K> action) {
2957		if (action == null) throw new NullPointerException();
2958		while (advance() != null)
2959		action.accept(nextKey);
2960		}
2961
2962	<	public boolean tryAdvance(Block<? super K> block) {
2962	>	public boolean tryAdvance(Consumer<? super K> block) {
2963		if (block == null) throw new NullPointerException();
2964		if (advance() == null)
2965		return false;
#	Line 2993 | Line 2993 | public class ConcurrentHashMap<K, V>
2993
2994		public Iterator<V> iterator() { return this; }
2995
2996	<	public void forEach(Block<? super V> action) {
2996	>	public void forEach(Consumer<? super V> action) {
2997		if (action == null) throw new NullPointerException();
2998		V v;
2999		while ((v = advance()) != null)
3000		action.accept(v);
3001		}
3002
3003	<	public boolean tryAdvance(Block<? super V> block) {
3003	>	public boolean tryAdvance(Consumer<? super V> block) {
3004		V v;
3005		if (block == null) throw new NullPointerException();
3006		if ((v = advance()) == null)
#	Line 3035 | Line 3035 | public class ConcurrentHashMap<K, V>
3035
3036		public Iterator<Map.Entry<K,V>> iterator() { return this; }
3037
3038	<	public void forEach(Block<? super Map.Entry<K,V>> action) {
3038	>	public void forEach(Consumer<? super Map.Entry<K,V>> action) {
3039		if (action == null) throw new NullPointerException();
3040		V v;
3041		while ((v = advance()) != null)
3042		action.accept(entryFor(nextKey, v));
3043		}
3044
3045	<	public boolean tryAdvance(Block<? super Map.Entry<K,V>> block) {
3045	>	public boolean tryAdvance(Consumer<? super Map.Entry<K,V>> block) {
3046		V v;
3047		if (block == null) throw new NullPointerException();
3048		if ((v = advance()) == null)
#	Line 3238 | Line 3238 | public class ConcurrentHashMap<K, V>
3238		* @param action the action
3239		*/
3240		public void forEachSequentially
3241	<	(BiBlock<? super K, ? super V> action) {
3241	>	(BiConsumer<? super K, ? super V> action) {
3242		if (action == null) throw new NullPointerException();
3243		Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
3244		V v;
#	Line 3257 | Line 3257 | public class ConcurrentHashMap<K, V>
3257		*/
3258		public <U> void forEachSequentially
3259		(BiFunction<? super K, ? super V, ? extends U> transformer,
3260	<	Block<? super U> action) {
3260	>	Consumer<? super U> action) {
3261		if (transformer == null || action == null)
3262		throw new NullPointerException();
3263		Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
#	Line 3328 | Line 3328 | public class ConcurrentHashMap<K, V>
3328		* of all (key, value) pairs
3329		*/
3330		public double reduceToDoubleSequentially
3331	<	(DoubleBiFunction<? super K, ? super V> transformer,
3331	>	(ToDoubleBiFunction<? super K, ? super V> transformer,
3332		double basis,
3333		DoubleBinaryOperator reducer) {
3334		if (transformer == null || reducer == null)
#	Line 3353 | Line 3353 | public class ConcurrentHashMap<K, V>
3353		* of all (key, value) pairs
3354		*/
3355		public long reduceToLongSequentially
3356	<	(LongBiFunction<? super K, ? super V> transformer,
3356	>	(ToLongBiFunction<? super K, ? super V> transformer,
3357		long basis,
3358		LongBinaryOperator reducer) {
3359		if (transformer == null || reducer == null)
#	Line 3378 | Line 3378 | public class ConcurrentHashMap<K, V>
3378		* of all (key, value) pairs
3379		*/
3380		public int reduceToIntSequentially
3381	<	(IntBiFunction<? super K, ? super V> transformer,
3381	>	(ToIntBiFunction<? super K, ? super V> transformer,
3382		int basis,
3383		IntBinaryOperator reducer) {
3384		if (transformer == null || reducer == null)
#	Line 3396 | Line 3396 | public class ConcurrentHashMap<K, V>
3396		* @param action the action
3397		*/
3398		public void forEachKeySequentially
3399	<	(Block<? super K> action) {
3399	>	(Consumer<? super K> action) {
3400		if (action == null) throw new NullPointerException();
3401		Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
3402		while (it.advance() != null)
#	Line 3414 | Line 3414 | public class ConcurrentHashMap<K, V>
3414		*/
3415		public <U> void forEachKeySequentially
3416		(Function<? super K, ? extends U> transformer,
3417	<	Block<? super U> action) {
3417	>	Consumer<? super U> action) {
3418		if (transformer == null || action == null)
3419		throw new NullPointerException();
3420		Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
#	Line 3506 | Line 3506 | public class ConcurrentHashMap<K, V>
3506		* of all keys
3507		*/
3508		public double reduceKeysToDoubleSequentially
3509	<	(DoubleFunction<? super K> transformer,
3509	>	(ToDoubleFunction<? super K> transformer,
3510		double basis,
3511		DoubleBinaryOperator reducer) {
3512		if (transformer == null || reducer == null)
#	Line 3531 | Line 3531 | public class ConcurrentHashMap<K, V>
3531		* of all keys
3532		*/
3533		public long reduceKeysToLongSequentially
3534	<	(LongFunction<? super K> transformer,
3534	>	(ToLongFunction<? super K> transformer,
3535		long basis,
3536		LongBinaryOperator reducer) {
3537		if (transformer == null || reducer == null)
#	Line 3556 | Line 3556 | public class ConcurrentHashMap<K, V>
3556		* of all keys
3557		*/
3558		public int reduceKeysToIntSequentially
3559	<	(IntFunction<? super K> transformer,
3559	>	(ToIntFunction<? super K> transformer,
3560		int basis,
3561		IntBinaryOperator reducer) {
3562		if (transformer == null || reducer == null)
#	Line 3573 | Line 3573 | public class ConcurrentHashMap<K, V>
3573		*
3574		* @param action the action
3575		*/
3576	<	public void forEachValueSequentially(Block<? super V> action) {
3576	>	public void forEachValueSequentially(Consumer<? super V> action) {
3577		if (action == null) throw new NullPointerException();
3578		Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
3579		V v;
#	Line 3591 | Line 3591 | public class ConcurrentHashMap<K, V>
3591		*/
3592		public <U> void forEachValueSequentially
3593		(Function<? super V, ? extends U> transformer,
3594	<	Block<? super U> action) {
3594	>	Consumer<? super U> action) {
3595		if (transformer == null || action == null)
3596		throw new NullPointerException();
3597		Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
#	Line 3679 | Line 3679 | public class ConcurrentHashMap<K, V>
3679		* of all values
3680		*/
3681		public double reduceValuesToDoubleSequentially
3682	<	(DoubleFunction<? super V> transformer,
3682	>	(ToDoubleFunction<? super V> transformer,
3683		double basis,
3684		DoubleBinaryOperator reducer) {
3685		if (transformer == null || reducer == null)
#	Line 3704 | Line 3704 | public class ConcurrentHashMap<K, V>
3704		* of all values
3705		*/
3706		public long reduceValuesToLongSequentially
3707	<	(LongFunction<? super V> transformer,
3707	>	(ToLongFunction<? super V> transformer,
3708		long basis,
3709		LongBinaryOperator reducer) {
3710		if (transformer == null || reducer == null)
#	Line 3729 | Line 3729 | public class ConcurrentHashMap<K, V>
3729		* of all values
3730		*/
3731		public int reduceValuesToIntSequentially
3732	<	(IntFunction<? super V> transformer,
3732	>	(ToIntFunction<? super V> transformer,
3733		int basis,
3734		IntBinaryOperator reducer) {
3735		if (transformer == null || reducer == null)
#	Line 3747 | Line 3747 | public class ConcurrentHashMap<K, V>
3747		* @param action the action
3748		*/
3749		public void forEachEntrySequentially
3750	<	(Block<? super Map.Entry<K,V>> action) {
3750	>	(Consumer<? super Map.Entry<K,V>> action) {
3751		if (action == null) throw new NullPointerException();
3752		Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
3753		V v;
#	Line 3766 | Line 3766 | public class ConcurrentHashMap<K, V>
3766		*/
3767		public <U> void forEachEntrySequentially
3768		(Function<Map.Entry<K,V>, ? extends U> transformer,
3769	<	Block<? super U> action) {
3769	>	Consumer<? super U> action) {
3770		if (transformer == null || action == null)
3771		throw new NullPointerException();
3772		Traverser<K,V,Object> it = new Traverser<K,V,Object>(this);
#	Line 3856 | Line 3856 | public class ConcurrentHashMap<K, V>
3856		* of all entries
3857		*/
3858		public double reduceEntriesToDoubleSequentially
3859	<	(DoubleFunction<Map.Entry<K,V>> transformer,
3859	>	(ToDoubleFunction<Map.Entry<K,V>> transformer,
3860		double basis,
3861		DoubleBinaryOperator reducer) {
3862		if (transformer == null || reducer == null)
#	Line 3881 | Line 3881 | public class ConcurrentHashMap<K, V>
3881		* of all entries
3882		*/
3883		public long reduceEntriesToLongSequentially
3884	<	(LongFunction<Map.Entry<K,V>> transformer,
3884	>	(ToLongFunction<Map.Entry<K,V>> transformer,
3885		long basis,
3886		LongBinaryOperator reducer) {
3887		if (transformer == null || reducer == null)
#	Line 3906 | Line 3906 | public class ConcurrentHashMap<K, V>
3906		* of all entries
3907		*/
3908		public int reduceEntriesToIntSequentially
3909	<	(IntFunction<Map.Entry<K,V>> transformer,
3909	>	(ToIntFunction<Map.Entry<K,V>> transformer,
3910		int basis,
3911		IntBinaryOperator reducer) {
3912		if (transformer == null || reducer == null)
#	Line 3925 | Line 3925 | public class ConcurrentHashMap<K, V>
3925		*
3926		* @param action the action
3927		*/
3928	<	public void forEachInParallel(BiBlock<? super K,? super V> action) {
3928	>	public void forEachInParallel(BiConsumer<? super K,? super V> action) {
3929		ForkJoinTasks.forEach
3930		(this, action).invoke();
3931		}
#	Line 3941 | Line 3941 | public class ConcurrentHashMap<K, V>
3941		*/
3942		public <U> void forEachInParallel
3943		(BiFunction<? super K, ? super V, ? extends U> transformer,
3944	<	Block<? super U> action) {
3944	>	Consumer<? super U> action) {
3945		ForkJoinTasks.forEach
3946		(this, transformer, action).invoke();
3947		}
#	Line 3996 | Line 3996 | public class ConcurrentHashMap<K, V>
3996		* of all (key, value) pairs
3997		*/
3998		public double reduceToDoubleInParallel
3999	<	(DoubleBiFunction<? super K, ? super V> transformer,
3999	>	(ToDoubleBiFunction<? super K, ? super V> transformer,
4000		double basis,
4001		DoubleBinaryOperator reducer) {
4002		return ForkJoinTasks.reduceToDouble
#	Line 4016 | Line 4016 | public class ConcurrentHashMap<K, V>
4016		* of all (key, value) pairs
4017		*/
4018		public long reduceToLongInParallel
4019	<	(LongBiFunction<? super K, ? super V> transformer,
4019	>	(ToLongBiFunction<? super K, ? super V> transformer,
4020		long basis,
4021		LongBinaryOperator reducer) {
4022		return ForkJoinTasks.reduceToLong
#	Line 4036 | Line 4036 | public class ConcurrentHashMap<K, V>
4036		* of all (key, value) pairs
4037		*/
4038		public int reduceToIntInParallel
4039	<	(IntBiFunction<? super K, ? super V> transformer,
4039	>	(ToIntBiFunction<? super K, ? super V> transformer,
4040		int basis,
4041		IntBinaryOperator reducer) {
4042		return ForkJoinTasks.reduceToInt
#	Line 4048 | Line 4048 | public class ConcurrentHashMap<K, V>
4048		*
4049		* @param action the action
4050		*/
4051	<	public void forEachKeyInParallel(Block<? super K> action) {
4051	>	public void forEachKeyInParallel(Consumer<? super K> action) {
4052		ForkJoinTasks.forEachKey
4053		(this, action).invoke();
4054		}
#	Line 4064 | Line 4064 | public class ConcurrentHashMap<K, V>
4064		*/
4065		public <U> void forEachKeyInParallel
4066		(Function<? super K, ? extends U> transformer,
4067	<	Block<? super U> action) {
4067	>	Consumer<? super U> action) {
4068		ForkJoinTasks.forEachKey
4069		(this, transformer, action).invoke();
4070		}
#	Line 4133 | Line 4133 | public class ConcurrentHashMap<K, V>
4133		* of all keys
4134		*/
4135		public double reduceKeysToDoubleInParallel
4136	<	(DoubleFunction<? super K> transformer,
4136	>	(ToDoubleFunction<? super K> transformer,
4137		double basis,
4138		DoubleBinaryOperator reducer) {
4139		return ForkJoinTasks.reduceKeysToDouble
#	Line 4153 | Line 4153 | public class ConcurrentHashMap<K, V>
4153		* of all keys
4154		*/
4155		public long reduceKeysToLongInParallel
4156	<	(LongFunction<? super K> transformer,
4156	>	(ToLongFunction<? super K> transformer,
4157		long basis,
4158		LongBinaryOperator reducer) {
4159		return ForkJoinTasks.reduceKeysToLong
#	Line 4173 | Line 4173 | public class ConcurrentHashMap<K, V>
4173		* of all keys
4174		*/
4175		public int reduceKeysToIntInParallel
4176	<	(IntFunction<? super K> transformer,
4176	>	(ToIntFunction<? super K> transformer,
4177		int basis,
4178		IntBinaryOperator reducer) {
4179		return ForkJoinTasks.reduceKeysToInt
#	Line 4185 | Line 4185 | public class ConcurrentHashMap<K, V>
4185		*
4186		* @param action the action
4187		*/
4188	<	public void forEachValueInParallel(Block<? super V> action) {
4188	>	public void forEachValueInParallel(Consumer<? super V> action) {
4189		ForkJoinTasks.forEachValue
4190		(this, action).invoke();
4191		}
#	Line 4200 | Line 4200 | public class ConcurrentHashMap<K, V>
4200		*/
4201		public <U> void forEachValueInParallel
4202		(Function<? super V, ? extends U> transformer,
4203	<	Block<? super U> action) {
4203	>	Consumer<? super U> action) {
4204		ForkJoinTasks.forEachValue
4205		(this, transformer, action).invoke();
4206		}
#	Line 4268 | Line 4268 | public class ConcurrentHashMap<K, V>
4268		* of all values
4269		*/
4270		public double reduceValuesToDoubleInParallel
4271	<	(DoubleFunction<? super V> transformer,
4271	>	(ToDoubleFunction<? super V> transformer,
4272		double basis,
4273		DoubleBinaryOperator reducer) {
4274		return ForkJoinTasks.reduceValuesToDouble
#	Line 4288 | Line 4288 | public class ConcurrentHashMap<K, V>
4288		* of all values
4289		*/
4290		public long reduceValuesToLongInParallel
4291	<	(LongFunction<? super V> transformer,
4291	>	(ToLongFunction<? super V> transformer,
4292		long basis,
4293		LongBinaryOperator reducer) {
4294		return ForkJoinTasks.reduceValuesToLong
#	Line 4308 | Line 4308 | public class ConcurrentHashMap<K, V>
4308		* of all values
4309		*/
4310		public int reduceValuesToIntInParallel
4311	<	(IntFunction<? super V> transformer,
4311	>	(ToIntFunction<? super V> transformer,
4312		int basis,
4313		IntBinaryOperator reducer) {
4314		return ForkJoinTasks.reduceValuesToInt
#	Line 4320 | Line 4320 | public class ConcurrentHashMap<K, V>
4320		*
4321		* @param action the action
4322		*/
4323	<	public void forEachEntryInParallel(Block<? super Map.Entry<K,V>> action) {
4323	>	public void forEachEntryInParallel(Consumer<? super Map.Entry<K,V>> action) {
4324		ForkJoinTasks.forEachEntry
4325		(this, action).invoke();
4326		}
#	Line 4336 | Line 4336 | public class ConcurrentHashMap<K, V>
4336		*/
4337		public <U> void forEachEntryInParallel
4338		(Function<Map.Entry<K,V>, ? extends U> transformer,
4339	<	Block<? super U> action) {
4339	>	Consumer<? super U> action) {
4340		ForkJoinTasks.forEachEntry
4341		(this, transformer, action).invoke();
4342		}
#	Line 4404 | Line 4404 | public class ConcurrentHashMap<K, V>
4404		* of all entries
4405		*/
4406		public double reduceEntriesToDoubleInParallel
4407	<	(DoubleFunction<Map.Entry<K,V>> transformer,
4407	>	(ToDoubleFunction<Map.Entry<K,V>> transformer,
4408		double basis,
4409		DoubleBinaryOperator reducer) {
4410		return ForkJoinTasks.reduceEntriesToDouble
#	Line 4424 | Line 4424 | public class ConcurrentHashMap<K, V>
4424		* of all entries
4425		*/
4426		public long reduceEntriesToLongInParallel
4427	<	(LongFunction<Map.Entry<K,V>> transformer,
4427	>	(ToLongFunction<Map.Entry<K,V>> transformer,
4428		long basis,
4429		LongBinaryOperator reducer) {
4430		return ForkJoinTasks.reduceEntriesToLong
#	Line 4444 | Line 4444 | public class ConcurrentHashMap<K, V>
4444		* of all entries
4445		*/
4446		public int reduceEntriesToIntInParallel
4447	<	(IntFunction<Map.Entry<K,V>> transformer,
4447	>	(ToIntFunction<Map.Entry<K,V>> transformer,
4448		int basis,
4449		IntBinaryOperator reducer) {
4450		return ForkJoinTasks.reduceEntriesToInt
#	Line 4824 | Line 4824 | public class ConcurrentHashMap<K, V>
4824		*/
4825		public static <K,V> ForkJoinTask<Void> forEach
4826		(ConcurrentHashMap<K,V> map,
4827	<	BiBlock<? super K, ? super V> action) {
4827	>	BiConsumer<? super K, ? super V> action) {
4828		if (action == null) throw new NullPointerException();
4829		return new ForEachMappingTask<K,V>(map, null, -1, action);
4830		}
#	Line 4843 | Line 4843 | public class ConcurrentHashMap<K, V>
4843		public static <K,V,U> ForkJoinTask<Void> forEach
4844		(ConcurrentHashMap<K,V> map,
4845		BiFunction<? super K, ? super V, ? extends U> transformer,
4846	<	Block<? super U> action) {
4846	>	Consumer<? super U> action) {
4847		if (transformer == null || action == null)
4848		throw new NullPointerException();
4849		return new ForEachTransformedMappingTask<K,V,U>
#	Line 4908 | Line 4908 | public class ConcurrentHashMap<K, V>
4908		*/
4909		public static <K,V> ForkJoinTask<Double> reduceToDouble
4910		(ConcurrentHashMap<K,V> map,
4911	<	DoubleBiFunction<? super K, ? super V> transformer,
4911	>	ToDoubleBiFunction<? super K, ? super V> transformer,
4912		double basis,
4913		DoubleBinaryOperator reducer) {
4914		if (transformer == null || reducer == null)
#	Line 4932 | Line 4932 | public class ConcurrentHashMap<K, V>
4932		*/
4933		public static <K,V> ForkJoinTask<Long> reduceToLong
4934		(ConcurrentHashMap<K,V> map,
4935	<	LongBiFunction<? super K, ? super V> transformer,
4935	>	ToLongBiFunction<? super K, ? super V> transformer,
4936		long basis,
4937		LongBinaryOperator reducer) {
4938		if (transformer == null || reducer == null)
#	Line 4955 | Line 4955 | public class ConcurrentHashMap<K, V>
4955		*/
4956		public static <K,V> ForkJoinTask<Integer> reduceToInt
4957		(ConcurrentHashMap<K,V> map,
4958	<	IntBiFunction<? super K, ? super V> transformer,
4958	>	ToIntBiFunction<? super K, ? super V> transformer,
4959		int basis,
4960		IntBinaryOperator reducer) {
4961		if (transformer == null || reducer == null)
#	Line 4974 | Line 4974 | public class ConcurrentHashMap<K, V>
4974		*/
4975		public static <K,V> ForkJoinTask<Void> forEachKey
4976		(ConcurrentHashMap<K,V> map,
4977	<	Block<? super K> action) {
4977	>	Consumer<? super K> action) {
4978		if (action == null) throw new NullPointerException();
4979		return new ForEachKeyTask<K,V>(map, null, -1, action);
4980		}
#	Line 4993 | Line 4993 | public class ConcurrentHashMap<K, V>
4993		public static <K,V,U> ForkJoinTask<Void> forEachKey
4994		(ConcurrentHashMap<K,V> map,
4995		Function<? super K, ? extends U> transformer,
4996	<	Block<? super U> action) {
4996	>	Consumer<? super U> action) {
4997		if (transformer == null || action == null)
4998		throw new NullPointerException();
4999		return new ForEachTransformedKeyTask<K,V,U>
#	Line 5075 | Line 5075 | public class ConcurrentHashMap<K, V>
5075		*/
5076		public static <K,V> ForkJoinTask<Double> reduceKeysToDouble
5077		(ConcurrentHashMap<K,V> map,
5078	<	DoubleFunction<? super K> transformer,
5078	>	ToDoubleFunction<? super K> transformer,
5079		double basis,
5080		DoubleBinaryOperator reducer) {
5081		if (transformer == null || reducer == null)
#	Line 5099 | Line 5099 | public class ConcurrentHashMap<K, V>
5099		*/
5100		public static <K,V> ForkJoinTask<Long> reduceKeysToLong
5101		(ConcurrentHashMap<K,V> map,
5102	<	LongFunction<? super K> transformer,
5102	>	ToLongFunction<? super K> transformer,
5103		long basis,
5104		LongBinaryOperator reducer) {
5105		if (transformer == null || reducer == null)
#	Line 5123 | Line 5123 | public class ConcurrentHashMap<K, V>
5123		*/
5124		public static <K,V> ForkJoinTask<Integer> reduceKeysToInt
5125		(ConcurrentHashMap<K,V> map,
5126	<	IntFunction<? super K> transformer,
5126	>	ToIntFunction<? super K> transformer,
5127		int basis,
5128		IntBinaryOperator reducer) {
5129		if (transformer == null || reducer == null)
#	Line 5141 | Line 5141 | public class ConcurrentHashMap<K, V>
5141		*/
5142		public static <K,V> ForkJoinTask<Void> forEachValue
5143		(ConcurrentHashMap<K,V> map,
5144	<	Block<? super V> action) {
5144	>	Consumer<? super V> action) {
5145		if (action == null) throw new NullPointerException();
5146		return new ForEachValueTask<K,V>(map, null, -1, action);
5147		}
#	Line 5159 | Line 5159 | public class ConcurrentHashMap<K, V>
5159		public static <K,V,U> ForkJoinTask<Void> forEachValue
5160		(ConcurrentHashMap<K,V> map,
5161		Function<? super V, ? extends U> transformer,
5162	<	Block<? super U> action) {
5162	>	Consumer<? super U> action) {
5163		if (transformer == null || action == null)
5164		throw new NullPointerException();
5165		return new ForEachTransformedValueTask<K,V,U>
#	Line 5241 | Line 5241 | public class ConcurrentHashMap<K, V>
5241		*/
5242		public static <K,V> ForkJoinTask<Double> reduceValuesToDouble
5243		(ConcurrentHashMap<K,V> map,
5244	<	DoubleFunction<? super V> transformer,
5244	>	ToDoubleFunction<? super V> transformer,
5245		double basis,
5246		DoubleBinaryOperator reducer) {
5247		if (transformer == null || reducer == null)
#	Line 5265 | Line 5265 | public class ConcurrentHashMap<K, V>
5265		*/
5266		public static <K,V> ForkJoinTask<Long> reduceValuesToLong
5267		(ConcurrentHashMap<K,V> map,
5268	<	LongFunction<? super V> transformer,
5268	>	ToLongFunction<? super V> transformer,
5269		long basis,
5270		LongBinaryOperator reducer) {
5271		if (transformer == null || reducer == null)
#	Line 5289 | Line 5289 | public class ConcurrentHashMap<K, V>
5289		*/
5290		public static <K,V> ForkJoinTask<Integer> reduceValuesToInt
5291		(ConcurrentHashMap<K,V> map,
5292	<	IntFunction<? super V> transformer,
5292	>	ToIntFunction<? super V> transformer,
5293		int basis,
5294		IntBinaryOperator reducer) {
5295		if (transformer == null || reducer == null)
#	Line 5307 | Line 5307 | public class ConcurrentHashMap<K, V>
5307		*/
5308		public static <K,V> ForkJoinTask<Void> forEachEntry
5309		(ConcurrentHashMap<K,V> map,
5310	<	Block<? super Map.Entry<K,V>> action) {
5310	>	Consumer<? super Map.Entry<K,V>> action) {
5311		if (action == null) throw new NullPointerException();
5312		return new ForEachEntryTask<K,V>(map, null, -1, action);
5313		}
#	Line 5325 | Line 5325 | public class ConcurrentHashMap<K, V>
5325		public static <K,V,U> ForkJoinTask<Void> forEachEntry
5326		(ConcurrentHashMap<K,V> map,
5327		Function<Map.Entry<K,V>, ? extends U> transformer,
5328	<	Block<? super U> action) {
5328	>	Consumer<? super U> action) {
5329		if (transformer == null || action == null)
5330		throw new NullPointerException();
5331		return new ForEachTransformedEntryTask<K,V,U>
#	Line 5407 | Line 5407 | public class ConcurrentHashMap<K, V>
5407		*/
5408		public static <K,V> ForkJoinTask<Double> reduceEntriesToDouble
5409		(ConcurrentHashMap<K,V> map,
5410	<	DoubleFunction<Map.Entry<K,V>> transformer,
5410	>	ToDoubleFunction<Map.Entry<K,V>> transformer,
5411		double basis,
5412		DoubleBinaryOperator reducer) {
5413		if (transformer == null || reducer == null)
#	Line 5431 | Line 5431 | public class ConcurrentHashMap<K, V>
5431		*/
5432		public static <K,V> ForkJoinTask<Long> reduceEntriesToLong
5433		(ConcurrentHashMap<K,V> map,
5434	<	LongFunction<Map.Entry<K,V>> transformer,
5434	>	ToLongFunction<Map.Entry<K,V>> transformer,
5435		long basis,
5436		LongBinaryOperator reducer) {
5437		if (transformer == null || reducer == null)
#	Line 5455 | Line 5455 | public class ConcurrentHashMap<K, V>
5455		*/
5456		public static <K,V> ForkJoinTask<Integer> reduceEntriesToInt
5457		(ConcurrentHashMap<K,V> map,
5458	<	IntFunction<Map.Entry<K,V>> transformer,
5458	>	ToIntFunction<Map.Entry<K,V>> transformer,
5459		int basis,
5460		IntBinaryOperator reducer) {
5461		if (transformer == null || reducer == null)
#	Line 5477 | Line 5477 | public class ConcurrentHashMap<K, V>
5477
5478		@SuppressWarnings("serial") static final class ForEachKeyTask<K,V>
5479		extends Traverser<K,V,Void> {
5480	<	final Block<? super K> action;
5480	>	final Consumer<? super K> action;
5481		ForEachKeyTask
5482		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
5483	<	Block<? super K> action) {
5483	>	Consumer<? super K> action) {
5484		super(m, p, b);
5485		this.action = action;
5486		}
5487		public final void compute() {
5488	<	final Block<? super K> action;
5488	>	final Consumer<? super K> action;
5489		if ((action = this.action) != null) {
5490		for (int b; (b = preSplit()) > 0;)
5491		new ForEachKeyTask<K,V>(map, this, b, action).fork();
#	Line 5498 | Line 5498 | public class ConcurrentHashMap<K, V>
5498
5499		@SuppressWarnings("serial") static final class ForEachValueTask<K,V>
5500		extends Traverser<K,V,Void> {
5501	<	final Block<? super V> action;
5501	>	final Consumer<? super V> action;
5502		ForEachValueTask
5503		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
5504	<	Block<? super V> action) {
5504	>	Consumer<? super V> action) {
5505		super(m, p, b);
5506		this.action = action;
5507		}
5508		public final void compute() {
5509	<	final Block<? super V> action;
5509	>	final Consumer<? super V> action;
5510		if ((action = this.action) != null) {
5511		for (int b; (b = preSplit()) > 0;)
5512		new ForEachValueTask<K,V>(map, this, b, action).fork();
#	Line 5520 | Line 5520 | public class ConcurrentHashMap<K, V>
5520
5521		@SuppressWarnings("serial") static final class ForEachEntryTask<K,V>
5522		extends Traverser<K,V,Void> {
5523	<	final Block<? super Entry<K,V>> action;
5523	>	final Consumer<? super Entry<K,V>> action;
5524		ForEachEntryTask
5525		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
5526	<	Block<? super Entry<K,V>> action) {
5526	>	Consumer<? super Entry<K,V>> action) {
5527		super(m, p, b);
5528		this.action = action;
5529		}
5530		public final void compute() {
5531	<	final Block<? super Entry<K,V>> action;
5531	>	final Consumer<? super Entry<K,V>> action;
5532		if ((action = this.action) != null) {
5533		for (int b; (b = preSplit()) > 0;)
5534		new ForEachEntryTask<K,V>(map, this, b, action).fork();
#	Line 5542 | Line 5542 | public class ConcurrentHashMap<K, V>
5542
5543		@SuppressWarnings("serial") static final class ForEachMappingTask<K,V>
5544		extends Traverser<K,V,Void> {
5545	<	final BiBlock<? super K, ? super V> action;
5545	>	final BiConsumer<? super K, ? super V> action;
5546		ForEachMappingTask
5547		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
5548	<	BiBlock<? super K,? super V> action) {
5548	>	BiConsumer<? super K,? super V> action) {
5549		super(m, p, b);
5550		this.action = action;
5551		}
5552		public final void compute() {
5553	<	final BiBlock<? super K, ? super V> action;
5553	>	final BiConsumer<? super K, ? super V> action;
5554		if ((action = this.action) != null) {
5555		for (int b; (b = preSplit()) > 0;)
5556		new ForEachMappingTask<K,V>(map, this, b, action).fork();
#	Line 5565 | Line 5565 | public class ConcurrentHashMap<K, V>
5565		@SuppressWarnings("serial") static final class ForEachTransformedKeyTask<K,V,U>
5566		extends Traverser<K,V,Void> {
5567		final Function<? super K, ? extends U> transformer;
5568	<	final Block<? super U> action;
5568	>	final Consumer<? super U> action;
5569		ForEachTransformedKeyTask
5570		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
5571	<	Function<? super K, ? extends U> transformer, Block<? super U> action) {
5571	>	Function<? super K, ? extends U> transformer, Consumer<? super U> action) {
5572		super(m, p, b);
5573		this.transformer = transformer; this.action = action;
5574		}
5575		public final void compute() {
5576		final Function<? super K, ? extends U> transformer;
5577	<	final Block<? super U> action;
5577	>	final Consumer<? super U> action;
5578		if ((transformer = this.transformer) != null &&
5579		(action = this.action) != null) {
5580		for (int b; (b = preSplit()) > 0;)
#	Line 5593 | Line 5593 | public class ConcurrentHashMap<K, V>
5593		@SuppressWarnings("serial") static final class ForEachTransformedValueTask<K,V,U>
5594		extends Traverser<K,V,Void> {
5595		final Function<? super V, ? extends U> transformer;
5596	<	final Block<? super U> action;
5596	>	final Consumer<? super U> action;
5597		ForEachTransformedValueTask
5598		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
5599	<	Function<? super V, ? extends U> transformer, Block<? super U> action) {
5599	>	Function<? super V, ? extends U> transformer, Consumer<? super U> action) {
5600		super(m, p, b);
5601		this.transformer = transformer; this.action = action;
5602		}
5603		public final void compute() {
5604		final Function<? super V, ? extends U> transformer;
5605	<	final Block<? super U> action;
5605	>	final Consumer<? super U> action;
5606		if ((transformer = this.transformer) != null &&
5607		(action = this.action) != null) {
5608		for (int b; (b = preSplit()) > 0;)
#	Line 5621 | Line 5621 | public class ConcurrentHashMap<K, V>
5621		@SuppressWarnings("serial") static final class ForEachTransformedEntryTask<K,V,U>
5622		extends Traverser<K,V,Void> {
5623		final Function<Map.Entry<K,V>, ? extends U> transformer;
5624	<	final Block<? super U> action;
5624	>	final Consumer<? super U> action;
5625		ForEachTransformedEntryTask
5626		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
5627	<	Function<Map.Entry<K,V>, ? extends U> transformer, Block<? super U> action) {
5627	>	Function<Map.Entry<K,V>, ? extends U> transformer, Consumer<? super U> action) {
5628		super(m, p, b);
5629		this.transformer = transformer; this.action = action;
5630		}
5631		public final void compute() {
5632		final Function<Map.Entry<K,V>, ? extends U> transformer;
5633	<	final Block<? super U> action;
5633	>	final Consumer<? super U> action;
5634		if ((transformer = this.transformer) != null &&
5635		(action = this.action) != null) {
5636		for (int b; (b = preSplit()) > 0;)
#	Line 5650 | Line 5650 | public class ConcurrentHashMap<K, V>
5650		@SuppressWarnings("serial") static final class ForEachTransformedMappingTask<K,V,U>
5651		extends Traverser<K,V,Void> {
5652		final BiFunction<? super K, ? super V, ? extends U> transformer;
5653	<	final Block<? super U> action;
5653	>	final Consumer<? super U> action;
5654		ForEachTransformedMappingTask
5655		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
5656		BiFunction<? super K, ? super V, ? extends U> transformer,
5657	<	Block<? super U> action) {
5657	>	Consumer<? super U> action) {
5658		super(m, p, b);
5659		this.transformer = transformer; this.action = action;
5660		}
5661		public final void compute() {
5662		final BiFunction<? super K, ? super V, ? extends U> transformer;
5663	<	final Block<? super U> action;
5663	>	final Consumer<? super U> action;
5664		if ((transformer = this.transformer) != null &&
5665		(action = this.action) != null) {
5666		for (int b; (b = preSplit()) > 0;)
#	Line 6160 | Line 6160 | public class ConcurrentHashMap<K, V>
6160
6161		@SuppressWarnings("serial") static final class MapReduceKeysToDoubleTask<K,V>
6162		extends Traverser<K,V,Double> {
6163	<	final DoubleFunction<? super K> transformer;
6163	>	final ToDoubleFunction<? super K> transformer;
6164		final DoubleBinaryOperator reducer;
6165		final double basis;
6166		double result;
#	Line 6168 | Line 6168 | public class ConcurrentHashMap<K, V>
6168		MapReduceKeysToDoubleTask
6169		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6170		MapReduceKeysToDoubleTask<K,V> nextRight,
6171	<	DoubleFunction<? super K> transformer,
6171	>	ToDoubleFunction<? super K> transformer,
6172		double basis,
6173		DoubleBinaryOperator reducer) {
6174		super(m, p, b); this.nextRight = nextRight;
#	Line 6177 | Line 6177 | public class ConcurrentHashMap<K, V>
6177		}
6178		public final Double getRawResult() { return result; }
6179		@SuppressWarnings("unchecked") public final void compute() {
6180	<	final DoubleFunction<? super K> transformer;
6180	>	final ToDoubleFunction<? super K> transformer;
6181		final DoubleBinaryOperator reducer;
6182		if ((transformer = this.transformer) != null &&
6183		(reducer = this.reducer) != null) {
#	Line 6204 | Line 6204 | public class ConcurrentHashMap<K, V>
6204
6205		@SuppressWarnings("serial") static final class MapReduceValuesToDoubleTask<K,V>
6206		extends Traverser<K,V,Double> {
6207	<	final DoubleFunction<? super V> transformer;
6207	>	final ToDoubleFunction<? super V> transformer;
6208		final DoubleBinaryOperator reducer;
6209		final double basis;
6210		double result;
#	Line 6212 | Line 6212 | public class ConcurrentHashMap<K, V>
6212		MapReduceValuesToDoubleTask
6213		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6214		MapReduceValuesToDoubleTask<K,V> nextRight,
6215	<	DoubleFunction<? super V> transformer,
6215	>	ToDoubleFunction<? super V> transformer,
6216		double basis,
6217		DoubleBinaryOperator reducer) {
6218		super(m, p, b); this.nextRight = nextRight;
#	Line 6221 | Line 6221 | public class ConcurrentHashMap<K, V>
6221		}
6222		public final Double getRawResult() { return result; }
6223		@SuppressWarnings("unchecked") public final void compute() {
6224	<	final DoubleFunction<? super V> transformer;
6224	>	final ToDoubleFunction<? super V> transformer;
6225		final DoubleBinaryOperator reducer;
6226		if ((transformer = this.transformer) != null &&
6227		(reducer = this.reducer) != null) {
#	Line 6249 | Line 6249 | public class ConcurrentHashMap<K, V>
6249
6250		@SuppressWarnings("serial") static final class MapReduceEntriesToDoubleTask<K,V>
6251		extends Traverser<K,V,Double> {
6252	<	final DoubleFunction<Map.Entry<K,V>> transformer;
6252	>	final ToDoubleFunction<Map.Entry<K,V>> transformer;
6253		final DoubleBinaryOperator reducer;
6254		final double basis;
6255		double result;
#	Line 6257 | Line 6257 | public class ConcurrentHashMap<K, V>
6257		MapReduceEntriesToDoubleTask
6258		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6259		MapReduceEntriesToDoubleTask<K,V> nextRight,
6260	<	DoubleFunction<Map.Entry<K,V>> transformer,
6260	>	ToDoubleFunction<Map.Entry<K,V>> transformer,
6261		double basis,
6262		DoubleBinaryOperator reducer) {
6263		super(m, p, b); this.nextRight = nextRight;
#	Line 6266 | Line 6266 | public class ConcurrentHashMap<K, V>
6266		}
6267		public final Double getRawResult() { return result; }
6268		@SuppressWarnings("unchecked") public final void compute() {
6269	<	final DoubleFunction<Map.Entry<K,V>> transformer;
6269	>	final ToDoubleFunction<Map.Entry<K,V>> transformer;
6270		final DoubleBinaryOperator reducer;
6271		if ((transformer = this.transformer) != null &&
6272		(reducer = this.reducer) != null) {
#	Line 6295 | Line 6295 | public class ConcurrentHashMap<K, V>
6295
6296		@SuppressWarnings("serial") static final class MapReduceMappingsToDoubleTask<K,V>
6297		extends Traverser<K,V,Double> {
6298	<	final DoubleBiFunction<? super K, ? super V> transformer;
6298	>	final ToDoubleBiFunction<? super K, ? super V> transformer;
6299		final DoubleBinaryOperator reducer;
6300		final double basis;
6301		double result;
#	Line 6303 | Line 6303 | public class ConcurrentHashMap<K, V>
6303		MapReduceMappingsToDoubleTask
6304		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6305		MapReduceMappingsToDoubleTask<K,V> nextRight,
6306	<	DoubleBiFunction<? super K, ? super V> transformer,
6306	>	ToDoubleBiFunction<? super K, ? super V> transformer,
6307		double basis,
6308		DoubleBinaryOperator reducer) {
6309		super(m, p, b); this.nextRight = nextRight;
#	Line 6312 | Line 6312 | public class ConcurrentHashMap<K, V>
6312		}
6313		public final Double getRawResult() { return result; }
6314		@SuppressWarnings("unchecked") public final void compute() {
6315	<	final DoubleBiFunction<? super K, ? super V> transformer;
6315	>	final ToDoubleBiFunction<? super K, ? super V> transformer;
6316		final DoubleBinaryOperator reducer;
6317		if ((transformer = this.transformer) != null &&
6318		(reducer = this.reducer) != null) {
#	Line 6340 | Line 6340 | public class ConcurrentHashMap<K, V>
6340
6341		@SuppressWarnings("serial") static final class MapReduceKeysToLongTask<K,V>
6342		extends Traverser<K,V,Long> {
6343	<	final LongFunction<? super K> transformer;
6343	>	final ToLongFunction<? super K> transformer;
6344		final LongBinaryOperator reducer;
6345		final long basis;
6346		long result;
#	Line 6348 | Line 6348 | public class ConcurrentHashMap<K, V>
6348		MapReduceKeysToLongTask
6349		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6350		MapReduceKeysToLongTask<K,V> nextRight,
6351	<	LongFunction<? super K> transformer,
6351	>	ToLongFunction<? super K> transformer,
6352		long basis,
6353		LongBinaryOperator reducer) {
6354		super(m, p, b); this.nextRight = nextRight;
#	Line 6357 | Line 6357 | public class ConcurrentHashMap<K, V>
6357		}
6358		public final Long getRawResult() { return result; }
6359		@SuppressWarnings("unchecked") public final void compute() {
6360	<	final LongFunction<? super K> transformer;
6360	>	final ToLongFunction<? super K> transformer;
6361		final LongBinaryOperator reducer;
6362		if ((transformer = this.transformer) != null &&
6363		(reducer = this.reducer) != null) {
#	Line 6384 | Line 6384 | public class ConcurrentHashMap<K, V>
6384
6385		@SuppressWarnings("serial") static final class MapReduceValuesToLongTask<K,V>
6386		extends Traverser<K,V,Long> {
6387	<	final LongFunction<? super V> transformer;
6387	>	final ToLongFunction<? super V> transformer;
6388		final LongBinaryOperator reducer;
6389		final long basis;
6390		long result;
#	Line 6392 | Line 6392 | public class ConcurrentHashMap<K, V>
6392		MapReduceValuesToLongTask
6393		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6394		MapReduceValuesToLongTask<K,V> nextRight,
6395	<	LongFunction<? super V> transformer,
6395	>	ToLongFunction<? super V> transformer,
6396		long basis,
6397		LongBinaryOperator reducer) {
6398		super(m, p, b); this.nextRight = nextRight;
#	Line 6401 | Line 6401 | public class ConcurrentHashMap<K, V>
6401		}
6402		public final Long getRawResult() { return result; }
6403		@SuppressWarnings("unchecked") public final void compute() {
6404	<	final LongFunction<? super V> transformer;
6404	>	final ToLongFunction<? super V> transformer;
6405		final LongBinaryOperator reducer;
6406		if ((transformer = this.transformer) != null &&
6407		(reducer = this.reducer) != null) {
#	Line 6429 | Line 6429 | public class ConcurrentHashMap<K, V>
6429
6430		@SuppressWarnings("serial") static final class MapReduceEntriesToLongTask<K,V>
6431		extends Traverser<K,V,Long> {
6432	<	final LongFunction<Map.Entry<K,V>> transformer;
6432	>	final ToLongFunction<Map.Entry<K,V>> transformer;
6433		final LongBinaryOperator reducer;
6434		final long basis;
6435		long result;
#	Line 6437 | Line 6437 | public class ConcurrentHashMap<K, V>
6437		MapReduceEntriesToLongTask
6438		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6439		MapReduceEntriesToLongTask<K,V> nextRight,
6440	<	LongFunction<Map.Entry<K,V>> transformer,
6440	>	ToLongFunction<Map.Entry<K,V>> transformer,
6441		long basis,
6442		LongBinaryOperator reducer) {
6443		super(m, p, b); this.nextRight = nextRight;
#	Line 6446 | Line 6446 | public class ConcurrentHashMap<K, V>
6446		}
6447		public final Long getRawResult() { return result; }
6448		@SuppressWarnings("unchecked") public final void compute() {
6449	<	final LongFunction<Map.Entry<K,V>> transformer;
6449	>	final ToLongFunction<Map.Entry<K,V>> transformer;
6450		final LongBinaryOperator reducer;
6451		if ((transformer = this.transformer) != null &&
6452		(reducer = this.reducer) != null) {
#	Line 6474 | Line 6474 | public class ConcurrentHashMap<K, V>
6474
6475		@SuppressWarnings("serial") static final class MapReduceMappingsToLongTask<K,V>
6476		extends Traverser<K,V,Long> {
6477	<	final LongBiFunction<? super K, ? super V> transformer;
6477	>	final ToLongBiFunction<? super K, ? super V> transformer;
6478		final LongBinaryOperator reducer;
6479		final long basis;
6480		long result;
#	Line 6482 | Line 6482 | public class ConcurrentHashMap<K, V>
6482		MapReduceMappingsToLongTask
6483		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6484		MapReduceMappingsToLongTask<K,V> nextRight,
6485	<	LongBiFunction<? super K, ? super V> transformer,
6485	>	ToLongBiFunction<? super K, ? super V> transformer,
6486		long basis,
6487		LongBinaryOperator reducer) {
6488		super(m, p, b); this.nextRight = nextRight;
#	Line 6491 | Line 6491 | public class ConcurrentHashMap<K, V>
6491		}
6492		public final Long getRawResult() { return result; }
6493		@SuppressWarnings("unchecked") public final void compute() {
6494	<	final LongBiFunction<? super K, ? super V> transformer;
6494	>	final ToLongBiFunction<? super K, ? super V> transformer;
6495		final LongBinaryOperator reducer;
6496		if ((transformer = this.transformer) != null &&
6497		(reducer = this.reducer) != null) {
#	Line 6519 | Line 6519 | public class ConcurrentHashMap<K, V>
6519
6520		@SuppressWarnings("serial") static final class MapReduceKeysToIntTask<K,V>
6521		extends Traverser<K,V,Integer> {
6522	<	final IntFunction<? super K> transformer;
6522	>	final ToIntFunction<? super K> transformer;
6523		final IntBinaryOperator reducer;
6524		final int basis;
6525		int result;
#	Line 6527 | Line 6527 | public class ConcurrentHashMap<K, V>
6527		MapReduceKeysToIntTask
6528		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6529		MapReduceKeysToIntTask<K,V> nextRight,
6530	<	IntFunction<? super K> transformer,
6530	>	ToIntFunction<? super K> transformer,
6531		int basis,
6532		IntBinaryOperator reducer) {
6533		super(m, p, b); this.nextRight = nextRight;
#	Line 6536 | Line 6536 | public class ConcurrentHashMap<K, V>
6536		}
6537		public final Integer getRawResult() { return result; }
6538		@SuppressWarnings("unchecked") public final void compute() {
6539	<	final IntFunction<? super K> transformer;
6539	>	final ToIntFunction<? super K> transformer;
6540		final IntBinaryOperator reducer;
6541		if ((transformer = this.transformer) != null &&
6542		(reducer = this.reducer) != null) {
#	Line 6563 | Line 6563 | public class ConcurrentHashMap<K, V>
6563
6564		@SuppressWarnings("serial") static final class MapReduceValuesToIntTask<K,V>
6565		extends Traverser<K,V,Integer> {
6566	<	final IntFunction<? super V> transformer;
6566	>	final ToIntFunction<? super V> transformer;
6567		final IntBinaryOperator reducer;
6568		final int basis;
6569		int result;
#	Line 6571 | Line 6571 | public class ConcurrentHashMap<K, V>
6571		MapReduceValuesToIntTask
6572		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6573		MapReduceValuesToIntTask<K,V> nextRight,
6574	<	IntFunction<? super V> transformer,
6574	>	ToIntFunction<? super V> transformer,
6575		int basis,
6576		IntBinaryOperator reducer) {
6577		super(m, p, b); this.nextRight = nextRight;
#	Line 6580 | Line 6580 | public class ConcurrentHashMap<K, V>
6580		}
6581		public final Integer getRawResult() { return result; }
6582		@SuppressWarnings("unchecked") public final void compute() {
6583	<	final IntFunction<? super V> transformer;
6583	>	final ToIntFunction<? super V> transformer;
6584		final IntBinaryOperator reducer;
6585		if ((transformer = this.transformer) != null &&
6586		(reducer = this.reducer) != null) {
#	Line 6608 | Line 6608 | public class ConcurrentHashMap<K, V>
6608
6609		@SuppressWarnings("serial") static final class MapReduceEntriesToIntTask<K,V>
6610		extends Traverser<K,V,Integer> {
6611	<	final IntFunction<Map.Entry<K,V>> transformer;
6611	>	final ToIntFunction<Map.Entry<K,V>> transformer;
6612		final IntBinaryOperator reducer;
6613		final int basis;
6614		int result;
#	Line 6616 | Line 6616 | public class ConcurrentHashMap<K, V>
6616		MapReduceEntriesToIntTask
6617		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6618		MapReduceEntriesToIntTask<K,V> nextRight,
6619	<	IntFunction<Map.Entry<K,V>> transformer,
6619	>	ToIntFunction<Map.Entry<K,V>> transformer,
6620		int basis,
6621		IntBinaryOperator reducer) {
6622		super(m, p, b); this.nextRight = nextRight;
#	Line 6625 | Line 6625 | public class ConcurrentHashMap<K, V>
6625		}
6626		public final Integer getRawResult() { return result; }
6627		@SuppressWarnings("unchecked") public final void compute() {
6628	<	final IntFunction<Map.Entry<K,V>> transformer;
6628	>	final ToIntFunction<Map.Entry<K,V>> transformer;
6629		final IntBinaryOperator reducer;
6630		if ((transformer = this.transformer) != null &&
6631		(reducer = this.reducer) != null) {
#	Line 6654 | Line 6654 | public class ConcurrentHashMap<K, V>
6654
6655		@SuppressWarnings("serial") static final class MapReduceMappingsToIntTask<K,V>
6656		extends Traverser<K,V,Integer> {
6657	<	final IntBiFunction<? super K, ? super V> transformer;
6657	>	final ToIntBiFunction<? super K, ? super V> transformer;
6658		final IntBinaryOperator reducer;
6659		final int basis;
6660		int result;
#	Line 6662 | Line 6662 | public class ConcurrentHashMap<K, V>
6662		MapReduceMappingsToIntTask
6663		(ConcurrentHashMap<K,V> m, Traverser<K,V,?> p, int b,
6664		MapReduceMappingsToIntTask<K,V> nextRight,
6665	<	IntBiFunction<? super K, ? super V> transformer,
6665	>	ToIntBiFunction<? super K, ? super V> transformer,
6666		int basis,
6667		IntBinaryOperator reducer) {
6668		super(m, p, b); this.nextRight = nextRight;
#	Line 6671 | Line 6671 | public class ConcurrentHashMap<K, V>
6671		}
6672		public final Integer getRawResult() { return result; }
6673		@SuppressWarnings("unchecked") public final void compute() {
6674	<	final IntBiFunction<? super K, ? super V> transformer;
6674	>	final ToIntBiFunction<? super K, ? super V> transformer;
6675		final IntBinaryOperator reducer;
6676		if ((transformer = this.transformer) != null &&
6677		(reducer = this.reducer) != null) {

Diff Legend

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