Java Maybe.empty方法代码示例

import io.reactivex.Maybe; //导入方法依赖的package包/类
public static void main(String[] args) {
// has emission
        Maybe<Integer> presentSource = Maybe.just(100);
        presentSource.subscribe(s -> System.out.println("Process 1 received:" + s),
                Throwable::printStackTrace,
                () -> System.out.println("Process 1 done!"));
//no emission
        Maybe<Integer> emptySource = Maybe.empty();
        emptySource.subscribe(s -> System.out.println("Process 2 received:" + s),
                Throwable::printStackTrace,
                () -> System.out.println("Process 2 done!"));
    }
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
@Override
public Maybe<Profile> getProfile(String uid) {
    if (returnFailure){
        return Maybe.error(new Exception());
    } else if (returnEmpty) {
        return Maybe.empty();
    }
    //TODO: make static fake Profile for testing
    return Maybe.just(fakeProfile);
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
@Override
public Maybe<List<Photo>> getThumbnails(ContentResolver resolver) {
    if (returnFailure){
        return Maybe.empty();
    } else {
        List<Photo> list = new ArrayList<>();
        for (int i = 0; i < 9; i++){
            list.add(new Photo("photo-" + Integer.toString(i)));
        }
        return Maybe.just(list);
    }
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
private void demo5() {
    Completable completable = Completable.fromAction(() -> {
        log("Let's do something");
    });

    completable.subscribe(() -> {
        log("Finished");
    }, throwable -> {
        log(throwable);
    });


    Single.just("One item")
            .subscribe((item) -> {
                log(item);
            }, (throwable) -> {
                log(throwable);
            });

    Maybe.empty();
    Maybe.just("Item")
            .subscribe(s -> {
                log("On Success: " + s);
            });

    Maybe.just("Item")
            .subscribe(s -> {
                log("On Success: " + s);
            }, throwable -> log("error"));

    Maybe.just("Item")
            .subscribe(
                    s -> log("success: " + s),
                    throwable -> log("error"),
                    () -> log("onComplete")
            );
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
private <R> Maybe<R> maybeFromNonNullItem(Function<T, R> flatMapper) {
    R newItem = Invoker.invoke(flatMapper, chain.item);
    if (newItem != null) {
        return Maybe.just(newItem);
    } else {
        return Maybe.empty();
    }
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
/**
 * Gets the current state as a Maybe. The Maybe will emit a single bundle if there is a previous state
 * or if the state is missing it will emit no events and call the onComplete event
 */
@NonNull
public static Maybe<Bundle> getSavedState(@NonNull Activity activity) {
  PreConditions.throwIfNotOnMainThread();
  Bundle prevState = getSavedStateDirect(activity);
  if(prevState != null) {
    return Maybe.just(prevState);
  } else {
    return Maybe.empty();
  }
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
private Maybe<PasswordCredentials> generateEmailCredentials(User user) {
    if (user.getCredentials() != null) {
        return passwordCredentialsFacade.generateEmailCredentials(user).toMaybe();
    }

    return Maybe.empty();
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
private Maybe<Pokemon> getPokemonMaybeFromCache() {
    if (pokemonCache != null) {
        return Maybe.just(pokemonCache);
    } else {
        return Maybe.empty();
    }
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
@Override
public Maybe<Address> apply(@io.reactivex.annotations.NonNull List<Address> addresses) throws Exception {
    return addresses.isEmpty() ? Maybe.<Address>empty() : Maybe.just(addresses.get(0));
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
public Open() {
    this.response = Maybe.empty();
}
 

import io.reactivex.Maybe; //导入方法依赖的package包/类
/**
 * apply an action to the stored item if not null, this action will cause this {@link Optional}
 * to be changed to a {@link Maybe}, if the stored item is {@code null} then an empty
 * {@link Maybe} will be returned
 *
 * @param flatMapper the flat-mapped {@link Function}
 * @param <R>        the new expected type
 * @return a {@link Maybe} that either hold a value, or is empty
 */
public <R> Maybe<R> flatMapMaybe(Function<T, R> flatMapper) {
    if (chain.item != null) {
        return maybeFromNonNullItem(flatMapper);
    } else {
        return Maybe.empty();
    }
}