io.reactivex.MaybeSource Java Examples

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
    switch (mSchedulerType) {
        case _main:
            return upstream.observeOn(AndroidSchedulers.mainThread());
        case _io:
            return upstream.observeOn(RxSchedulerUtils.io(mIOExecutor));
        case _io_main:
            return upstream
                    .subscribeOn(RxSchedulerUtils.io(mIOExecutor))
                    .unsubscribeOn(RxSchedulerUtils.io(mIOExecutor))
                    .observeOn(AndroidSchedulers.mainThread());
        case _io_io:
            return upstream
                    .subscribeOn(RxSchedulerUtils.io(mIOExecutor))
                    .unsubscribeOn(RxSchedulerUtils.io(mIOExecutor))
                    .observeOn(RxSchedulerUtils.io(mIOExecutor));
        default:
            break;
    }
    return upstream;
}
 

@Override
public MaybeSource<T> apply(@NonNull Maybe<B> upstream) {
  Maybe<Buffer> unwrapped = upstream.map(unwrap::apply);
  Maybe<T> unmarshalled = unwrapped.concatMap(buffer -> {
    if (buffer.length() > 0) {
      try {
        T obj;
        if (mapper != null) {
          JsonParser parser = mapper.getFactory().createParser(buffer.getBytes());
          obj = nonNull(mappedType) ? mapper.readValue(parser, mappedType) :
            mapper.readValue(parser, mappedTypeRef);
        } else {
          obj = getT(buffer, mappedType, mappedTypeRef);
        }
        return Maybe.just(obj);
      } catch (Exception e) {
        return Maybe.error(e);
      }
    } else {
      return Maybe.empty();
    }
  });
  return unmarshalled;
}
 

private Single<JWT> validateSignature(SignedJWT jwt, Client client) {
    return jwkService.getKeys(client)
            .switchIfEmpty(Maybe.error(new InvalidRequestObjectException()))
            .flatMap(new Function<JWKSet, MaybeSource<JWK>>() {
                @Override
                public MaybeSource<JWK> apply(JWKSet jwkSet) throws Exception {
                    return jwkService.getKey(jwkSet, jwt.getHeader().getKeyID());
                }
            })
            .switchIfEmpty(Maybe.error(new InvalidRequestObjectException()))
            .flatMapSingle(new Function<JWK, SingleSource<JWT>>() {
                @Override
                public SingleSource<JWT> apply(JWK jwk) throws Exception {
                    // 6.3.2.  Signed Request Object
                    // To perform Signature Validation, the alg Header Parameter in the
                    // JOSE Header MUST match the value of the request_object_signing_alg
                    // set during Client Registration
                    if (jwt.getHeader().getAlgorithm().getName().equals(client.getRequestObjectSigningAlg()) &&
                            jwsService.isValidSignature(jwt, jwk)) {
                        return Single.just(jwt);
                    } else {
                        return Single.error(new InvalidRequestObjectException("Invalid signature"));
                    }
                }
            });
}
 

/**
 * This {@link Observable} will not emit values by design. It may only emit {@link BleScanException} if
 * bluetooth adapter is turned down.
 */
<T> Observable<T> bluetoothAdapterOffExceptionObservable() {
    return rxBleAdapterStateObservable
            .filter(new Predicate<BleAdapterState>() {
                @Override
                public boolean test(BleAdapterState state) {
                    return state != BleAdapterState.STATE_ON;
                }
            })
            .firstElement()
            .flatMap(new Function<BleAdapterState, MaybeSource<T>>() {
                @Override
                public MaybeSource<T> apply(BleAdapterState bleAdapterState) {
                    return Maybe.error(new BleScanException(BleScanException.BLUETOOTH_DISABLED));
                }
            })
            .toObservable();
}
 

private MaybeSource<? extends JsonObject> deleteIncompleteUser(JsonObject query, Throwable err) {
  if (isIndexViolated(err)) {
    return mongoClient
      .rxRemoveDocument("user", query)
      .flatMap(del -> Maybe.error(err));
  } else {
    return Maybe.error(err);
  }
}
 

public static <T> Maybe<T> wrap(
  MaybeSource<T> source, CurrentTraceContext contextScoper, TraceContext assembled) {
  if (source instanceof Callable) {
    return new TraceContextCallableMaybe<>(source, contextScoper, assembled);
  }
  return new TraceContextMaybe<>(source, contextScoper, assembled);
}
 

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
  return sqlConnection.rxSetAutoCommit(false)
    .andThen(upstream)
    .flatMap(item -> sqlConnection.rxCommit().andThen(Maybe.just(item)), Maybe::error, () -> sqlConnection.rxCommit().andThen(Maybe.empty()))
    .onErrorResumeNext(throwable -> {
      return sqlConnection.rxRollback().onErrorComplete()
        .andThen(sqlConnection.rxSetAutoCommit(true).onErrorComplete())
        .andThen(Maybe.error(throwable));
    }).flatMap(item -> sqlConnection.rxSetAutoCommit(true).andThen(Maybe.just(item)), Maybe::error, () -> sqlConnection.rxSetAutoCommit(true).andThen(Maybe.empty()));
}
 

@Override
public Maybe<Client> assertClient(String assertionType, String assertion, String basePath) {

    InvalidClientException unsupportedAssertionType = new InvalidClientException("Unknown or unsupported assertion_type");

    if (assertionType == null || assertionType.isEmpty()) {
        return Maybe.error(unsupportedAssertionType);
    }

    if (JWT_BEARER.equals(assertionType)) {
        return this.validateJWT(assertion, basePath)
                .flatMap(new Function<JWT, MaybeSource<Client>>() {
                    @Override
                    public MaybeSource<Client> apply(JWT jwt) throws Exception {
                        // Handle client_secret_key client authentication
                        if (JWSAlgorithm.Family.HMAC_SHA.contains(jwt.getHeader().getAlgorithm())) {
                            return validateSignatureWithHMAC(jwt);
                        } else {
                            // Handle private_key_jwt client authentication
                            return validateSignatureWithPublicKey(jwt);
                        }
                    }
                });
    }

    return Maybe.error(unsupportedAssertionType);
}
 

private MaybeSource<Optional<Client>> clientSource(String audience) {
    if (audience == null) {
        return Maybe.just(Optional.empty());
    }

    return clientSyncService.findById(audience)
            .map(client -> Optional.of(client))
            .defaultIfEmpty(Optional.empty());
}
 

private MaybeSource<SensorSnapshot> makeSnapshot(String sensorId, SensorRegistry sensorRegistry)
    throws Exception {
  BehaviorSubject<ScalarReading> subject = latestValues.get(sensorId);
  if (subject == null) {
    return Maybe.empty();
  }
  final GoosciSensorSpec.SensorSpec spec = getSensorSpec(sensorId, sensorRegistry);
  return subject.firstElement().map(value -> generateSnapshot(spec, value));
}
 

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
    Maybe<T> tObservable = upstream
            .observeOn(AndroidSchedulers.mainThread());
    if (provider == null) {
        return tObservable;
    }
    return tObservable.compose(RxLifecycleDelegate.<T>bindLifecycle(provider));
}
 

@NonNull
private Function<StockUpdate, MaybeSource<? extends StockUpdate>> skipTweetsThatDoNotContainKeywords(String[] trackingKeywords) {
    return update -> Observable.fromArray(trackingKeywords)
            .filter(keyword -> update.getTwitterStatus().toLowerCase().contains(keyword.toLowerCase()))
            .map(keyword -> update)
            .firstElement();
}
 

@NonNull
private Function<StockUpdate, MaybeSource<? extends StockUpdate>> skipTweetsThatDoNotContainKeywords(String[] trackingKeywords) {
    return update -> Observable.fromArray(trackingKeywords)
            .filter(keyword -> update.getTwitterStatus().toLowerCase().contains(keyword.toLowerCase()))
            .map(keyword -> update)
            .firstElement();
}
 

private MaybeSource<? extends JsonObject> insertExtraInfo(JsonObject extraInfo, String docId) {
  JsonObject query = new JsonObject().put("_id", docId);
  return mongoClient
    .rxFindOneAndUpdate("user", query, extraInfo)
    .onErrorResumeNext(err -> {
      return deleteIncompleteUser(query, err);
    });
}
 

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
    return upstream;
}
 

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
    return upstream.takeUntil(mObservable.firstElement());
}
 

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
    return upstream.takeUntil(mObservable.firstElement());
}
 

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
    return upstream.takeUntil(mObservable.firstElement());
}
 

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
    return upstream.takeUntil(mObservable.firstElement());
}
 

@Override
public MaybeSource apply(Maybe upstream) {

    return request.getDownloadDelay() > 0 ? upstream.delay(request.getDownloadDelay(), TimeUnit.MILLISECONDS) : upstream;
}
 

@Override
public MaybeSource apply(Maybe upstream) {

    return executor != null ? upstream.observeOn(Schedulers.from(executor)) : upstream;
}
 

@Override
public MaybeSource<T> apply(Maybe<T> upstream) {
    return upstream.takeUntil(observable.firstElement());
}
 

RequestContextCallableMaybe(MaybeSource<T> source, RequestContext assemblyContext) {
    this.source = source;
    this.assemblyContext = assemblyContext;
}
 

RequestContextScalarCallableMaybe(MaybeSource<T> source, RequestContext assemblyContext) {
    this.source = source;
    this.assemblyContext = assemblyContext;
}
 

RequestContextMaybe(MaybeSource<T> source, RequestContext assemblyContext) {
    this.source = source;
    this.assemblyContext = assemblyContext;
}
 

TraceContextCallableMaybe(
  MaybeSource<T> source, CurrentTraceContext contextScoper, TraceContext assembled) {
  this.source = source;
  this.contextScoper = contextScoper;
  this.assembled = assembled;
}
 

TraceContextMaybe(
  MaybeSource<T> source, CurrentTraceContext contextScoper, TraceContext assembled) {
  this.source = source;
  this.contextScoper = contextScoper;
  this.assembled = assembled;
}