Java Code Examples for scala.concurrent.Future#successful()

@Override
public Future<Void> doAsyncDeleteMessagesTo(final String persistenceId, final long toSequenceNr) {
    LOGGER.debug("[doAsyncDeleteMessagesTo]: persistenceId {}, toSequenceNr {}", persistenceId, toSequenceNr);
    journalMock.doAsyncDeleteMessagesTo(persistenceId, toSequenceNr);
    if (FAIL_DELETE_MESSAGE.equals(persistenceId)) {
        final CompletableFuture<Void> failDeleteMessage = new CompletableFuture<>();
        failDeleteMessage.completeExceptionally(new IllegalStateException(FAIL_DELETE_MESSAGE));
        return FutureConverters.toScala(failDeleteMessage);
    } else if (SLOW_DELETE.equals(persistenceId)) {
        final CompletableFuture<Void> completableFuture = new CompletableFuture<>();
        // do not complete future to simulate long running delete
        return FutureConverters.toScala(completableFuture);
    }else {
        return Future.successful(null);
    }
}
 

@Override
public Future<Optional<SelectedSnapshot>> doLoadAsync(final String persistenceId,
        final SnapshotSelectionCriteria criteria) {
    // return something - not relevant for current tests
    final SnapshotMetadata metadata = new SnapshotMetadata(persistenceId, 0, 0);
    final SelectedSnapshot selectedSnapshot = SelectedSnapshot.apply(metadata, 1L);
    return Future.successful(Optional.of(selectedSnapshot));
}
 

@Override
public Future<Void> doDeleteAsync(final SnapshotMetadata metadata) {
    LOGGER.debug("[doDeleteAsync]: {}", metadata);
    snapshotStore.doDeleteAsync(metadata);
    if (FAIL_DELETE_SNAPSHOT.equals(metadata.persistenceId())) {
        final CompletableFuture<Void> failDeleteSnapshot = new CompletableFuture<>();
        failDeleteSnapshot.completeExceptionally(new IllegalStateException(FAIL_DELETE_SNAPSHOT));
        return FutureConverters.toScala(failDeleteSnapshot);
    } else {
        return Future.successful(null);
    }
}
 

@Override
public Future<Void> doDeleteAsync(final String persistenceId, final SnapshotSelectionCriteria criteria) {
    LOGGER.debug("[doDeleteAsync]: {} -> {}", persistenceId, criteria);
    snapshotStore.doDeleteAsync(persistenceId, criteria);
    if (FAIL_DELETE_SNAPSHOT.equals(persistenceId)) {
        final CompletableFuture<Void> failDeleteSnapshot = new CompletableFuture<>();
        failDeleteSnapshot.completeExceptionally(new IllegalStateException(FAIL_DELETE_SNAPSHOT));
        return FutureConverters.toScala(failDeleteSnapshot);
    } else {
        return Future.successful(null);
    }
}
 

@Override
public Future<Void> doAsyncReplayMessages(final String persistenceId, final long fromSequenceNr,
        final long toSequenceNr,
        final long max, final Consumer<PersistentRepr> replayCallback) {
    LOGGER.debug("[doAsyncReplayMessages]: persistenceId {}, fromSequenceNr {}, toSequenceNr {}, max {}",
            persistenceId,
            fromSequenceNr, toSequenceNr, max);
    return Future.successful(null);
}
 

@Override
public Future<Iterable<Optional<Exception>>> doAsyncWriteMessages(final Iterable<AtomicWrite> messages) {
    LOGGER.debug("[doAsyncWriteMessages]: messages {}", messages);
    final Iterable<Optional<Exception>> collect =
            Stream.of(messages).map(m -> Optional.<Exception>empty()).collect(Collectors.toList());
    return Future.successful(collect);
}
 

@Benchmark
public Future<String> value() {
  return Future.successful(string);
}
 

private Future<Integer> loop(int i) {
  if (i > 0)
    return Future.successful(i - 1).flatMap(this::loop, ec);
  else
    return Future.successful(0);
}
 

@Override
public Future<Void> doSaveAsync(final SnapshotMetadata metadata, final Object snapshot) {
    LOGGER.debug("[doSaveAsync]: {} -> {}", metadata, snapshot);
    return Future.successful(null);
}
 

@Override
public Future<Long> doAsyncReadHighestSequenceNr(final String persistenceId, final long fromSequenceNr) {
    LOGGER.debug("[doAsyncReadHighestSequenceNr]: persistenceId {}, fromSequenceNr {}", persistenceId,
            fromSequenceNr);
    return Future.successful(0L);
}
 

@Benchmark
public Future<String> value() {
  return Future.successful(string);
}
 

private Future<Integer> loop(int i) {
  if (i > 0)
    return Future.successful(i - 1).flatMap(this::loop, ec);
  else
    return Future.successful(0);
}