Action0
to Action
/Runnable
Before:
new Action0() {
@Override
public void call() {
}
}
After:
new Action() {
@Override
public void run() throws Exception {
}
}
After:
new Runnable() {
@Override
public void run() {
}
}
Action1<T>
to Consumer<T>
Before:
new Action1<String>() {
@Override
public void call(String text) {
}
}
After:
new Consumer<String>() {
@Override
public void accept(String text) throws Exception {
}
}
Action2<T>
to BiConsumer<T>
Before:
new Action2<String, Integer>() {
@Override
public void call(String text, Integer i) {
}
}
After:
new BiConsumer<String, Integer>() {
@Override
public void accept(String text, Integer i) throws Exception {
}
}
Func0<R>
to Callable<R>
Before:
new Func0<Boolean>() {
@Override
public Boolean call() {
return true;
}
}
After:
new Callable<Boolean>() {
@Override
public Boolean call() throws Exception {
return true;
}
}
Func1<T, Boolean>
to Predicate<T>
Before:
new Func1<String, Boolean>() {
@Override
public Boolean call(String text) {
return true;
}
}
After:
new Predicate<String>() {
@Override
public boolean test(String text) {
return true;
}
}
Func1<T, R>
to Function<T, R>
Before:
new Func1<String, Integer>() {
@Override
public Integer call(String text) {
return ret;
}
}
After:
new Function<String, Integer>() {
@Override
public Integer apply(String text) {
return ret;
}
}
Func2<T, T2, R>
to BiFunction<T, T2, R>
Before:
new Func2<String, Integer, Boolean>() {
@Override
public Boolean call(String text, Integer i) {
return true;
}
}
After:
new BiFunction<String, Integer, Boolean>() {
@Override
public Boolean apply(String text, Integer i) {
return true;
}
}
ActionN<T>
to Action<Object[]>
Before:
new Action3<String, Integer, Boolean>() {
@Override
public void call(String text, Integer i, Boolean b) {
}
}
After:
new Action<Object[]>() {
@Override
public void accept(Object[] objects) throws Exception {
}
}
FuncN<T>
to Function<Object[], R>
Before:
new Func3<String, Integer, Float, Boolean>() {
@Override
public Boolean call(String text, Integer i, Float f) {
return true;
}
}
After:
new Function<Object[], R>() {
@Override
public R apply(Object[] objects) throws Exception {
return ret;
}
}
Misc.
rx.Observable.OnSubscribe<T>
to ObservableOnSubscribe<T>
rx.Subscription
to Disposable
BehaviorSubject.create("defaultValue")
to BehaviorSubject.createDefault("defaultValue")
Schedulers.immediate()
to Schedulers.trampoline()
TestSubscriber<T>
to TestObserver<T>
Before:
val subscriber = TestSubscriber<List<Any>>()
store.asObservable().subscribe(subscriber)
store.dispatch(Fire1)
store.dispatch(Fire2)
scheduler.advanceTimeBy(500L, MILLISECONDS)
subscriber.assertValues(
listOf(
INIT,
Fire1
),
listOf(
INIT,
Fire1,
Fire2
),
listOf(
INIT,
Fire1,
Fire2,
Action1
),
listOf(
INIT,
Fire1,
Fire2,
Action1,
Action2
)
)
After:
val testObserver = store.asObservable().test()
// ...
testObserver.assertValues(
listOf(
INIT,
Fire1
),
listOf(
INIT,
Fire1,
Fire2
),
listOf(
INIT,
Fire1,
Fire2,
Action1
),
listOf(
INIT,
Fire1,
Fire2,
Action1,
Action2
)
)
RxPlugins.getInstance()
to RxPlugins
Before:
RxJavaPlugins.getInstance().reset()
RxJavaPlugins.getInstance().registerErrorHandler(RxJavaPlugins.DEFAULT_ERROR_HANDLER)
RxJavaPlugins.getInstance().registerSchedulersHook(SynchronousSchedulersHook())
//RxJavaPlugins.getInstance().registerObservableExecutionHook(RxJavaObservableExecutionHookDefault.getInstance())
After:
RxJavaPlugins.reset()
RxJavaPlugins.setErrorHandler {}
RxJavaPlugins.setComputationSchedulerHandler { null }
RxJavaPlugins.setIoSchedulerHandler { Schedulers.trampoline() }
RxJavaPlugins.setNewThreadSchedulerHandler { Schedulers.trampoline() }
CompositeSubscription
to CompositeDisposable
onErrorResumeNext(Function2<Throwable, Observable<T>>)
to onErrorResumeNext(Function2<Throwable, ObservableSource<T>>)
Before:
onErrorResumeNext(e -> { Observable.empty() })
After (do nothing):
onErrorReturn(Observable.empty())
After:
onErrorResumeNext { e: Throwable ->
// do something
Observable.empty()
}
Notification.hasThrowable()
to Notification.isOnError()
& Notification.getThrowable()
to Notification.getError()
Before:
notification.hasThrowable() && notification.getThrowable().getClass().isAssignableFrom(errorClazz);
After:
notification.isOnError() && notification.getError().getClass().isAssignableFrom(errorClazz);