Java Code Examples for java.util.Objects#requireNonNullElseGet()

/**
 * List the verified balance files and parse them. We can process them in any order, but we choose to process the
 * latest balance first since most clients will want to query for the latest data.
 */
@Override
public void parse() {
    Stopwatch stopwatch = Stopwatch.createStarted();

    try {
        File balanceFilePath = parserProperties.getValidPath().toFile();
        File[] balanceFiles = Objects.requireNonNullElseGet(balanceFilePath.listFiles(), () -> new File[] {});
        Arrays.sort(balanceFiles, Collections.reverseOrder());

        for (File balanceFile : balanceFiles) {
            if (ShutdownHelper.isStopping()) {
                throw new RuntimeException("Process is shutting down");
            }
            parseBalanceFile(balanceFile);
        }

        log.info("Completed processing {} balance files in {}", balanceFiles.length, stopwatch);
    } catch (Exception e) {
        log.error("Error processing balances files after {}", stopwatch, e);
    }
}
 

public void renderBook(Format format, Renderer renderer, String size) {

        Objects.requireNonNull(format, "Format cannot be null");
        Objects.requireNonNull(renderer, "Renderer cannot be null");
        String bookSize = Objects.requireNonNullElseGet(size, () -> "125 x 200");

        System.out.println("Rendering ...");
    }
 

@Override
public void async(@Nullable Consumer<T> onSuccess, @Nullable Consumer<RequestException> onError) {
    final Consumer<T> finalOnSuccess = Objects.requireNonNullElseGet(onSuccess, () -> (__) -> {});

    // this should work fine
    //noinspection ConstantConditions
    finalOnSuccess.accept(this.onSuccess(null));
}
 

private BiFunction<Contextual<WithDittoHeaders>, Throwable, Contextual<WithDittoHeaders>> handleEnforcementCompletion() {
    return (result, throwable) -> {
        context.getStartedTimer()
                .map(startedTimer -> startedTimer.tag("outcome", throwable != null ? "fail" : "success"))
                .ifPresent(StartedTimer::stop);
        return Objects.requireNonNullElseGet(result,
                () -> withMessageToReceiver(convertError(throwable), sender()));
    };
}
 

private Json getTags(EnvironmentCreationDto creationDto) {
    boolean internalTenant = entitlementService.internalTenant(creationDto.getCreator(), creationDto.getAccountId());
    Map<String, String> userDefinedTags = creationDto.getTags();
    Set<AccountTag> accountTags = accountTagService.get(creationDto.getAccountId());
    List<AccountTagResponse> accountTagResponses = accountTagToAccountTagResponsesConverter.convert(accountTags);
    defaultInternalAccountTagService.merge(accountTagResponses);
    Map<String, String> accountTagsMap = accountTagResponses
            .stream()
            .collect(Collectors.toMap(AccountTagResponse::getKey, AccountTagResponse::getValue));
    CDPTagGenerationRequest request = CDPTagGenerationRequest.Builder.builder()
            .withCreatorCrn(creationDto.getCreator())
            .withEnvironmentCrn(creationDto.getCrn())
            .withAccountId(creationDto.getAccountId())
            .withPlatform(creationDto.getCloudPlatform())
            .withResourceCrn(creationDto.getCrn())
            .withIsInternalTenant(internalTenant)
            .withUserName(getUserFromCrn(creationDto.getCreator()))
            .withAccountTags(accountTagsMap)
            .withUserDefinedTags(userDefinedTags)
            .build();

    try {
        Map<String, String> defaultTags = costTagging.prepareDefaultTags(request);
        return new Json(new EnvironmentTags(Objects.requireNonNullElseGet(userDefinedTags, HashMap::new), defaultTags));
    } catch (AccountTagValidationFailed aTVF) {
        throw new BadRequestException(aTVF.getMessage());
    } catch (Exception ignored) {
        throw new BadRequestException("Failed to convert dynamic tags.");
    }
}
 

public Car(String name, Color color) {

        this.name = Objects.requireNonNullElse(name, "No name");
        this.color = Objects.requireNonNullElseGet(color, () -> new Color(0, 0, 0));
    }
 

private static CachingImmutableBlockProvider getLoadingSource() {
    return Objects.requireNonNullElseGet(loadingSource, () -> (loadingSource = new CachingImmutableBlockProvider()));
}
 

public static void transferMoney(String recipient, BigDecimal amount) {
	amount = Objects.requireNonNullElseGet(amount, ObjectsRequireNonNullUpdate::calculateDefaultAmount);
	recipient = Objects.requireNonNullElse(recipient, "Phil");

	System.out.println(amount + " is transfered to " + recipient);
}
 

@Override
public File getFileReference(Path pathRelativeToAppDir) {
    String fileName = zkApplication.getData(ConfigCurator.USERAPP_ZK_SUBPATH + "/" + pathRelativeToAppDir.getRelative());
    // File does not exist: Manufacture a non-existing file
    return new File(Objects.requireNonNullElseGet(fileName, pathRelativeToAppDir::getRelative));
}
 

/**
 */
@Override
public String getConfDirectory() {
    return Objects.requireNonNullElseGet(confDirectory, () -> getRootDirectory() + "/WEB-INF/conf/");
}
 

/**
 */
@Override
public String getVarDirectory() {
    return Objects.requireNonNullElseGet(varDirectory, () -> getRootDirectory() + "/var/");
}
 

@Test
public void givenObject_whenRequireNonNullElseGet_thenObject(){
    List<String> aList = Objects.<List>requireNonNullElseGet(null, List::of);
    assertThat(aList, is(List.of()));
}
 

@Override
public Collection<String> nodeIds() {
    return Objects.requireNonNullElseGet(executionNodes, Set::of);
}
 

/**
 * Initialize a new instance specifying the libmodulemd API instance to use
 * @param modulemdApiIn the libmodulemd API to use when resolving modular dependencies
 */
public ContentManager(ModulemdApi modulemdApiIn) {
    this.modulemdApi = Objects.requireNonNullElseGet(modulemdApiIn, ModulemdApi::new);
}
 

/**
 * Initialize a new instance with a content project and a {@link ModulemdApi} instance
 *
 * @param projectIn the content project
 * @param modulemdApiIn the libmodulemd API instance
 */
public DependencyResolver(ContentProject projectIn, ModulemdApi modulemdApiIn) {
    this.project = projectIn;
    this.modulemdApi = Objects.requireNonNullElseGet(modulemdApiIn, ModulemdApi::new);
}