Java Experimental类代码示例

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public CompositeException(Throwable... errors) {
    this.cause = null;
    Set<Throwable> deDupedExceptions = new LinkedHashSet();
    List<Throwable> _exceptions = new ArrayList();
    if (errors != null) {
        for (Throwable ex : errors) {
            if (ex instanceof CompositeException) {
                deDupedExceptions.addAll(((CompositeException) ex).getExceptions());
            } else if (ex != null) {
                deDupedExceptions.add(ex);
            } else {
                deDupedExceptions.add(new NullPointerException());
            }
        }
    } else {
        deDupedExceptions.add(new NullPointerException());
    }
    _exceptions.addAll(deDupedExceptions);
    this.exceptions = Collections.unmodifiableList(_exceptions);
    this.message = this.exceptions.size() + " exceptions occurred. ";
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public void subscribe(final Action1<? super T> onNext, final Action1<? super Throwable> onError, final Action0 onCompleted) {
    subscribe(new Observer<T>() {
        public void onNext(T t) {
            onNext.call(t);
        }

        public void onError(Throwable e) {
            onError.call(e);
        }

        public void onCompleted() {
            onCompleted.call();
        }
    });
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public JsonObservable readJsonObservable(final String filePath) {
    final Observable<JsonReader> jsonReaderObservable = Observable.fromCallable(new Callable<JsonReader>() {
        @Override
        public JsonReader call() throws Exception {
            return GsonFunctions.readJson(filePath);
        }
    });

    return new JsonObservable(new Observable.OnSubscribe<JsonReader>() {
        @Override
        public void call(Subscriber<? super JsonReader> subscriber) {
            jsonReaderObservable.unsafeSubscribe(subscriber);
        }
    });
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Observable<? extends R>> func) {
    if (this instanceof ScalarSynchronousObservable) {
        return ((ScalarSynchronousObservable) this).scalarFlatMap(func);
    }
    return create(new OnSubscribeConcatMap(this, func, 2, 2));
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public final <U> Observable<T> delaySubscription(Observable<U> other) {
    if (other != null) {
        return create(new OnSubscribeDelaySubscriptionOther(this, other));
    }
    throw new NullPointerException();
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observable<? extends R>> mapper, int capacityHint) {
    if (capacityHint >= 1) {
        return lift(new OperatorEagerConcatMap(mapper, capacityHint, Integer.MAX_VALUE));
    }
    throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint);
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public static <T> Single<T> fromCallable(final Callable<? extends T> func) {
    return create(new OnSubscribe<T>() {
        public void call(SingleSubscriber<? super T> singleSubscriber) {
            try {
                singleSubscriber.onSuccess(func.call());
            } catch (Throwable t) {
                Exceptions.throwIfFatal(t);
                singleSubscriber.onError(t);
            }
        }
    });
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public final Single<T> doOnError(final Action1<Throwable> onError) {
    return lift(new OperatorDoOnEach(new Observer<T>() {
        public void onCompleted() {
        }

        public void onError(Throwable e) {
            onError.call(e);
        }

        public void onNext(T t) {
        }
    }));
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public static void awaitForComplete(CountDownLatch latch, Subscription subscription) {
    if (latch.getCount() != 0) {
        try {
            latch.await();
        } catch (InterruptedException e) {
            subscription.unsubscribe();
            Thread.currentThread().interrupt();
            throw new RuntimeException("Interrupted while waiting for subscription to complete.", e);
        }
    }
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observable<? extends R>> mapper, int capacityHint) {
    if (capacityHint >= 1) {
        return lift(new OperatorEagerConcatMap(mapper, capacityHint));
    }
    throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint);
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public static <S, T> Observable$OnSubscribe<T> createSingleState(Func0<? extends S> generator, final Action3<? super S, Long, ? super Observer<Observable<? extends T>>> next) {
    return new AsyncOnSubscribeImpl((Func0) generator, new Func3<S, Long, Observer<Observable<? extends T>>, S>() {
        public S call(S state, Long requested, Observer<Observable<? extends T>> subscriber) {
            next.call(state, requested, subscriber);
            return state;
        }
    });
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public static <S, T> Observable$OnSubscribe<T> createSingleState(Func0<? extends S> generator, final Action2<? super S, ? super Observer<? super T>> next) {
    return new SyncOnSubscribeImpl((Func0) generator, new Func2<S, Observer<? super T>, S>() {
        public S call(S state, Observer<? super T> subscriber) {
            next.call(state, subscriber);
            return state;
        }
    });
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
/**
 * Returns the Throwable that terminated the Subject.
 * @return the Throwable that terminated the Subject or {@code null} if the
 * subject hasn't terminated yet or it terminated normally.
 */
@Experimental
public Throwable getThrowable() {
    Object o = state.get();
    if (nl.isError(o)) {
        return nl.getError(o);
    }
    return null;
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public void reset() {
    this.schedulersHook.set(null);
}
 

import rx.annotations.Experimental; //导入依赖的package包/类
@Experimental
public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscribe) {
    return new Observable(hook.onCreate(asyncOnSubscribe));
}