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

@Override
public void request(long n) {
    if (Operators.validate(n)) {
        for (; ; ) {
            int s = state;
            if (s == SDS_HAS_REQUEST_NO_VALUE || s == SDS_HAS_REQUEST_HAS_VALUE) {
                return;
            }
            if (s == SDS_NO_REQUEST_HAS_VALUE) {
                if (STATE.compareAndSet(this, SDS_NO_REQUEST_HAS_VALUE, SDS_HAS_REQUEST_HAS_VALUE)) {
                    Subscriber<? super O> a = subscriber;
                    a.onNext(value);
                    a.onComplete();
                }
                return;
            }
            if (STATE.compareAndSet(this, SDS_NO_REQUEST_NO_VALUE, SDS_HAS_REQUEST_NO_VALUE)) {
                return;
            }
        }
    }
}
 

@Override
public final void onSubscribe(Subscription s) {
	if (Operators.validate(this.subscription, s)) {
		this.subscription = s;
		this.writeCompletionBarrier.connect();
		s.request(1);
	}
}
 

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

@Override
public void onSubscribe(Subscription s) {
    if (Operators.validate(upstream, s)) {
        this.upstream = s;
        actual.onSubscribe(this);
        this.start = pool.clock.millis();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public void onSubscribe(Subscription s) {
    if (Operators.validate(this.s, s)) {
        this.s = (S) s;
        this.actual.onSubscribe(this);
    }
}
 

@Override
public void request(long n) {
	if (Operators.validate(n)) {
		if (establishedFusionMode != Fuseable.SYNC) {
			normalRequest(n);
		}
	}
}
 

@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
@SuppressWarnings("unchecked")
public void onSubscribe(Subscription s) {
  if (Operators.validate(this.s, s)) {
    this.s = (QueueSubscription<T>) s;
    this.start = System.nanoTime();

    actual.onSubscribe(this);
  }
}
 

@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 onSubscribe(Subscription s) {
  if (Operators.validate(this.s, s)) {
    this.s = s;
    this.start = System.nanoTime();

    actual.onSubscribe(this);
  }
}
 

@Override
public void onSubscribe(Subscription s) {
	if (Operators.validate(subscription, s)) {
		this.subscription = s;
		cancellations.add(this);
		if (!retried) {
			sink.onCancel(cancellations);
		}
		s.request(Long.MAX_VALUE);
	}
}
 

@Override
public final void request(long n) {
    if (Operators.validate(n)) {
        Subscription s = this.subscription;
        if (s != null) {
            s.request(n);
        }
    }
}
 

@Override
public void onSubscribe(Subscription s) {
  if (Operators.validate(this.s, s)) {
    this.s = s;
    this.start = System.nanoTime();

    actual.onSubscribe(this);
  }
}
 

@Override
public void request(long n) {
    if (Operators.validate(n)) {
        if (establishedFusionMode != Fuseable.SYNC) {
            normalRequest(n);
        }
    }
}
 

@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
@SuppressWarnings("unchecked")
public void onSubscribe(Subscription s) {
  if (Operators.validate(this.s, s)) {
    this.s = s;
    if (s instanceof Fuseable.QueueSubscription) {
      this.qs = (Fuseable.QueueSubscription<Payload>) s;
    }
    this.actual.onSubscribe(this);
  }
}
 

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

@Override
public void onSubscribe(Subscription s) {
	if (Operators.validate(subscription, s)) {
		this.subscription = s;
		sink.onCancel(this);
		s.request(Long.MAX_VALUE);
	}
}
 

@Override
public void onSubscribe(Subscription s) {
  if (Operators.validate(this.s, s)) {
    this.s = s;
    this.actual.onSubscribe(this.second);
  }
}
 

@Override
void request(WriteResultPublisher publisher, long n) {
	Operators.validate(n);
}