public ReactiveSeq<Seq<T>> streamGroupedBySizeAndTime(int size, long time, TimeUnit t){ long toRun = t.toNanos(time); return streamBatch(new Subscription(), source->{ return ()->{ List<T> result = new ArrayList<>(); long start = System.nanoTime(); try { while (result.size() < size && checkTime(System.nanoTime(), start, toRun)) { try { T next = source.apply(100l, TimeUnit.MICROSECONDS); if (next != null) { result.add(next); } } catch (Queue.QueueTimeoutException e) { } } }catch(Queue.ClosedQueueException e){ if(result.size()>0) { List list = new ArrayList<>(); list.add(result); throw new ClosedQueueException(list); } } return result; }; }).filter(l->l.size()>0) .map(Seq::fromIterable); }
@Override public void onComplete() { counter.active.decrementAndGet(); counter.subscription.remove(subscription); if (queue != null && counter.active.get() == 0) { if (counter.completable) { if(counter.closing.compareAndSet(false,true)) { counter.closed = true; queue.addContinuation(new Continuation( () -> { final List current = new ArrayList(); while (queue.size() > 0) { try { current.add(queue.get()); }catch(ClosedQueueException e){ break; } } throw new ClosedQueueException( current); })); queue.close(); } } } }
/** * Offer a single datapoint to this Queue * * If the queue is a bounded queue and is full it will block until space comes available or until * offer time out is reached (default is Integer.MAX_VALUE DAYS). * * @param data * data to add * @return self */ @Override public boolean offer(final T data) { if (!open) { throw new ClosedQueueException(); } try { final boolean result = producerWait.offer(() -> this.queue.offer((T) nullSafe(data), this.offerTimeout, this.offerTimeUnit)); if (sizeSignal != null) this.sizeSignal.set(queue.size()); return result; } catch (final InterruptedException e) { Thread.currentThread() .interrupt(); throw ExceptionSoftener.throwSoftenedException(e); } }
@Override public void handleContinuation() { continuation = ReactiveSeq.fromIterable(continuation) .<Optional<Continuation>> map(c -> { try { return Optional.of(c.proceed()); } catch (final Queue.ClosedQueueException e) { return Optional.empty(); } }) .filter(Optional::isPresent) .map(Optional::get) .toList(); if (continuation.size() == 0) { queue.close(); throw new Queue.ClosedQueueException(); } }
@Override default void addToQueue(final Queue queue) { final Continuation continuation = thenSync(queue::add).self(s -> { if (this.getPopulator() .isPoolingActive()) s.peekSync(v -> { throw new CompletedException( v); }); }).runContinuation(() -> {throw new ClosedQueueException(); } ); queue.addContinuation(continuation); }
public void close() { counter.completable = true; if (queue != null && counter.active.get() == 0) { if(counter.closing.compareAndSet(false,true)) { counter.closed = true; queue.addContinuation(new Continuation( () -> { throw new ClosedQueueException(); })); queue.close(); } } }
public boolean completeAsNone(){ return completeExceptionally(new Queue.ClosedQueueException()); } @Override
public void close() { counter.completable = true; if (queue != null && counter.active.get() == 0) { if(counter.closing.compareAndSet(false,true)) { counter.closed = true; queue.addContinuation(new Continuation( () -> { throw new ClosedQueueException(); })); queue.close(); } } }
private T ensureNotPoisonPill(final T data) { if (data instanceof PoisonPill) { throw new ClosedQueueException(); } return data; }
private T ensureOpen(final long timeout, final TimeUnit timeUnit) { throw new ClosedQueueException(); throw new ClosedQueueException();
filtered.source.subscribeAll(e -> { result.complete(true); throw new Queue.ClosedQueueException(); }, t -> {
stream.source.subscribeAll(e -> { result.complete(e); throw new Queue.ClosedQueueException(); }, t -> { result.completeExceptionally(t);
@Override public final boolean allMatch(final Predicate<? super T> c) { Future<Boolean> result = Future.future(); if (async == Type.NO_BACKPRESSURE) { ReactiveStreamX<T> filtered = (ReactiveStreamX<T>) filter(c.negate()); filtered.source.subscribeAll(e -> { result.complete(false); throw new Queue.ClosedQueueException(); }, t -> { result.completeExceptionally(t); }, () -> { if (!result.isDone()) { result.complete(true); } }); } else { ReactiveStreamX<T> filtered = (ReactiveStreamX<T>) filter(c.negate()); filtered.source.subscribe(e -> { result.complete(false); }, t -> { result.completeExceptionally(t); }, () -> { if (!result.isDone()) { result.complete(true); } }).request(1l); } return result.getFuture().join(); }
source.subscribeAll(e -> { result.complete(e); throw new Queue.ClosedQueueException(); }, t -> { result.completeExceptionally(t);
@Override public LazyEither<Throwable, T> findFirstOrError() { if (async == Type.NO_BACKPRESSURE) { Future<T> result = Future.future(); source.subscribeAll(e -> { result.complete(e); throw new Queue.ClosedQueueException(); }, t -> { result.completeExceptionally(t); }, () -> { if (!result.isDone()) { result.complete(null); } }); return LazyEither.fromFuture(result); } return LazyEither.fromPublisher(this); }
@Override public void handleContinuation() { continuation = ReactiveSeq.fromIterable(continuation) .<Optional<Continuation>> map(c -> { try { return Optional.of(c.proceed()); } catch (final Queue.ClosedQueueException e) { return Optional.empty(); } }) .filter(Optional::isPresent) .map(Optional::get) .toList(); if (continuation.size() == 0) { queue.close(); throw new Queue.ClosedQueueException(); } }
@Override public Maybe<T> takeOne() { if (async == Type.NO_BACKPRESSURE) { Future<T> result = Future.future(); source.subscribeAll(e -> { result.complete(e); throw new Queue.ClosedQueueException(); }, t -> { result.completeExceptionally(t); }, () -> { if (!result.isDone()) { result.completeExceptionally(new Queue.ClosedQueueException() ); } }); return result.toMaybe(); } return Maybe.fromPublisher(this); }
public boolean completeAsNone(){ return completeExceptionally(new Queue.ClosedQueueException()); } @Override
public void close() { counter.completable = true; if (queue != null && counter.active.get() == 0) { if(counter.closing.compareAndSet(false,true)) { counter.closed = true; queue.addContinuation(new Continuation( () -> { throw new ClosedQueueException(); })); queue.close(); } } }
private T ensureNotPoisonPill(final T data) { if (data instanceof PoisonPill) { throw new ClosedQueueException(); } return data; }