All Downloads are FREE. Search and download functionalities are using the official Maven repository.

rx.internal.operators.BlockingOperatorNext Maven / Gradle / Ivy

There is a newer version: 1.3.8
Show newest version
/**
 * Copyright 2014 Netflix, Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package rx.internal.operators;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

import rx.*;
import rx.Observable;
import rx.exceptions.Exceptions;

/**
 * Returns an Iterable that blocks until the Observable emits another item, then returns that item.
 * 

* */ public final class BlockingOperatorNext { private BlockingOperatorNext() { throw new IllegalStateException("No instances!"); } /** * Returns an {@code Iterable} that blocks until the {@code Observable} emits another item, then returns * that item. * * @param the value type * @param items * the {@code Observable} to observe * @return an {@code Iterable} that behaves like a blocking version of {@code items} */ public static Iterable next(final Observable items) { return new Iterable() { @Override public Iterator iterator() { NextObserver nextObserver = new NextObserver(); return new NextIterator(items, nextObserver); } }; } // test needs to access the observer.waiting flag non-blockingly. /* private */static final class NextIterator implements Iterator { private final NextObserver observer; private final Observable items; private T next; private boolean hasNext = true; private boolean isNextConsumed = true; private Throwable error; private boolean started; NextIterator(Observable items, NextObserver observer) { this.items = items; this.observer = observer; } @Override public boolean hasNext() { if (error != null) { // If any error has already been thrown, throw it again. throw Exceptions.propagate(error); } // Since an iterator should not be used in different thread, // so we do not need any synchronization. if (!hasNext) { // the iterator has reached the end. return false; } if (!isNextConsumed) { // next has not been used yet. return true; } return moveToNext(); } @SuppressWarnings("unchecked") private boolean moveToNext() { try { if (!started) { started = true; // if not started, start now observer.setWaiting(1); ((Observable)items).materialize().subscribe(observer); } Notification nextNotification = observer.takeNext(); if (nextNotification.isOnNext()) { isNextConsumed = false; next = nextNotification.getValue(); return true; } // If an observable is completed or fails, // hasNext() always return false. hasNext = false; if (nextNotification.isOnCompleted()) { return false; } if (nextNotification.isOnError()) { error = nextNotification.getThrowable(); throw Exceptions.propagate(error); } throw new IllegalStateException("Should not reach here"); } catch (InterruptedException e) { observer.unsubscribe(); Thread.currentThread().interrupt(); error = e; throw Exceptions.propagate(e); } } @Override public T next() { if (error != null) { // If any error has already been thrown, throw it again. throw Exceptions.propagate(error); } if (hasNext()) { isNextConsumed = true; return next; } else { throw new NoSuchElementException("No more elements"); } } @Override public void remove() { throw new UnsupportedOperationException("Read only iterator"); } } static final class NextObserver extends Subscriber> { private final BlockingQueue> buf = new ArrayBlockingQueue>(1); final AtomicInteger waiting = new AtomicInteger(); @Override public void onCompleted() { // ignore } @Override public void onError(Throwable e) { // ignore } @Override public void onNext(Notification args) { if (waiting.getAndSet(0) == 1 || !args.isOnNext()) { Notification toOffer = args; while (!buf.offer(toOffer)) { Notification concurrentItem = buf.poll(); // in case if we won race condition with onComplete/onError method if (concurrentItem != null && !concurrentItem.isOnNext()) { toOffer = concurrentItem; } } } } public Notification takeNext() throws InterruptedException { setWaiting(1); return buf.take(); } void setWaiting(int value) { waiting.set(value); } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy