Java Code Examples for reactor.core.publisher.Operators#addCap()

protected final void normalRequest(long n) {
  Subscription a = s;
  if (a != null) {
    a.request(n);
  } else {
    Operators.addCap(REQUESTED, this, n);

    a = s;

    if (a != null) {
      long r = REQUESTED.getAndSet(this, 0L);

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

protected final void normalRequest(long n) {
	Subscription a = s;
	if (a != null) {
		a.request(n);
	} else {
		Operators.addCap(REQUESTED, this, n);

		a = s;

		if (a != null) {
			long r = REQUESTED.getAndSet(this, 0L);

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

private void updateRequested(Event<?> event) {
	RequestEvent requestEvent = null;
	if (event instanceof RequestEvent) requestEvent = (RequestEvent) event;
	else if (event instanceof SubscriptionTaskEvent) {
		SubscriptionTaskEvent ste = (SubscriptionTaskEvent) event;
		if (ste.delegate instanceof RequestEvent) {
			requestEvent = (RequestEvent) ste.delegate;
		}
	}

	if (requestEvent == null) {
		return;
	}
	else if (requestEvent.isBounded()) {
		Operators.addCap(REQUESTED, this, requestEvent.getRequestAmount());

	}
	else {
		REQUESTED.set(this, Long.MAX_VALUE);
	}
}
 

protected final void normalRequest(long n) {
    Subscription a = s;
    if (a != null) {
        a.request(n);
    } else {
        Operators.addCap(REQUESTED, this, n);

        a = s;

        if (a != null) {
            long r = REQUESTED.getAndSet(this, 0L);

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

@Override
public void request(long n) {
	if (Operators.validate(n)) {
		if (eventLoop.inEventLoop()) {
			this.receiverDemand = Operators.addCap(receiverDemand, n);
			drainReceiver();
		}
		else {
			eventLoop.execute(() -> {
				this.receiverDemand = Operators.addCap(receiverDemand, n);
				drainReceiver();
			});
		}
	}
}
 

@Override
public void request(long n) {
  if (Operators.validate(n)) {
    long r = this.requested; // volatile read beforehand

    if (r > STATE_SUBSCRIBED) { // works only in case onSubscribe has not happened
      long u;
      for (; ; ) { // normal CAS loop with overflow protection
        if (r == Long.MAX_VALUE) {
          // if r == Long.MAX_VALUE then we dont care and we can loose this
          // request just in case of racing
          return;
        }
        u = Operators.addCap(r, n);
        if (REQUESTED.compareAndSet(this, r, u)) {
          // Means increment happened before onSubscribe
          return;
        } else {
          // Means increment happened after onSubscribe

          // update new state to see what exactly happened (onSubscribe |cancel | requestN)
          r = this.requested;

          // check state (expect -1 | -2 to exit, otherwise repeat)
          if (r < 0) {
            break;
          }
        }
      }
    }

    if (r == STATE_CANCELLED) { // if canceled, just exit
      return;
    }

    // if onSubscribe -> subscription exists (and we sure of that because volatile read
    // after volatile write) so we can execute requestN on the subscription
    this.s.request(n);
  }
}
 

@Override
public void request(long n) {
	if (Operators.validate(n)) {
		if (Operators.addCap(REQUESTED, this, n) == 0) {
			if (n == Long.MAX_VALUE) {
				fastPath();
			}
			else {
				slowPath(n);
			}
		}
	}
}
 

@Override
public DefaultStepVerifierBuilder<T> thenRequest(long n) {
	checkStrictlyPositive(n);
	this.script.add(new RequestEvent<>(n, "thenRequest"));
	this.hangCheckRequested = Operators.addCap(hangCheckRequested, n);
	return this;
}
 

@Override
public void request(long n) {
	if (Operators.validate(n)) {
		Operators.addCap(REQUESTED, this, n);
		parent.wasRequested = true;
	}
}
 

@Override
public void request(long n) {
	if (Operators.validate(n)) {
		Operators.addCap(REQUESTED, this, n);
		parent.wasRequested = true;
	}
}
 

static long add(TestCallStreamObserverProducer o, long n) {
    for (;;) {
        long r = REQUESTED.get(o);
        if (r == Long.MAX_VALUE) {
            return Long.MAX_VALUE;
        }
        long u = Operators.addCap(r, n);
        if ((REQUESTED).compareAndSet(o, r, u)) {
            return r;
        }
    }
}
 

@Override
<T> void request(AbstractListenerReadPublisher<T> publisher, long n) {
	if (Operators.validate(n)) {
		Operators.addCap(DEMAND_FIELD_UPDATER, publisher, n);
		// Did a concurrent read transition to NO_DEMAND just before us?
		publisher.changeToDemandState(NO_DEMAND);
	}
}
 

@Override
<T> void request(AbstractListenerReadPublisher<T> publisher, long n) {
	if (Operators.validate(n)) {
		Operators.addCap(DEMAND_FIELD_UPDATER, publisher, n);
		// Did a concurrent read transition to NO_DEMAND just before us?
		publisher.changeToDemandState(NO_DEMAND);
	}
}
 

@Override
<T> void request(AbstractListenerReadPublisher<T> publisher, long n) {
	if (Operators.validate(n)) {
		Operators.addCap(DEMAND_FIELD_UPDATER, publisher, n);
		publisher.changeToDemandState(this);
	}
}
 

@Override
<T> void request(AbstractListenerReadPublisher<T> publisher, long n) {
	if (Operators.validate(n)) {
		Operators.addCap(DEMAND_FIELD_UPDATER, publisher, n);
		// Did a concurrent read transition to NO_DEMAND just before us?
		publisher.changeToDemandState(NO_DEMAND);
	}
}
 

@Override
<T> void request(AbstractListenerReadPublisher<T> publisher, long n) {
	if (Operators.validate(n)) {
		Operators.addCap(DEMAND_FIELD_UPDATER, publisher, n);
		// Did a concurrent read transition to NO_DEMAND just before us?
		publisher.changeToDemandState(NO_DEMAND);
	}
}
 

@Override
<T> void request(AbstractListenerReadPublisher<T> publisher, long n) {
	if (Operators.validate(n)) {
		Operators.addCap(DEMAND_FIELD_UPDATER, publisher, n);
		publisher.changeToDemandState(this);
	}
}
 

final void advanceTime(long timeShiftInNanoseconds) {
	Operators.addCap(DEFERRED_NANO_TIME, this, timeShiftInNanoseconds);
	drain();
}
 

@Override
<T> void request(AbstractListenerReadPublisher<T> publisher, long n) {
	if (Operators.validate(n)) {
		Operators.addCap(DEMAND_FIELD_UPDATER, publisher, n);
		publisher.changeToDemandState(this);
	}
}
 

@Override
<T> void request(AbstractListenerReadPublisher<T> publisher, long n) {
	if (Operators.validate(n)) {
		Operators.addCap(DEMAND_FIELD_UPDATER, publisher, n);
		publisher.changeToDemandState(this);
	}
}