Examples with Maybe io.reactivex.Maybe used on opensource projects

Example 11 with Maybe

use of io.reactivex.Maybe in project Store by NYTimes.

the class StoreBuilderTest method testBuildersBuildWithCorrectTypes.

@Test
public void testBuildersBuildWithCorrectTypes() {
    // test  is checking whether types are correct in builders
    Store<Date, Integer> store = StoreBuilder.<Integer, String, Date>parsedWithKey().fetcher(key -> Single.just(String.valueOf(key))).persister(new Persister<String, Integer>() {

        @Nonnull
        @Override
        public Maybe<String> read(@Nonnull Integer key) {
            return Maybe.just(String.valueOf(key));
        }

        @Nonnull
        @Override
        public Single<Boolean> write(@Nonnull Integer key, @Nonnull String s) {
            return Single.just(true);
        }
    }).parser(s -> DATE).open();
    Store<Date, BarCode> barCodeStore = StoreBuilder.<Date>barcode().fetcher(new Fetcher<Date, BarCode>() {

        @Nonnull
        @Override
        public Single<Date> fetch(@Nonnull BarCode barCode) {
            return Single.just(DATE);
        }
    }).open();
    Store<Date, Integer> keyStore = StoreBuilder.<Integer, Date>key().fetcher(new Fetcher<Date, Integer>() {

        @Nonnull
        @Override
        public Single<Date> fetch(@Nonnull Integer key) {
            return Single.just(DATE);
        }
    }).open();
    Date result = store.get(5).blockingGet();
    result = barCodeStore.get(new BarCode("test", "5")).blockingGet();
    result = keyStore.get(5).blockingGet();
    assertThat(result).isNotNull();
}

Example 12 with Maybe

use of io.reactivex.Maybe in project retrofit by square.

the class RxJava2CallAdapterFactoryTest method responseTypes.

@Test
public void responseTypes() {
    Type oBodyClass = new TypeToken<Observable<String>>() {
    }.getType();
    assertThat(factory.get(oBodyClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type sBodyClass = new TypeToken<Single<String>>() {
    }.getType();
    assertThat(factory.get(sBodyClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type mBodyClass = new TypeToken<Maybe<String>>() {
    }.getType();
    assertThat(factory.get(mBodyClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type fBodyClass = new TypeToken<Flowable<String>>() {
    }.getType();
    assertThat(factory.get(fBodyClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type oBodyWildcard = new TypeToken<Observable<? extends String>>() {
    }.getType();
    assertThat(factory.get(oBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type sBodyWildcard = new TypeToken<Single<? extends String>>() {
    }.getType();
    assertThat(factory.get(sBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type mBodyWildcard = new TypeToken<Maybe<? extends String>>() {
    }.getType();
    assertThat(factory.get(mBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type fBodyWildcard = new TypeToken<Flowable<? extends String>>() {
    }.getType();
    assertThat(factory.get(fBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type oBodyGeneric = new TypeToken<Observable<List<String>>>() {
    }.getType();
    assertThat(factory.get(oBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(new TypeToken<List<String>>() {
    }.getType());
    Type sBodyGeneric = new TypeToken<Single<List<String>>>() {
    }.getType();
    assertThat(factory.get(sBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(new TypeToken<List<String>>() {
    }.getType());
    Type mBodyGeneric = new TypeToken<Maybe<List<String>>>() {
    }.getType();
    assertThat(factory.get(mBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(new TypeToken<List<String>>() {
    }.getType());
    Type fBodyGeneric = new TypeToken<Flowable<List<String>>>() {
    }.getType();
    assertThat(factory.get(fBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(new TypeToken<List<String>>() {
    }.getType());
    Type oResponseClass = new TypeToken<Observable<Response<String>>>() {
    }.getType();
    assertThat(factory.get(oResponseClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type sResponseClass = new TypeToken<Single<Response<String>>>() {
    }.getType();
    assertThat(factory.get(sResponseClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type mResponseClass = new TypeToken<Maybe<Response<String>>>() {
    }.getType();
    assertThat(factory.get(mResponseClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type fResponseClass = new TypeToken<Flowable<Response<String>>>() {
    }.getType();
    assertThat(factory.get(fResponseClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type oResponseWildcard = new TypeToken<Observable<Response<? extends String>>>() {
    }.getType();
    assertThat(factory.get(oResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type sResponseWildcard = new TypeToken<Single<Response<? extends String>>>() {
    }.getType();
    assertThat(factory.get(sResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type mResponseWildcard = new TypeToken<Maybe<Response<? extends String>>>() {
    }.getType();
    assertThat(factory.get(mResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type fResponseWildcard = new TypeToken<Flowable<Response<? extends String>>>() {
    }.getType();
    assertThat(factory.get(fResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type oResultClass = new TypeToken<Observable<Result<String>>>() {
    }.getType();
    assertThat(factory.get(oResultClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type sResultClass = new TypeToken<Single<Result<String>>>() {
    }.getType();
    assertThat(factory.get(sResultClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type mResultClass = new TypeToken<Maybe<Result<String>>>() {
    }.getType();
    assertThat(factory.get(mResultClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type fResultClass = new TypeToken<Flowable<Result<String>>>() {
    }.getType();
    assertThat(factory.get(fResultClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type oResultWildcard = new TypeToken<Observable<Result<? extends String>>>() {
    }.getType();
    assertThat(factory.get(oResultWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type sResultWildcard = new TypeToken<Single<Result<? extends String>>>() {
    }.getType();
    assertThat(factory.get(sResultWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type mResultWildcard = new TypeToken<Maybe<Result<? extends String>>>() {
    }.getType();
    assertThat(factory.get(mResultWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type fResultWildcard = new TypeToken<Flowable<Result<? extends String>>>() {
    }.getType();
    assertThat(factory.get(fResultWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
}

Example 13 with Maybe

use of io.reactivex.Maybe in project RxCache by VictorAlbertos.

the class ProxyTranslator method getLoaderObservable.

private Observable getLoaderObservable(Method method, Object[] objectsMethod) {
    Observable<?> observable = getObjectFromMethodParam(method, Observable.class, objectsMethod);
    if (observable != null)
        return observable;
    Single single = getObjectFromMethodParam(method, Single.class, objectsMethod);
    if (single != null)
        return single.toObservable();
    Maybe maybe = getObjectFromMethodParam(method, Maybe.class, objectsMethod);
    if (maybe != null)
        return maybe.toObservable();
    Flowable flowable = getObjectFromMethodParam(method, Flowable.class, objectsMethod);
    if (flowable != null)
        return flowable.toObservable();
    String errorMessage = method.getName() + io.rx_cache2.internal.Locale.NOT_REACTIVE_TYPE_FOR_LOADER_WAS_FOUND;
    throw new IllegalArgumentException(errorMessage);
}