Java RxRingBuffer.isCompleted方法代码示例

import rx.internal.util.RxRingBuffer; //导入方法依赖的package包/类
/**
 * Polls a top item from the priority queue. Adds the top source back to
 * pending set. Not synchronized as accessed inside COUNTER_UPDATER block
 * 
 * @param pending
 *          set of source observers pending a value for the merge
 * @return true if we need a shutdown
 */
private boolean pollTopItem(Set<InnerSubscriber> pending) {
  // get a next item in order from the priority queue
  ValueSourcePair tuple = queue.poll();
  T value = tuple.value;

  InnerSubscriber observer = tuple.source;
  // mark the wining observer as pending again
  pending.add(observer);
  try {
    // emit the next item in order
    child.onNext(value);
    // we emitted so decrement the requested counter
    requested.decrementAndGet();
    observer.emitted++;
  } catch (Throwable e) {
    Exceptions.throwOrReport(e, child, value);
    return true;
  }
  // now remove
  RxRingBuffer buffer = observer.items;
  buffer.poll();
  // eagerly check if the next item on this queue is an onComplete
  if (buffer.isCompleted(buffer.peek())) {
    // we need to unsubscribe and remove from pending
    pending.remove(observer);
    childSubscription.remove(observer);
    if (!childSubscription.hasSubscriptions()) {
      // it is last upstream observer so onComplete so shut down
      child.onCompleted();
      return true;
    }
    return false; // dont request for this observer
  }
  if (observer.emitted > THRESHOLD) {
    observer.requestMore(observer.emitted);
    observer.emitted = 0;
  }
  return false;
}
 

import rx.internal.util.RxRingBuffer; //导入方法依赖的package包/类
void tick() {
    Object[] observers = this.observers;
    if (observers != null && getAndIncrement() == 0) {
        int length = observers.length;
        Observer<? super R> child = this.child;
        AtomicLong requested = this.requested;
        while (true) {
            RxRingBuffer buffer;
            Object[] vs = new Object[length];
            boolean allHaveValues = true;
            for (int i = 0; i < length; i++) {
                buffer = ((InnerSubscriber) observers[i]).items;
                Object n = buffer.peek();
                if (n == null) {
                    allHaveValues = false;
                } else if (buffer.isCompleted(n)) {
                    child.onCompleted();
                    this.childSubscription.unsubscribe();
                    return;
                } else {
                    vs[i] = buffer.getValue(n);
                }
            }
            if (requested.get() > 0 && allHaveValues) {
                try {
                    child.onNext(this.zipFunction.call(vs));
                    requested.decrementAndGet();
                    this.emitted++;
                    for (Object obj : observers) {
                        buffer = ((InnerSubscriber) obj).items;
                        buffer.poll();
                        if (buffer.isCompleted(buffer.peek())) {
                            child.onCompleted();
                            this.childSubscription.unsubscribe();
                            return;
                        }
                    }
                    if (this.emitted > THRESHOLD) {
                        for (Object obj2 : observers) {
                            ((InnerSubscriber) obj2).requestMore((long) this.emitted);
                        }
                        this.emitted = 0;
                    }
                } catch (Throwable e) {
                    Exceptions.throwOrReport(e, child, vs);
                    return;
                }
            } else if (decrementAndGet() <= 0) {
                return;
            }
        }
    }
}
 

import rx.internal.util.RxRingBuffer; //导入方法依赖的package包/类
/**
 * Tries to pick items from pending sources. Not synchronized as accessed
 * inside COUNTER_UPDATER block
 * 
 * @param pending
 *          set of source observers pending a value for the merge
 * @return true if we need a shutdown
 */
boolean pickPendingItems(Set<InnerSubscriber> pending) {
  // peek for a potential onCompleted event
  for (Iterator<InnerSubscriber> iter = pending.iterator(); iter.hasNext();) {
    InnerSubscriber subscr = iter.next();
    if (subscr.isUnsubscribed()) {
      // we should remove completed observer from the pending set
      iter.remove();
    }

    RxRingBuffer buffer = subscr.items;
    Object n = buffer.peek();

    if (n == null) {
      // we should keep this observer as pending
      continue;
    }

    if (buffer.isCompleted(n)) {
      iter.remove();
      // this observer indicates completion - unsubscribe and remove from
      // pending
      childSubscription.remove(subscr);
      if (!childSubscription.hasSubscriptions()) {
        // it is last upstream observer so onComplete so shut down
        child.onCompleted();
        return true;
      }
    } else {
      // got new data add to the priority queue and remove from pending set
      @SuppressWarnings("unchecked")
      T value = (T) buffer.getValue(n);
      ValueSourcePair tuple = new ValueSourcePair(value, subscr);
      queue.add(tuple);
      // remove from pending set
      iter.remove();
    }
  }
  return false;

}