public static <R extends Result> SingleTransformer<R, R> forSingle() {
    return upstream -> upstream.onErrorResumeNext(throwable -> {
        if(throwable instanceof StatusException) {
            StatusException statusException = (StatusException) throwable;

            if(statusException.getStatus().hasResolution()) {
                return Single.just((R) statusException.getResult());
            } else {
                return Single.error(throwable);
            }

        } else {
            return Single.error(throwable);
        }
    });
}
 

/**
 * 拆壳
 *
 * @param <T>
 * @return
 */
public static <T> SingleTransformer<RespData<T>, T> handleSingleDataResult() {
    return new SingleTransformer<RespData<T>, T>() {
        @Override
        public SingleSource<T> apply(Single<RespData<T>> upstream) {
            return upstream
                    .map(new TransToData<T>())
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
        }

    };
}
 

/**
 * 不拆壳
 *
 * @param <T>
 * @return
 */
public static <T> SingleTransformer<RespData<T>, RespData<T>> handleSingleToResult() {
    return new SingleTransformer<RespData<T>, RespData<T>>() {
        @Override
        public SingleSource<RespData<T>> apply(Single<RespData<T>> upstream) {
            return upstream
                    .map(new TransToResult<T>())
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
        }

    };
}
 

private SingleTransformer<Token[], Token[]> attachDefaultTokens(Wallet wallet)
{
    return upstream -> Single.zip(
            upstream, ethereumNetworkRepository.getBlankOverrideTokens(wallet),
            (tokens, defaultTokens) ->
            {
                List<Token> result = mergeTokens(tokens, defaultTokens);
                return result.toArray(new Token[0]);
            });
}
 

private SingleTransformer<Token[], Token[]> attachEthereumStored(Wallet wallet)
{
    return upstream -> Single.zip(
            upstream, attachCachedEth(wallet),
            (tokens, ethTokens) ->
            {
                List<Token> result = new ArrayList<>();
                result.addAll(ethTokens);
                for (Token t : tokens) if (!t.isEthereum()) result.add(t);
                return result.toArray(new Token[0]);
            });
}
 

private <T> SingleTransformer<T, T> retry() {
    return new SingleTransformer<T, T>() {
        @Override
        public SingleSource<T> apply(Single<T> upstream) {
            return upstream.retryWhen(new Function<Flowable<Throwable>, Publisher<Object>>() {

                private final int MAX_COUNT = 3;
                private int count = 0;

                private final int DELAY_SECOND = 10;

                @Override
                public Publisher<Object> apply(Flowable<Throwable> throwableFlowable) throws Exception {
                    return throwableFlowable.flatMap(new Function<Throwable, Publisher<?>>() {
                        @Override
                        public Publisher<?> apply(Throwable throwable) throws Exception {
                            if (count++ < MAX_COUNT && throwable instanceof HttpException) {
                                final HttpException httpException = (HttpException) throwable;
                                if (httpException.code() == 403) {
                                    return Flowable.timer(DELAY_SECOND, TimeUnit.SECONDS);
                                }
                            }
                            return Flowable.error(throwable);
                        }
                    });
                }
            });
        }
    };
}
 

public <R> SingleTransformer<? super R, ? extends R> compose() {
    return new SingleTransformer<R, R>() {
        @Override
        public SingleSource<R> apply(@NonNull Single<R> upstream) {
            return upstream
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .doOnSubscribe(AbstractPresenter.this::call);
        }
    };
}
 

private SingleTransformer<BluetoothGatt, BluetoothGatt> wrapWithTimeoutWhenNotAutoconnecting() {
    return new SingleTransformer<BluetoothGatt, BluetoothGatt>() {
        @Override
        public Single<BluetoothGatt> apply(Single<BluetoothGatt> bluetoothGattSingle) {
            return autoConnect
                    ? bluetoothGattSingle
                    : bluetoothGattSingle
                    .timeout(connectTimeout.timeout, connectTimeout.timeoutTimeUnit, connectTimeout.timeoutScheduler,
                            prepareConnectionTimeoutError());
        }
    };
}
 

public SingleUseCase(final UseCaseExecutor useCaseExecutor,
                     final PostExecutionThread postExecutionThread) {
    super(useCaseExecutor, postExecutionThread);
    schedulersTransformer = new SingleTransformer<R, R>() {
        @Override
        public Single<R> apply(Single<R> single) {
            return single.subscribeOn(useCaseExecutor.getScheduler())
                    .observeOn(postExecutionThread.getScheduler());
        }
    };
}
 

public static SingleTransformer<Wallet, Wallet> savePassword(WalletRepository walletRepository) {
    return new SavePasswordOperator(walletRepository);
}
 

public static <T> SingleTransformer<T, T> singleIo2Main() {
    return upstream -> upstream.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread());
}
 

public static SingleTransformer<Wallet, Wallet> savePassword(
        PasswordStore passwordStore, WalletRepositoryType walletRepository, String password) {
    return new SavePasswordOperator(passwordStore, walletRepository, password);
}
 

@Override
protected SingleTransformer<Peripheral, Irrelevant> postWrite() {
  return single -> single.flatMap(peripheral -> Single.just(Irrelevant.INSTANCE));
}
 

public static <T> SingleTransformer<T, T> applySingleSchedulers() {
    return f -> f.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread());
}
 

private SingleTransformer<? super R, ? extends R> getSchedulersTransformer() {
    return schedulersTransformer;
}
 

public static <T> SingleTransformer<T, T> applySingleScheduler() {
  return upstream -> upstream.subscribeOn(Schedulers.io())
      .observeOn(AndroidSchedulers.mainThread());
}
 

public static <T> SingleTransformer<T, T> applySingleSchedulerToIO() {
  return upstream -> upstream.subscribeOn(Schedulers.io())
      .observeOn(Schedulers.io());
}
 

public <T> SingleTransformer<T, T> singleSchedulers() {
  //noinspection unchecked
  return (SingleTransformer<T, T>) singleSchedulers;
}
 

public static <T> SingleTransformer<Buffer, T> unmarshaller(Class<T> mappedType) {
  return new SingleUnmarshaller<>(Buffer::getDelegate, mappedType);
}
 

public static <T> SingleTransformer<Buffer, T> unmarshaller(TypeReference<T> mappedTypeRef) {
  return new SingleUnmarshaller<>(Buffer::getDelegate, mappedTypeRef);
}
 

public static <T> SingleTransformer<Buffer, T> unmarshaller(Class<T> mappedType, ObjectCodec mapper) {
  return new SingleUnmarshaller<>(Buffer::getDelegate, mappedType, mapper);
}
 

public static <T> SingleTransformer<Buffer, T> unmarshaller(TypeReference<T> mappedTypeRef, ObjectCodec mapper) {
  return new SingleUnmarshaller<>(Buffer::getDelegate, mappedTypeRef, mapper);
}
 

public static <T> SingleTransformer<Buffer, T> unmarshaller(Class<T> mappedType) {
  return new SingleUnmarshaller<>(java.util.function.Function.identity(), mappedType);
}
 

public static <T> SingleTransformer<Buffer, T> unmarshaller(TypeReference<T> mappedTypeRef) {
  return new SingleUnmarshaller<>(java.util.function.Function.identity(), mappedTypeRef);
}
 

public static <T> SingleTransformer<Buffer, T> unmarshaller(Class<T> mappedType, ObjectCodec mapper) {
  return new SingleUnmarshaller<>(java.util.function.Function.identity(), mappedType, mapper);
}
 

public static <T> SingleTransformer<Buffer, T> unmarshaller(TypeReference<T> mappedTypeRef, ObjectCodec mapper) {
  return new SingleUnmarshaller<>(java.util.function.Function.identity(), mappedTypeRef, mapper);
}
 

protected abstract SingleTransformer<Peripheral, T> postWrite();