Interface IntCacheStream
- All Superinterfaces:
AutoCloseable
,BaseCacheStream<Integer,
,IntStream> BaseStream<Integer,
,IntStream> IntStream
- All Known Implementing Classes:
DistributedIntCacheStream
,IntermediateIntCacheStream
IntStream
that has additional methods to allow for Serializable instances. Please see
CacheStream
for additional details about various methods.- Since:
- 9.0
- Author:
- wburns
-
Nested Class Summary
Nested classes/interfaces inherited from interface org.infinispan.BaseCacheStream
BaseCacheStream.SegmentCompletionListener
Nested classes/interfaces inherited from interface java.util.stream.IntStream
IntStream.Builder
-
Method Summary
Modifier and TypeMethodDescriptiondefault boolean
allMatch
(SerializableIntPredicate predicate) Same asIntStream.allMatch(IntPredicate)
except that the IntPredicate must also implementSerializable
default boolean
anyMatch
(SerializableIntPredicate predicate) Same asIntStream.anyMatch(IntPredicate)
except that the IntPredicate must also implementSerializable
boxed()
default <R> R
collect
(SerializableSupplier<R> supplier, SerializableObjIntConsumer<R> accumulator, SerializableBiConsumer<R, R> combiner) Same asIntStream.collect(Supplier, ObjIntConsumer, BiConsumer)
except that the arguments must also implementSerializable
Disables tracking of rehash events that could occur to the underlying cache.distinct()
distributedBatchSize
(int batchSize) Controls how many keys are returned from a remote node when using a stream terminal operation with a distributed cache to back this stream.filter
(IntPredicate predicate) default IntCacheStream
filter
(SerializableIntPredicate predicate) Same asfilter(IntPredicate)
except that the IntPredicate must also implementSerializable
filterKeys
(Set<?> keys) Filters which entries are returned by only returning ones that map to the given key.filterKeySegments
(Set<Integer> segments) Filters which entries are returned by what segment they are present in.flatMap
(IntFunction<? extends IntStream> mapper) default IntCacheStream
flatMap
(SerializableIntFunction<? extends IntStream> mapper) Same asflatMap(IntFunction)
except that the IntFunction must also implementSerializable
<K,
V> void forEach
(ObjIntConsumer<Cache<K, V>> action) Same asIntStream.forEach(IntConsumer)
except that it takes anObjIntConsumer
that provides access to the underlyingCache
that is backing this stream.default void
forEach
(SerializableIntConsumer action) Same asIntStream.forEach(IntConsumer)
except that the IntConsumer must also implementSerializable
default <K,
V> void forEach
(SerializableObjIntConsumer<Cache<K, V>> action) limit
(long maxSize) map
(IntUnaryOperator mapper) default IntCacheStream
map
(SerializableIntUnaryOperator mapper) Same asmap(IntUnaryOperator)
except that the IntUnaryOperator must also implementSerializable
mapToDouble
(IntToDoubleFunction mapper) default DoubleCacheStream
Same asmapToDouble(IntToDoubleFunction)
except that the IntToIntFunction must also implementSerializable
mapToLong
(IntToLongFunction mapper) default LongCacheStream
Same asmapToLong(IntToLongFunction)
except that the IntToLongFunction must also implementSerializable
<U> CacheStream
<U> mapToObj
(IntFunction<? extends U> mapper) default <U> CacheStream
<U> mapToObj
(SerializableIntFunction<? extends U> mapper) Same asmapToObj(IntFunction)
except that the IntFunction must also implementSerializable
default boolean
noneMatch
(SerializableIntPredicate predicate) Same asIntStream.noneMatch(IntPredicate)
except that the IntPredicate must also implementSerializable
parallel()
This would enable sending requests to all other remote nodes when a terminal operator is performed.peek
(IntConsumer action) default IntCacheStream
peek
(SerializableIntConsumer action) Same asflatMap(IntFunction)
except that the IntFunction must also implementSerializable
default int
reduce
(int identity, SerializableIntBinaryOperator op) Same asIntStream.reduce(int, IntBinaryOperator)
except that the IntBinaryOperator must also implementSerializable
default OptionalInt
Same asIntStream.reduce(IntBinaryOperator)
except that the IntBinaryOperator must also implementSerializable
Allows registration of a segment completion listener that is notified when a segment has completed processing.This would disable sending requests to all other remote nodes compared to one at a time.skip
(long n) sorted()
Sets a given time to wait for a remote operation to respond by.Methods inherited from interface org.infinispan.BaseCacheStream
filterKeySegments
Methods inherited from interface java.util.stream.BaseStream
close, isParallel
-
Method Details
-
sequentialDistribution
IntCacheStream sequentialDistribution()This would disable sending requests to all other remote nodes compared to one at a time. This can reduce memory pressure on the originator node at the cost of performance.Parallel distribution is enabled by default except for
CacheStream.iterator()
andCacheStream.spliterator()
- Specified by:
sequentialDistribution
in interfaceBaseCacheStream<Integer,
IntStream> - Returns:
- a stream with parallel distribution disabled.
-
parallelDistribution
IntCacheStream parallelDistribution()Description copied from interface:BaseCacheStream
This would enable sending requests to all other remote nodes when a terminal operator is performed. This requires additional overhead as it must process results concurrently from various nodes, but should perform faster in the majority of cases.Parallel distribution is enabled by default except for
CacheStream.iterator()
andCacheStream.spliterator()
- Specified by:
parallelDistribution
in interfaceBaseCacheStream<Integer,
IntStream> - Returns:
- a stream with parallel distribution enabled.
-
filterKeySegments
Filters which entries are returned by what segment they are present in. This method can be substantially more efficient than using a regularCacheStream.filter(Predicate)
method as this can control what nodes are asked for data and what entries are read from the underlying CacheStore if present.- Specified by:
filterKeySegments
in interfaceBaseCacheStream<Integer,
IntStream> - Parameters:
segments
- The segments to use for this stream operation. Any segments not in this set will be ignored.- Returns:
- a stream with the segments filtered.
-
filterKeys
Filters which entries are returned by only returning ones that map to the given key. This method will be faster than a regularCacheStream.filter(Predicate)
if the filter is holding references to the same keys.- Specified by:
filterKeys
in interfaceBaseCacheStream<Integer,
IntStream> - Parameters:
keys
- The keys that this stream will only operate on.- Returns:
- a stream with the keys filtered.
-
distributedBatchSize
Controls how many keys are returned from a remote node when using a stream terminal operation with a distributed cache to back this stream. This value is ignored when terminal operators that don't track keys are used. Key tracking terminal operators areCacheStream.iterator()
,CacheStream.spliterator()
,CacheStream.forEach(Consumer)
. Please see those methods for additional information on how this value may affect them.This value may be used in the case of a a terminal operator that doesn't track keys if an intermediate operation is performed that requires bringing keys locally to do computations. Examples of such intermediate operations are
CacheStream.sorted()
,CacheStream.sorted(Comparator)
,CacheStream.distinct()
,CacheStream.limit(long)
,CacheStream.skip(long)
This value is always ignored when this stream is backed by a cache that is not distributed as all values are already local.
- Specified by:
distributedBatchSize
in interfaceBaseCacheStream<Integer,
IntStream> - Parameters:
batchSize
- The size of each batch. This defaults to the state transfer chunk size.- Returns:
- a stream with the batch size updated
-
segmentCompletionListener
Allows registration of a segment completion listener that is notified when a segment has completed processing. If the terminal operator has a short circuit this listener may never be called.This method is designed for the sole purpose of use with the
CacheStream.iterator()
to allow for a user to track completion of segments as they are returned from the iterator. Behavior of other methods is not specified. Please seeCacheStream.iterator()
for more information.Multiple listeners may be registered upon multiple invocations of this method. The ordering of notified listeners is not specified.
This is only used if this stream did not invoke
BaseCacheStream.disableRehashAware()
and has no flat map based operations. If this is done no segments will be notified.- Specified by:
segmentCompletionListener
in interfaceBaseCacheStream<Integer,
IntStream> - Parameters:
listener
- The listener that will be called back as segments are completed.- Returns:
- a stream with the listener registered.
-
disableRehashAware
IntCacheStream disableRehashAware()Disables tracking of rehash events that could occur to the underlying cache. If a rehash event occurs while a terminal operation is being performed it is possible for some values that are in the cache to not be found. Note that you will never have an entry duplicated when rehash awareness is disabled, only lost values.Most terminal operations will run faster with rehash awareness disabled even without a rehash occuring. However if a rehash occurs with this disabled be prepared to possibly receive only a subset of values.
- Specified by:
disableRehashAware
in interfaceBaseCacheStream<Integer,
IntStream> - Returns:
- a stream with rehash awareness disabled.
-
timeout
Sets a given time to wait for a remote operation to respond by. This timeout does nothing if the terminal operation does not go remote.If a timeout does occur then a
TimeoutException
is thrown from the terminal operation invoking thread or on the next call to theIterator
orSpliterator
.Note that if a rehash occurs this timeout value is reset for the subsequent retry if rehash aware is enabled.
- Specified by:
timeout
in interfaceBaseCacheStream<Integer,
IntStream> - Parameters:
timeout
- the maximum time to waitunit
- the time unit of the timeout argument- Returns:
- a stream with the timeout set
-
filter
-
filter
Same asfilter(IntPredicate)
except that the IntPredicate must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
predicate
- a non-interfering, stateless predicate to apply to each element to determine if it should be included- Returns:
- the new cache int stream
-
map
-
map
Same asmap(IntUnaryOperator)
except that the IntUnaryOperator must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
mapper
- a non-interfering, stateless function to apply to each element- Returns:
- the new cache int stream
-
mapToObj
-
mapToObj
Same asmapToObj(IntFunction)
except that the IntFunction must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Type Parameters:
U
- the element type of the new stream- Parameters:
mapper
- a non-interfering, stateless function to apply to each element- Returns:
- the new cache stream
-
mapToDouble
- Specified by:
mapToDouble
in interfaceIntStream
- Returns:
- the new cache double stream
-
mapToDouble
Same asmapToDouble(IntToDoubleFunction)
except that the IntToIntFunction must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
mapper
- a non-interfering, stateless function to apply to each element- Returns:
- the new cache double stream
-
mapToLong
-
mapToLong
Same asmapToLong(IntToLongFunction)
except that the IntToLongFunction must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
mapper
- a non-interfering, stateless function to apply to each element- Returns:
- the new cache long stream
-
flatMap
-
flatMap
Same asflatMap(IntFunction)
except that the IntFunction must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
mapper
- a non-interfering, stateless function to apply to each element which produces aIntStream
of new values- Returns:
- the new cache int stream
-
distinct
IntCacheStream distinct() -
sorted
IntCacheStream sorted() -
peek
-
peek
Same asflatMap(IntFunction)
except that the IntFunction must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
action
- a non-interfering action to perform on the elements as they are consumed from the stream- Returns:
- the new cache int stream
-
limit
-
skip
-
forEach
Same asIntStream.forEach(IntConsumer)
except that the IntConsumer must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
action
- a non-interfering action to perform on the elements
-
forEach
Same asIntStream.forEach(IntConsumer)
except that it takes anObjIntConsumer
that provides access to the underlyingCache
that is backing this stream.Note that the
CacheAware
interface is not supported for injection using this method as the cache is provided in the consumer directly.- Type Parameters:
K
- key type of the cacheV
- value type of the cache- Parameters:
action
- consumer to be ran for each element in the stream
-
forEach
- Type Parameters:
K
- key type of the cacheV
- value type of the cache- Parameters:
action
- consumer to be ran for each element in the stream
-
reduce
Same asIntStream.reduce(int, IntBinaryOperator)
except that the IntBinaryOperator must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
identity
- the identity value for the accumulating functionop
- an associative, non-interfering, stateless function for combining two values- Returns:
- the result of the reduction
-
reduce
Same asIntStream.reduce(IntBinaryOperator)
except that the IntBinaryOperator must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
op
- an associative, non-interfering, stateless function for combining two values- Returns:
- the result of the reduction
-
collect
default <R> R collect(SerializableSupplier<R> supplier, SerializableObjIntConsumer<R> accumulator, SerializableBiConsumer<R, R> combiner) Same asIntStream.collect(Supplier, ObjIntConsumer, BiConsumer)
except that the arguments must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Type Parameters:
R
- type of the result- Parameters:
supplier
- a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.accumulator
- an associative, non-interfering, stateless function for incorporating an additional element into a resultcombiner
- an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function- Returns:
- the result of the reduction
-
anyMatch
Same asIntStream.anyMatch(IntPredicate)
except that the IntPredicate must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
predicate
- a non-interfering, stateless predicate to apply to elements of this stream- Returns:
true
if any elements of the stream match the provided predicate, otherwisefalse
-
allMatch
Same asIntStream.allMatch(IntPredicate)
except that the IntPredicate must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
predicate
- a non-interfering, stateless predicate to apply to elements of this stream- Returns:
true
if either all elements of the stream match the provided predicate or the stream is empty, otherwisefalse
-
noneMatch
Same asIntStream.noneMatch(IntPredicate)
except that the IntPredicate must also implementSerializable
The compiler will pick this overload for lambda parameters, making them
Serializable
- Parameters:
predicate
- a non-interfering, stateless predicate to apply to elements of this stream- Returns:
true
if either no elements of the stream match the provided predicate or the stream is empty, otherwisefalse
-
boxed
CacheStream<Integer> boxed() -
asDoubleStream
DoubleCacheStream asDoubleStream()- Specified by:
asDoubleStream
in interfaceIntStream
- Returns:
- the cache double stream
-
asLongStream
LongCacheStream asLongStream()- Specified by:
asLongStream
in interfaceIntStream
- Returns:
- the cache long stream
-
sequential
IntCacheStream sequential()- Specified by:
sequential
in interfaceBaseStream<Integer,
IntStream> - Specified by:
sequential
in interfaceIntStream
- Returns:
- a sequential cache int stream
-
parallel
IntCacheStream parallel() -
unordered
IntCacheStream unordered()- Specified by:
unordered
in interfaceBaseStream<Integer,
IntStream> - Returns:
- an unordered cache int stream
-
onClose
- Specified by:
onClose
in interfaceBaseStream<Integer,
IntStream> - Returns:
- a cache int stream with the handler applied
-