import org.apache.maven.artifact.handler.ArtifactHandler;
import org.apache.maven.artifact.metadata.ArtifactMetadata;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
import org.apache.maven.artifact.versioning.VersionRange;

/**

        return usedTypes.computeIfAbsent(id, i -> {
            Type type = lookup.lookupList(TypeProvider.class).stream()
                    .flatMap(p -> p.provides().stream())
                    .filter(t -> Objects.equals(id, t.id()))
                    .findFirst()
                    .orElse(null);
            if (type == null) {
                // Copy data as the ArtifactHandler is not immutable, but Type should be.

        public void setUp() throws IOException {
            Path userHome = Paths.get(System.getProperty("user.home"));
            poms = Files.walk(userHome.resolve(".m2/repository/org/apache/maven"))
                    .filter(p -> p.getFileName().toString().endsWith(".pom"))
                    .collect(Collectors.toList());
        }
    }

    @Benchmark

    assertEquals(1, (int) iter.next());
    assertTrue(iter.hasNext());
    assertEquals(2, (int) iter.next());
    assertTrue(iter.hasNext());
    assertEquals(3, (int) iter.next());
    assertFalse(iter.hasNext());
  }

  public void testAsEnumerationEmpty() {
    Iterator<Integer> iter = emptyIterator();
    Enumeration<Integer> enumer = Iterators.asEnumeration(iter);

     *
     * @param cb the condition bean for building the database query
     * @param requestHeaderPager the pager containing search and filter criteria
     */
    protected void setupListCondition(final RequestHeaderCB cb, final ReqHeaderPager requestHeaderPager) {
        if (requestHeaderPager.id != null) {

        if (StringUtil.isBlank(value)) {
            defaultResponseHeaders = Collections.emptyList();
            return;
        }

        StreamUtil.split(value, "\n").of(stream -> stream.filter(StringUtil::isNotBlank).forEach(s -> {
            final String[] values = StringUtils.split(s, "=", 2);
            List<Pair<String, String>> list = responseHeaderMap.get(values[0]);
            if (list == null) {

        triggers.add(StageTrigger(model, stage, prevStage, null, allDependencies))

        stageWithOsTriggers.getOrDefault(stage.stageName, emptyList()).forEach { targetOs ->
            val dependencies = allDependencies.filter { it.os == targetOs }
            triggers.add(StageTrigger(model, stage, prevStage, targetOs, dependencies, generateTriggers = false))
        }
    }
}

// https://github.com/gradle/gradle-private/issues/4527

    * This will be used by the **automatic docs**.
    * It will also be used by automatic client code generation tools.

But most importantly:

* It will **limit and filter** the output data to what is defined in the return type.
    * This is particularly important for **security**, we'll see more of that below.

## `response_model` Parameter { #response-model-parameter }

            String propertyValue = properties.getProperty(REMAINING_PROJECTS);
            Stream.of(propertyValue.split(PROPERTY_DELIMITER))
                    .filter(str -> !str.isEmpty())
                    .forEach(request.getProjectActivation()::activateOptionalProjectNonRecursive);
            LOGGER.info("Resuming from {} due to the --resume / -r feature.", propertyValue);
        }

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<GroupCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<GroupCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }