169 // LongStream
170
171 @Override
172 public final PrimitiveIterator.OfLong iterator() {
173 return Spliterators.iterator(spliterator());
174 }
175
176 @Override
177 public final Spliterator.OfLong spliterator() {
178 return adapt(super.spliterator());
179 }
180
181 // Stateless intermediate ops from LongStream
182
183 @Override
184 public final DoubleStream asDoubleStream() {
185 return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
186 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
187 @Override
188 Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
189 return new Sink.ChainedLong(sink) {
190 @Override
191 public void accept(long t) {
192 downstream.accept((double) t);
193 }
194 };
195 }
196 };
197 }
198
199 @Override
200 public final Stream<Long> boxed() {
201 return mapToObj(Long::valueOf);
202 }
203
204 @Override
205 public final LongStream map(LongUnaryOperator mapper) {
206 Objects.requireNonNull(mapper);
207 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
208 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
209 @Override
210 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
211 return new Sink.ChainedLong(sink) {
212 @Override
213 @SuppressWarnings("unchecked")
214 public void accept(long t) {
215 downstream.accept(mapper.applyAsLong(t));
216 }
217 };
218 }
219 };
220 }
221
222 @Override
223 public final <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
224 Objects.requireNonNull(mapper);
225 return new ReferencePipeline.StatelessOp<Long, U>(this, StreamShape.LONG_VALUE,
226 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
227 @Override
228 Sink<Long> opWrapSink(int flags, Sink<U> sink) {
229 return new Sink.ChainedLong(sink) {
230 @Override
231 @SuppressWarnings("unchecked")
232 public void accept(long t) {
233 downstream.accept(mapper.apply(t));
234 }
235 };
236 }
237 };
238 }
239
240 @Override
241 public final IntStream mapToInt(LongToIntFunction mapper) {
242 Objects.requireNonNull(mapper);
243 return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
244 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
245 @Override
246 Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
247 return new Sink.ChainedLong(sink) {
248 @Override
249 @SuppressWarnings("unchecked")
250 public void accept(long t) {
251 downstream.accept(mapper.applyAsInt(t));
252 }
253 };
254 }
255 };
256 }
257
258 @Override
259 public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
260 Objects.requireNonNull(mapper);
261 return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
262 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
263 @Override
264 Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
265 return new Sink.ChainedLong(sink) {
266 @Override
267 public void accept(long t) {
268 downstream.accept(mapper.applyAsDouble(t));
269 }
270 };
271 }
272 };
273 }
274
275 @Override
276 public final LongStream flatMap(LongFunction<? extends LongStream> mapper) {
277 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
278 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
279 @Override
280 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
281 return new Sink.ChainedLong(sink) {
282 @Override
283 public void begin(long size) {
284 downstream.begin(-1);
285 }
286
287 @Override
288 public void accept(long t) {
289 // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
290 LongStream result = mapper.apply(t);
291 if (result != null)
292 result.sequential().forEach(i -> downstream.accept(i));
293 }
294 };
295 }
296 };
297 }
298
299 @Override
300 public LongStream unordered() {
301 if (!isOrdered())
302 return this;
303 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE, StreamOpFlag.NOT_ORDERED) {
304 @Override
305 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
306 return sink;
307 }
308 };
309 }
310
311 @Override
312 public final LongStream filter(LongPredicate predicate) {
313 Objects.requireNonNull(predicate);
314 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
315 StreamOpFlag.NOT_SIZED) {
316 @Override
317 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
318 return new Sink.ChainedLong(sink) {
319 @Override
320 public void begin(long size) {
321 downstream.begin(-1);
322 }
323
324 @Override
325 public void accept(long t) {
326 if (predicate.test(t))
327 downstream.accept(t);
328 }
329 };
330 }
331 };
332 }
333
334 @Override
335 public final LongStream peek(LongConsumer consumer) {
336 Objects.requireNonNull(consumer);
337 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
338 0) {
339 @Override
340 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
341 return new Sink.ChainedLong(sink) {
342 @Override
343 public void accept(long t) {
344 consumer.accept(t);
345 downstream.accept(t);
346 }
347 };
348 }
349 };
350 }
351
352 // Stateful intermediate ops from LongStream
353
354 private LongStream slice(long skip, long limit) {
355 return SliceOps.makeLong(this, skip, limit);
356 }
357
358 @Override
359 public final LongStream limit(long maxSize) {
360 if (maxSize < 0)
361 throw new IllegalArgumentException(Long.toString(maxSize));
|
169 // LongStream
170
171 @Override
172 public final PrimitiveIterator.OfLong iterator() {
173 return Spliterators.iterator(spliterator());
174 }
175
176 @Override
177 public final Spliterator.OfLong spliterator() {
178 return adapt(super.spliterator());
179 }
180
181 // Stateless intermediate ops from LongStream
182
183 @Override
184 public final DoubleStream asDoubleStream() {
185 return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
186 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
187 @Override
188 Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
189 return new Sink.ChainedLong<Double>(sink) {
190 @Override
191 public void accept(long t) {
192 downstream.accept((double) t);
193 }
194 };
195 }
196 };
197 }
198
199 @Override
200 public final Stream<Long> boxed() {
201 return mapToObj(Long::valueOf);
202 }
203
204 @Override
205 public final LongStream map(LongUnaryOperator mapper) {
206 Objects.requireNonNull(mapper);
207 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
208 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
209 @Override
210 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
211 return new Sink.ChainedLong<Long>(sink) {
212 @Override
213 public void accept(long t) {
214 downstream.accept(mapper.applyAsLong(t));
215 }
216 };
217 }
218 };
219 }
220
221 @Override
222 public final <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
223 Objects.requireNonNull(mapper);
224 return new ReferencePipeline.StatelessOp<Long, U>(this, StreamShape.LONG_VALUE,
225 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
226 @Override
227 Sink<Long> opWrapSink(int flags, Sink<U> sink) {
228 return new Sink.ChainedLong<U>(sink) {
229 @Override
230 public void accept(long t) {
231 downstream.accept(mapper.apply(t));
232 }
233 };
234 }
235 };
236 }
237
238 @Override
239 public final IntStream mapToInt(LongToIntFunction mapper) {
240 Objects.requireNonNull(mapper);
241 return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
242 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
243 @Override
244 Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
245 return new Sink.ChainedLong<Integer>(sink) {
246 @Override
247 public void accept(long t) {
248 downstream.accept(mapper.applyAsInt(t));
249 }
250 };
251 }
252 };
253 }
254
255 @Override
256 public final DoubleStream mapToDouble(LongToDoubleFunction mapper) {
257 Objects.requireNonNull(mapper);
258 return new DoublePipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
259 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
260 @Override
261 Sink<Long> opWrapSink(int flags, Sink<Double> sink) {
262 return new Sink.ChainedLong<Double>(sink) {
263 @Override
264 public void accept(long t) {
265 downstream.accept(mapper.applyAsDouble(t));
266 }
267 };
268 }
269 };
270 }
271
272 @Override
273 public final LongStream flatMap(LongFunction<? extends LongStream> mapper) {
274 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
275 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {
276 @Override
277 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
278 return new Sink.ChainedLong<Long>(sink) {
279 @Override
280 public void begin(long size) {
281 downstream.begin(-1);
282 }
283
284 @Override
285 public void accept(long t) {
286 // We can do better that this too; optimize for depth=0 case and just grab spliterator and forEach it
287 LongStream result = mapper.apply(t);
288 if (result != null)
289 result.sequential().forEach(i -> downstream.accept(i));
290 }
291 };
292 }
293 };
294 }
295
296 @Override
297 public LongStream unordered() {
298 if (!isOrdered())
299 return this;
300 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE, StreamOpFlag.NOT_ORDERED) {
301 @Override
302 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
303 return sink;
304 }
305 };
306 }
307
308 @Override
309 public final LongStream filter(LongPredicate predicate) {
310 Objects.requireNonNull(predicate);
311 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
312 StreamOpFlag.NOT_SIZED) {
313 @Override
314 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
315 return new Sink.ChainedLong<Long>(sink) {
316 @Override
317 public void begin(long size) {
318 downstream.begin(-1);
319 }
320
321 @Override
322 public void accept(long t) {
323 if (predicate.test(t))
324 downstream.accept(t);
325 }
326 };
327 }
328 };
329 }
330
331 @Override
332 public final LongStream peek(LongConsumer consumer) {
333 Objects.requireNonNull(consumer);
334 return new StatelessOp<Long>(this, StreamShape.LONG_VALUE,
335 0) {
336 @Override
337 Sink<Long> opWrapSink(int flags, Sink<Long> sink) {
338 return new Sink.ChainedLong<Long>(sink) {
339 @Override
340 public void accept(long t) {
341 consumer.accept(t);
342 downstream.accept(t);
343 }
344 };
345 }
346 };
347 }
348
349 // Stateful intermediate ops from LongStream
350
351 private LongStream slice(long skip, long limit) {
352 return SliceOps.makeLong(this, skip, limit);
353 }
354
355 @Override
356 public final LongStream limit(long maxSize) {
357 if (maxSize < 0)
358 throw new IllegalArgumentException(Long.toString(maxSize));
|