/**
   * Atomically sets the single subscription and requests the missed amount from it.
   *
   * @param s the Subscription to set.
   * @return false if this arbiter is cancelled or there was a subscription already set
   */
  protected final boolean set(Subscription s) {
    Objects.requireNonNull(s, "s");
    Subscription a = this.s;
    if (a == Operators.cancelledSubscription()) {
      s.cancel();
      return false;
    }
    if (a != null) {
      s.cancel();
      Operators.reportSubscriptionSet();
      return false;
    }

    if (S.compareAndSet(this, null, s)) {

      long r = REQUESTED.getAndSet(this, 0L);

      if (r != 0L) {
        s.request(r);
      }

      return true;
    }

    a = this.s;

    if (a != Operators.cancelledSubscription()) {
      s.cancel();
      return false;
    }

    Operators.reportSubscriptionSet();
    return false;
  }
    @Override
    public void onSubscribe(Subscription s) {
      if (SubscriptionHelper.validateSubscription(this.s, s)) {
        return;
      }
      this.s = s;

      Subscriber<? super U> actual = this.actual;

      U b;

      try {
        b = bufferSupplier.get();
      } catch (Throwable e) {
        cancelled = true;
        s.cancel();
        EmptySubscription.error(e, actual);
        return;
      }

      if (b == null) {
        cancelled = true;
        s.cancel();
        EmptySubscription.error(new NullPointerException("The buffer supplied is null"), actual);
        return;
      }
      buffer = b;

      Publisher<B> boundary;

      try {
        boundary = boundarySupplier.get();
      } catch (Throwable ex) {
        cancelled = true;
        s.cancel();
        EmptySubscription.error(ex, actual);
        return;
      }

      if (boundary == null) {
        cancelled = true;
        s.cancel();
        EmptySubscription.error(
            new NullPointerException("The boundary publisher supplied is null"), actual);
        return;
      }

      BufferBoundarySubscriber<T, U, B> bs = new BufferBoundarySubscriber<T, U, B>(this);
      other = bs;

      actual.onSubscribe(this);

      if (!cancelled) {
        s.request(Long.MAX_VALUE);

        boundary.subscribe(bs);
      }
    }
    void next() {

      Disposable o = other;

      U next;

      try {
        next = bufferSupplier.get();
      } catch (Throwable e) {
        cancel();
        actual.onError(e);
        return;
      }

      if (next == null) {
        cancel();
        actual.onError(new NullPointerException("The buffer supplied is null"));
        return;
      }

      Publisher<B> boundary;

      try {
        boundary = boundarySupplier.get();
      } catch (Throwable ex) {
        cancelled = true;
        s.cancel();
        actual.onError(ex);
        return;
      }

      if (boundary == null) {
        cancelled = true;
        s.cancel();
        actual.onError(new NullPointerException("The boundary publisher supplied is null"));
        return;
      }

      BufferBoundarySubscriber<T, U, B> bs = new BufferBoundarySubscriber<T, U, B>(this);

      if (!OTHER.compareAndSet(this, o, bs)) {
        return;
      }

      U b;
      synchronized (this) {
        b = buffer;
        if (b == null) {
          return;
        }
        buffer = next;
      }

      boundary.subscribe(bs);

      fastpathEmitMax(b, false, this);
    }
 @Override
 public void onNext(Try<Optional<T>> t) {
   if (done) {
     return;
   }
   if (t.hasError()) {
     s.cancel();
     onError(t.error());
   } else {
     Optional<T> o = t.value();
     if (o.isPresent()) {
       actual.onNext(o.get());
     } else {
       s.cancel();
       onComplete();
     }
   }
 }
 @Override
 public void cancel() {
   Subscription a = s;
   if (a != Operators.cancelledSubscription()) {
     a = S.getAndSet(this, Operators.cancelledSubscription());
     if (a != null && a != Operators.cancelledSubscription()) {
       a.cancel();
     }
   }
 }
  /**
   * Sets the Subscription once but does not request anything.
   *
   * @param s the Subscription to set
   * @return true if successful, false if the current subscription is not null
   */
  protected final boolean setWithoutRequesting(Subscription s) {
    Objects.requireNonNull(s, "s");
    while (true) {
      Subscription a = this.s;
      if (a == Operators.cancelledSubscription()) {
        s.cancel();
        return false;
      }
      if (a != null) {
        s.cancel();
        Operators.reportSubscriptionSet();
        return false;
      }

      if (S.compareAndSet(this, null, s)) {
        return true;
      }
    }
  }
Ejemplo n.º 7
0
 @Override
 public void operationComplete(ChannelFuture future) throws Exception {
   if (log.isDebugEnabled()) {
     log.debug("Cancel connection");
   }
   if (subscription != null) {
     subscription.cancel();
   }
   subscription = null;
 }
    @Override
    public void cancel() {
      if (!cancelled) {
        cancelled = true;
        s.cancel();
        disposeOther();

        if (enter()) {
          queue.clear();
        }
      }
    }
Ejemplo n.º 9
0
 @Override
 public void cancel() {
   super.cancel();
   FallbackSubscriber fallbackSubscriber = this.fallbackSubscriber;
   if (fallbackSubscriber != null) {
     Subscription subscription = fallbackSubscriber.subscription;
     if (subscription != null) {
       fallbackSubscriber.subscription = null;
       subscription.cancel();
     }
   }
 }
    @Override
    public void cancel() {
      if (!cancelled) {

        cancelled = true;

        s.cancel();

        if (WIP.getAndIncrement(this) == 0) {
          VALUE.lazySet(this, null);
        }
      }
    }
Ejemplo n.º 11
0
 @Override
 public void onSubscribe(final Subscription s) {
   if (BackpressureUtils.checkSubscription(upstreamSubscription, s)) {
     this.upstreamSubscription = s;
     try {
       doOnSubscribe(s);
     } catch (Throwable t) {
       Exceptions.throwIfFatal(t);
       s.cancel();
       onError(t);
     }
   }
 }
Ejemplo n.º 12
0
    @Override
    public void onNext(T t) {
      if (done) {
        return;
      }
      try {
        onNext.accept(t);
      } catch (Throwable e) {
        s.cancel();
        onError(e);
        return;
      }

      actual.onNext(t);
    }
Ejemplo n.º 13
0
  public void demonstrateADetachedGraphStage() throws Exception {
    // tests:
    CompletionStage<Integer> result1 =
        Source.from(Arrays.asList(1, 2, 3))
            .via(new TwoBuffer<>())
            .runFold(0, (acc, n) -> acc + n, mat);

    assertEquals(new Integer(6), result1.toCompletableFuture().get(3, TimeUnit.SECONDS));

    TestSubscriber.ManualProbe<Integer> subscriber = TestSubscriber.manualProbe(system);
    TestPublisher.Probe<Integer> publisher = TestPublisher.probe(0, system);
    RunnableGraph<NotUsed> flow2 =
        Source.fromPublisher(publisher).via(new TwoBuffer<>()).to(Sink.fromSubscriber(subscriber));

    flow2.run(mat);

    Subscription sub = subscriber.expectSubscription();
    // this happens even though the subscriber has not signalled any demand
    publisher.sendNext(1);
    publisher.sendNext(2);

    sub.cancel();
  }
Ejemplo n.º 14
0
 @Override
 public void cancel() {
   if (subscription != null) {
     subscription.cancel();
   }
 }
Ejemplo n.º 15
0
 protected void cancel(Subscription subscription) {
   if (subscription != SignalType.NOOP_SUBSCRIPTION) {
     subscription.cancel();
   }
 }
 @Override
 public void dispose() {
   s.cancel();
   disposeOther();
 }