final int maxQueryLength = fessConfig.getQueryMaxLengthAsInteger();

        stream(conditions.get(SearchRequestParams.AS_OCCURRENCE))
                .of(stream -> stream.filter(this::isOccurrence).findFirst().ifPresent(q -> queryBuf.insert(0, q + ":")));

        stream(conditions.get(SearchRequestParams.AS_Q)).of(stream -> stream

   * streams.
   *
   * <p>If the stream has nondeterministic order, this has equivalent semantics to {@link
   * Stream#findAny} (which you might as well use).
   *
   * @see Stream#findFirst()
   * @throws NullPointerException if the last element of the stream is null
   */
  /*
   * By declaring <T> instead of <T extends @Nullable Object>, we declare this method as requiring a

        }

        private Relocation getRelocation(Artifact artifact) {
            return relocations.stream()
                    .filter(r -> r.predicate.test(artifact))
                    .findFirst()
                    .orElse(null);
        }
    }

    private Relocations parseRelocations(RepositorySystemSession session) {

        DispatcherMeta meta = secDispatcher.availableDispatchers().stream()
                .filter(d -> Objects.equals(config.getDefaultDispatcher(), d.name()))
                .findFirst()
                .orElseThrow();
        if (!meta.fields().isEmpty()) {
            result = prompt.prompt(
                    context.header,

                        FAMILY_UNIX,
                        FAMILY_WIN9X,
                        FAMILY_WINDOWS,
                        FAMILY_ZOS)
                .filter(Os::isFamily)
                .findFirst()
                .orElse(null);
    }

            if (e.getSecond().matcher(url).matches()) {
                return e.getFirst();
            }
            return null;
        }).filter(StringUtil::isNotBlank).findFirst()//
                .map(s -> clientFactory.getClient(s + ":" + url))//
                .orElseGet(() -> clientFactory.getClient(url));
        if (logger.isDebugEnabled()) {

                return result;
            } else {
                session.getAllProjects().stream()
                        .filter(MavenProject::isExecutionRoot)
                        .findFirst()
                        .ifPresent(buildResumptionDataRepository::removeResumptionData);
            }
        } finally {
            try {
                afterSessionEnd(session);

                        .filter(p -> artifact.equals(p.getArtifact()))
                        .map(MavenProject::getRemoteArtifactRepositories)
                        .findFirst()
                        .orElseGet(() -> getRepositoriesFromModel(repositorySession, model));
            } else {
                pomRepositories = new ArrayList<>();
            }

            this.currentProject = ThreadLocal.withInitial(() -> first);
            this.topLevelProject = projects.stream()
                    .filter(project -> project.isExecutionRoot())
                    .findFirst()
                    .orElse(first);
        } else {
            this.currentProject = new ThreadLocal<>();
            this.topLevelProject = null;
        }
        this.projects = projects;
    }

                    .filter(r -> Objects.equals(r.getId(), externalRepository.getId()))
                    .filter(r -> !Objects.equals(r.getUrl(), externalRepository.getUrl()))
                    .findFirst();
            if (clashingPomRepository.isPresent()) {
                addViolation(
                        problems,
                        Severity.WARNING,
                        Version.BASE,