Java Supplier类代码示例

import java.util.function.Supplier; //导入依赖的package包/类
SourceLevelSelector(
        @NonNull final PropertyEvaluator eval,
        @NonNull final String sourceLevelPropName,
        @NonNull final List<? extends Supplier<? extends ClassPath>> cpFactories) {
    Parameters.notNull("eval", eval);   //NOI18N
    Parameters.notNull("sourceLevelPropName", sourceLevelPropName); //NOI18N
    Parameters.notNull("cpFactories", cpFactories); //NOI18N
    if (cpFactories.size() != 2) {
        throw new IllegalArgumentException("Invalid classpaths: " + cpFactories);  //NOI18N
    }
    for (Supplier<?> f : cpFactories) {
        if (f == null) {
            throw new NullPointerException("Classpaths contain null: " + cpFactories);  //NOI18N
        }
    }
    this.eval = eval;
    this.sourceLevelPropName = sourceLevelPropName;
    this.cpfs = cpFactories;
    this.listeners = new PropertyChangeSupport(this);
    this.cps = new ClassPath[2];
    this.eval.addPropertyChangeListener(WeakListeners.propertyChange(this, this.eval));
}
 

import java.util.function.Supplier; //导入依赖的package包/类
/**
 * Computes applicable events.
 *
 * @param <AggregateT>           The aggregate over which the query executes
 * @param <EventIdT>             The type of the {@link EventT}'s id field
 * @param <EventT>               The type of the Event
 * @param <SnapshotIdT>          The type of the {@link SnapshotT}'s id field
 * @param <SnapshotT>            The type of the Snapshot
 * @param forwardOnlyEvents      Known forward only events
 * @param executor               An instance of Executor
 * @param snapshotAndEventsSince Events to use if forwardOnlyEvents is empty
 *
 * @return events that can be applied.
 */
public static <
        AggregateT,
        EventIdT,
        EventT extends BaseEvent<AggregateT, EventIdT, EventT>,
        SnapshotIdT,
        SnapshotT extends BaseSnapshot<AggregateT, SnapshotIdT, EventIdT, EventT>
        > Flowable<EventT> getApplicableEvents(
        Flowable<EventT> forwardOnlyEvents, Executor executor,
        Supplier<Flowable<Pair<SnapshotT, List<EventT>>>> snapshotAndEventsSince) {
    return forwardOnlyEvents
            .filter(e -> e instanceof Deprecates)
            .toList()
            .toFlowable()
            .flatMap(list -> list.isEmpty() ?
                    forwardOnlyEvents :
                    snapshotAndEventsSince.get().flatMap(p ->
                            getForwardOnlyEvents(p.getSecond(), executor, () ->
                                    error(new GroovesException(
                                            "Couldn't apply deprecates events")))
                    ));
}
 

import java.util.function.Supplier; //导入依赖的package包/类
/**
 * Method for Performance Rate Uuid validations
 *
 * @param check a property existence check
 * @param keys that identify measures
 * @return a callback / consumer that will perform a measure specific validation against a given
 * node.
 */
private Consumer<Node> makePerformanceRateUuidValidator(Supplier<String> check, String... keys) {
	return node -> {
		if (check.get() != null) {
			Predicate<Node> childUuidFinder =
					makeUuidChildFinder(check, ErrorCode.QUALITY_MEASURE_ID_MISSING_SINGLE_PERFORMANCE_RATE, PERFORMANCE_RATE_ID);

			Node existingUuidChild = node
					.getChildNodes(TemplateId.PERFORMANCE_RATE_PROPORTION_MEASURE)
					.filter(childUuidFinder)
					.findFirst()
					.orElse(null);

			if (existingUuidChild == null) {
				addMeasureConfigurationValidationMessage(check, keys, node);
			}
		}
	};
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@Test
public void testGenerator() {
    final String prefix1 = "http://example.org/";
    final String prefix2 = "trellis:repository/a/b/c/";
    final IdentifierService svc = new UUIDGenerator();
    final Supplier<String> gen1 = svc.getSupplier(prefix1);
    final Supplier<String> gen2 = svc.getSupplier(prefix2);

    final String id1 = gen1.get();
    final String id2 = gen2.get();

    assertTrue(id1.startsWith(prefix1));
    assertFalse(id1.equals(prefix1));
    assertTrue(id2.startsWith(prefix2));
    assertFalse(id2.equals(prefix2));
}
 

import java.util.function.Supplier; //导入依赖的package包/类
/**
 * Applies the {@code pageMapper} function on each page fetched from the supplied {@code queryRequestSupplier} on
 * the supplied {@code ctpClient}.
 *
 * @param ctpClient            defines the CTP project to apply the query on.
 * @param queryRequestSupplier defines a supplier which, when executed, returns the query that should be made on
 *                             the CTP project.
 * @param resourceMapper       defines a mapper function that should be applied on each resource in the fetched page
 *                             from the query on the specified CTP project.
 */
public static <T extends Resource, C extends QueryDsl<T, C>> void queryAndApply(
    @Nonnull final SphereClient ctpClient,
    @Nonnull final Supplier<QueryDsl<T, C>> queryRequestSupplier,
    @Nonnull final Function<T, SphereRequest<T>> resourceMapper) {

    final Function<List<T>, Stream<CompletableFuture<T>>> pageMapper =
        pageElements -> pageElements.stream()
                                    .map(resourceMapper)
                                    .map(ctpClient::execute)
                                    .map(CompletionStage::toCompletableFuture);

    CtpQueryUtils.queryAll(ctpClient, queryRequestSupplier.get(), pageMapper)
                 .thenApply(list -> list.stream().flatMap(Function.identity()))
                 .thenApply(stream -> stream.toArray(CompletableFuture[]::new))
                 .thenCompose(CompletableFuture::allOf)
                 .toCompletableFuture().join();
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@DataProvider(name="maps")
static Object[][] mapCases() {
    if (collections != null) {
        return collections;
    }

    List<Object[]> cases = new ArrayList<>();
    for (int size : new int[] {1, 2, 16}) {
        cases.add(new Object[] {
                String.format("new HashMap(%d)", size),
                (Supplier<Map<Integer, Integer>>)
                () -> Collections.unmodifiableMap(fillMap(size, new HashMap<>())) });
        cases.add(new Object[] {
                String.format("new TreeMap(%d)", size),
                (Supplier<Map<Integer, Integer>>)
                () -> Collections.unmodifiableSortedMap(fillMap(size, new TreeMap<>())) });
    }

    return cases.toArray(new Object[0][]);
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@Override
protected void registerItem(EndpointsEntry entry, MethodSpec.Builder methodBuilder) {
    final FullClassName handlerEndpoint = new FullClassName(entry.element.fullQualifiedNoneGenericName() + "EndpointHandler");
    String path = entry.element.getAnnotation(Handler.class).value();

    ClassName handlerEndpointType = ClassName.get(handlerEndpoint.asPackage(), handlerEndpoint.asSimpleName());
    MethodSpec getMethod = MethodSpec.methodBuilder("get")
            .addAnnotation(Override.class)
            .addModifiers(Modifier.PUBLIC)
            .returns(handlerEndpointType)
            .addStatement("return new $T()", handlerEndpointType)
            .build();

    TypeSpec factoryType = TypeSpec.anonymousClassBuilder("")
            .addSuperinterface(ParameterizedTypeName.get(ClassName.get(Supplier.class), handlerEndpointType.box()))
            .addMethod(getMethod)
            .build();
    methodBuilder.addStatement("registry.registerEndpoint(\"" + path + "\", $L)", factoryType);
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@Test
public void testSubNetworkInterfaces() throws SocketException {
    Supplier<Stream<NetworkInterface>> ss = () -> {
        try {
            return allNetworkInterfaces();
        }
        catch (SocketException e) {
            throw new RuntimeException(e);
        }
    };

    Collection<NetworkInterface> expected = getAllNetworkInterfaces();
    withData(TestData.Factory.ofSupplier("All network interfaces", ss))
            .stream(s -> s)
            .expectedResult(expected)
            .exercise();
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@Test
public void testNetworkInterfaces() throws SocketException {
    Supplier<Stream<NetworkInterface>> ss = () -> {
        try {
            return NetworkInterface.networkInterfaces()
                    .filter(ni -> isIncluded(ni));
        }
        catch (SocketException e) {
            throw new RuntimeException(e);
        }
    };

    Collection<NetworkInterface> enums = Collections.list(NetworkInterface.getNetworkInterfaces());
    Collection<NetworkInterface> expected = new ArrayList<>();
    enums.forEach(ni -> {
        if (isIncluded(ni)) {
            expected.add(ni);
        }
    });
    withData(TestData.Factory.ofSupplier("Top-level network interfaces", ss))
            .stream(s -> s)
            .expectedResult(expected)
            .exercise();
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void testMismatchingUsedVariablesAndVariableDefinitions() {
  Supplier<InputStream> sourceFile = () -> SmtEncoderTest.class.getResourceAsStream(
      "spec_freevariable.xml");

  ValidSpecification spec = TestUtils.importValidSpec(sourceFile.get(), new TypeEnum(
      "Color",
      Arrays.asList("red", "green", "blue")));
  List<ValidFreeVariable> freeVariables = TestUtils.importValidFreeVariables(sourceFile.get(),
      new TypeEnum("Color",
          Arrays.asList("red", "green", "blue")));

  int maxDuration = 5;


  SmtEncoder smtEncoder = new SmtEncoder(maxDuration, spec, Collections.emptyList());
  SmtModel output = smtEncoder.getConstraint();
  List<SExpression> constraints = output.getGlobalConstraints();
  Collection<SExpression> definitions = output.getVariableDefinitions();



}
 

import java.util.function.Supplier; //导入依赖的package包/类
private void buildRefreshModelChain() {
    Supplier<Set<StackData>> stacksSupplier = new DataSourceStacksSupplier(commonDaoFacade, appName);
    TaskFactory taskFactory = new TaskFactory(DataSource.DATA_STORE);

    refreshModelChain = new TaskChain( new InitDataStoreTask(modelFacade))
        .and(taskFactory.newGetFlavorRules())
        .and(taskFactory.newGetUrlRules())
        .and(taskFactory.newGetWhitelistedStacks())
        .and(taskFactory.newGetNamespacedLists())
        .and(taskFactory.newGetStacksWithHostsTask(stacksSupplier))
        .and(taskFactory.newBackupStacksInMemory())
        .and(taskFactory.newValidateAbleToRedirectTask())
        .and(taskFactory.newApplyNewModelTask());

    if (isStaticDiscoveryNeededForApp.test(appName)) {
        refreshModelChain.and(new TriggerManualBackupTask(stacksBackupManager));
    }

    refreshModelChain.and(new BackupNewModelTask(flavorRulesHolder, whiteListHolder, urlRulesHolder, modelMetadataHolder));
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@Test
public void allStringJoins() {
    List<Supplier<Refactor.LongTrackFinder>> finders = Arrays.<Supplier<Refactor.LongTrackFinder>>asList(
        Refactor.Step0::new,
        Refactor.Step1::new,
        Refactor.Step2::new,
        Refactor.Step3::new,
        Refactor.Step4::new
    );

    List<Album> albums = unmodifiableList(asList(SampleData.aLoveSupreme, SampleData.sampleShortAlbum));
    List<Album> noTracks = unmodifiableList(asList(SampleData.sampleShortAlbum));

    finders.forEach(finder -> {
        System.out.println("Testing: " + finder.toString());

        Refactor.LongTrackFinder longTrackFinder = finder.get();
        Set<String> longTracks = longTrackFinder.findLongTracks(albums);

        assertEquals("[Acknowledgement, Resolution]", longTracks.toString());

        longTracks = longTrackFinder.findLongTracks(noTracks);

        assertTrue(longTracks.isEmpty());
    });
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@Test
public void testUnawaitedBackgroundWorkShouldCompleteWithoutSyncBlock() throws Exception {
	CompletableFuture<Void> unawaitedWorkCompleted = new CompletableFuture<>();
	Supplier<CompletableFuture<Void>> otherAsyncMethod = ExecutionContext.wrap(() -> {
		StrongBox<CompletableFuture<Void>> result = new StrongBox<>();
		Consumer<Void> implementation = ignored -> result.value = Async.awaitAsync(
			// this posts to the JoinableTask.threadPoolQueue
			Async.yieldAsync(),
			() -> Async.awaitAsync(
				// this should schedule directly to the .NET ThreadPool.
				Async.yieldAsync(),
				() -> {
					unawaitedWorkCompleted.complete(null);
					return Futures.completedNull();
				}));

		ExecutionContext.run(ExecutionContext.capture(), implementation, null);
		return result.value;
	});

	CompletableFuture<Void> bkgrndThread = Futures.runAsync(() -> {
		asyncPump.run(() -> {
			TplExtensions.forget(otherAsyncMethod.get());
			return Futures.completedNull();
		});
	});

	bkgrndThread.join();
	unawaitedWorkCompleted.get(EXPECTED_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS);
}
 

import java.util.function.Supplier; //导入依赖的package包/类
@Override
public void maybeAssignManifoldType( ClassLoader loader, String fqn, URL url, BiConsumer<String, Supplier<byte[]>> assigner )
{
  Set<ITypeManifold> sps = getCurrentModule().findTypeManifoldsFor( fqn );
  if( !sps.isEmpty() )
  {
    assigner.accept( fqn, null );
  }
}
 

import java.util.function.Supplier; //导入依赖的package包/类
protected <T> CompletableFuture<T> delayedException (final long delay, final Supplier<Exception> exceptionSupplier) {
    final CompletableFuture<T> future = new CompletableFuture<>();
    rule.vertx().setTimer(delay, l -> rule.vertx().runOnContext(v -> {
        future.completeExceptionally(exceptionSupplier.get());
    }));
    return future;
}