Java Maybe类代码示例

import io.reactivex.Maybe; //导入依赖的package包/类
public static void main(String[] args) {
	// TODO Auto-generated method stub

	Maybe<List<String>> month_maybe = Maybe.create(emitter -> {
		try {
			String[] monthArray = { "Jan", "Feb", "Mar", "Apl", "May", "Jun", "July", "Aug", "Sept", "Oct", "Nov",
					"Dec" };

			List<String> months = Arrays.asList(monthArray);
			if (months != null && !months.isEmpty()) {
				emitter.onSuccess(months);
			} else {
				emitter.onComplete();
			}
		} catch (Exception e) {
			emitter.onError(e);
		}
	});
	month_maybe.subscribe(s->System.out.println(s));
	
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Override
public Maybe<Response> download(final Request request) {

    return Maybe.create(new MaybeOnSubscribe<CloseableHttpResponse>(){

        @Override
        public void subscribe(MaybeEmitter emitter) throws Exception {

            emitter.onSuccess(httpManager.getResponse(request));
        }
    }).map(new Function<CloseableHttpResponse, Response>() {

        @Override
        public Response apply(CloseableHttpResponse closeableHttpResponse) throws Exception {

            String html = EntityUtils.toString(closeableHttpResponse.getEntity(), "UTF-8");
            Response response = new Response();
            response.setContent(html);
            response.setStatusCode(closeableHttpResponse.getStatusLine().getStatusCode());
            return response;
        }
    });
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Test public void test() {

        MaybeSubject<String> subject = MaybeSubject.create();
        Maybe<String> maybeSource = subject.hide();


        TestObserver testObserver = new TestObserver();
        CompositeDisposable composite = new CompositeDisposable();
        Disposable disposable = maybeSource
                .compose(DisposableAttach.<String>to(composite))
                .subscribeWith(testObserver);

        subject.onSuccess("Foo");
        testObserver.assertValue("Foo");
        assertTrue(composite.size() == 1);
        composite.dispose();
        assertTrue(composite.size() == 0);
        assertTrue(composite.isDisposed());
        assertTrue(disposable.isDisposed());
        assertTrue(testObserver.isDisposed());
    }
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Override
public Maybe<AesKeyPair> findKeyPairFor(int accountId, long sessionId) {
    return Maybe.create(e -> {
        List<AesKeyPair> pairs = mData.get(accountId);
        AesKeyPair result = null;
        if (Objects.nonNull(pairs)) {
            for (AesKeyPair pair : pairs) {
                if (pair.getSessionId() == sessionId) {
                    result = pair;
                    break;
                }
            }
        }

        if (Objects.nonNull(result)) {
            e.onSuccess(result);
        }

        e.onComplete();
    });
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Test
public void testMaybeToSingleEmpty() {
    final List<Object> results = new LinkedList<>();

    singleOrException(Maybe.empty(), HttpStatus.SC_BAD_REQUEST, "Too few elements")
            .subscribe((ignore) -> fail(), (e) -> results.add(e));

    assertEquals(1, results.size());

    Object result = results.get(0);

    if (result.getClass() != ServiceException.class) {
        fail();
    }

    ServiceException serviceException = (ServiceException) result;

    assertEquals(HttpStatus.SC_BAD_REQUEST, serviceException.getStatusCode());
    assertEquals("Too few elements", serviceException.getMessage());
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
public void enqueue(final ModuleCallback<T> callback) {
    synchronized (this) {
        if (mExecuted) {
            throw new IllegalStateException("每个ModuleCall只能enqueue一次");
        }
        mExecuted = true;
    }
    if (mCanceled || mDone) {
        return;
    }
    mModuleCallback = callback;

    if (mObservable instanceof Observable) {
        subscribeObservable((Observable<T>) mObservable);
    } else if (mObservable instanceof Single) {
        subscribeSingle((Single<T>) mObservable);
    } else if (mObservable instanceof Flowable) {
        subscribeFlowable((Flowable<T>) mObservable);
    } else {
        subscribeMaybe((Maybe<T>) mObservable);
    }
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Override
public Maybe<Response> download(Request request) {

    okhttp3.Request okrequest = new okhttp3.Request.Builder()
            .url(request.getUrl())
            .build();

    return Maybe.create(new MaybeOnSubscribe<okhttp3.Response>(){

        @Override
        public void subscribe(MaybeEmitter emitter) throws Exception {

            emitter.onSuccess(client.newCall(okrequest).execute());
        }
    }).map(new Function<okhttp3.Response, Response>() {

        @Override
        public Response apply(okhttp3.Response resp) throws Exception {

            String html = resp.body().string();
            Response response = new Response();
            response.setContent(html);
            response.setStatusCode(resp.code());
            return response;
        }
    });
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
public static <T extends RealmObject> Maybe<T> getElement(final Function<Realm, T> query) {
    return Maybe.create(emitter -> {
        final Realm realm = Realm.getDefaultInstance();
        final T result = query.apply(realm);
        if (result != null && result.isLoaded() && result.isValid()) {
            emitter.onSuccess(realm.copyFromRealm(result));
        } else {
            emitter.onComplete();
        }
        emitter.setCancellable(realm::close);
    });
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Test
public void loadLastForecastOnComplete() {
    when(lastForecastStore.get()).thenReturn(Maybe.<Channel>empty());

    presenter.loadLastForecast();
    verify(view).showContent();
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
/**
 * Asynchronously downloads the object at this {@link StorageReference} to a specified system filepath.
 *
 * @param storageRef     represents a reference to a Google Cloud Storage object.
 * @param destinationUri a file system URI representing the path the object should be downloaded to.
 * @return a {@link Maybe} which emits an {@link FileDownloadTask.TaskSnapshot} if success.
 */
@NonNull
public static Maybe<FileDownloadTask.TaskSnapshot> getFile(@NonNull final StorageReference storageRef,
                                                           @NonNull final Uri destinationUri) {
    return Maybe.create(new MaybeOnSubscribe<FileDownloadTask.TaskSnapshot>() {
        @Override
        public void subscribe(MaybeEmitter<FileDownloadTask.TaskSnapshot> emitter) throws Exception {
            RxHandler.assignOnTask(emitter, storageRef.getFile(destinationUri));
        }
    });
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Test
public void viewsAreOnlyCalledWhenLifecycleActiveWithMaybe() throws Exception {
	Maybe.just("test")
		.compose(LifecycleBinder.bind(lifecycleOwner, new DisposableMaybeObserver<String>() {
			@Override
			public void onSuccess(final String value) {
				LifecycleTest.this.methodOnViewCalled = true;
			}

			@Override
			public void onError(final Throwable e) {
			}

			@Override
			public void onComplete() {
			}
		}));

	// Need to wait to give it time to potentially fail
	TimeUnit.MILLISECONDS.sleep(100);
	assertEquals(false, methodOnViewCalled);

	lifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
	TimeUnit.MILLISECONDS.sleep(100);
	assertEquals(false, methodOnViewCalled);

	lifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_START);
	TimeUnit.MILLISECONDS.sleep(100);
	// At this point the views should now be called since the lifecycle is active
	assertEquals(true, methodOnViewCalled);
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Override
public Maybe<IdentityProvider> read(Long id) {
    IdentityProviderQuery query = new IdentityProviderQuery().setId(id);

    return Single.just(query)
            .compose((single) -> DaoPolicies.applySingle(single))
            .flatMapMaybe((_query) -> dbExecutor.executeSelectFirst(readSql, _query, resultClass));
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
/**
 * Method which retrieve a list of DataSnapshot from multiple {@link DatabaseReference}.
 *
 * @param whereRefs array of {@link DatabaseReference references.}
 * @return a {@link Flowable} which emmit {@link DataSnapshot} from the given queries.
 */
@NonNull
public static Flowable<DataSnapshot> observeMultipleSingleValueEvent(@NonNull DatabaseReference... whereRefs) {
   @SuppressWarnings("unchecked")
   Maybe<DataSnapshot>[] singleQueries = (Maybe<DataSnapshot>[]) Array.newInstance(Maybe.class, whereRefs.length);
   for (int i = 0; i < whereRefs.length; i++) {
      singleQueries[i] = (observeSingleValueEvent(whereRefs[i]));
   }
   return Maybe.mergeArray(singleQueries);
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
/**
 * Asynchronously uploads a stream of data to this {@link StorageReference}.
 *
 * @param storageRef represents a reference to a Google Cloud Storage object.
 * @param metadata   {@link StorageMetadata} containing additional information (MIME type, etc.) about the object being uploaded.
 * @return a {@link Maybe} which emits an {@link StorageMetadata} if success.
 */
@NonNull
public static Maybe<StorageMetadata> updateMetadata(@NonNull final StorageReference storageRef,
                                                    @NonNull final StorageMetadata metadata) {
    return Maybe.create(new MaybeOnSubscribe<StorageMetadata>() {
        @Override
        public void subscribe(MaybeEmitter<StorageMetadata> emitter) throws Exception {
            RxHandler.assignOnTask(emitter, storageRef.updateMetadata(metadata));
        }
    });
}
 

import io.reactivex.Maybe; //导入依赖的package包/类
@Test
public void bind_whenSubscribingWithWorkerLifecycle_shouldMapToWorkerStartEvent() {
  BehaviorRelay<InteractorEvent> lifecycle = BehaviorRelay.createDefault(InteractorEvent.ACTIVE);
  bind(lifecycle, worker);
  verify(worker).onStart(argumentCaptor.capture());

  Maybe observable = argumentCaptor.getValue().requestScope();
  WorkerEventCallback callback = new WorkerEventCallback();
  observable.subscribe(callback);
  lifecycle.accept(InteractorEvent.ACTIVE);
  assertThat(callback.getWorkerEvent()).isEqualTo(WorkerEvent.START);
}