webProtocols = split(fessConfig.getCrawlerWebProtocols(), ",")
                .get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> s.trim() + ":").toArray(n -> new String[n]));
        fileProtocols = split(fessConfig.getCrawlerFileProtocols(), ",")
                .get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> s.trim() + ":").toArray(n -> new String[n]));

        }
    }

    // -----------------------------------------------------
    //                                     Parameter Logging
    //                                     -----------------
    // logging filter cannot show the parameters when multi-part so logging here
    protected void showFieldLoggingTitle() {
        if (logger.isDebugEnabled()) {
            logger.debug("[Multipart Request Parameter]");
        }
    }

import org.codelibs.fess.opensearch.user.cbean.ca.GroupCA;
import org.codelibs.fess.opensearch.user.cbean.cq.GroupCQ;
import org.codelibs.fess.opensearch.user.cbean.cq.bs.BsGroupCQ;
import org.opensearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
import org.opensearch.search.aggregations.bucket.histogram.HistogramAggregationBuilder;

     */
    public OptionalEntity<StemmerOverrideFile> getStemmerOverrideFile(final String dictId) {
        return dictionaryManager.getDictionaryFile(dictId)
                .filter(StemmerOverrideFile.class::isInstance)
                .map(file -> OptionalEntity.of((StemmerOverrideFile) file))
                .orElse(OptionalEntity.empty());
    }

    /**

            final Properties props = new Properties();
            getWebConfig().getConfigParameterMap(ConfigName.CONFIG)
                    .entrySet()
                    .stream()
                    .filter(e -> e.getKey().startsWith(Config.JCIFS_PREFIX))
                    .forEach(e -> {
                        props.setProperty(e.getKey(), e.getValue());
                    });

        Collection<DependencyScope> allDependencyScopes = internalScopeManager.getDependencyScopeUniverse();
        Collection<DependencyScope> nonTransitiveDependencyScopes =
                allDependencyScopes.stream().filter(s -> !s.isTransitive()).collect(Collectors.toSet());
        DependencyScope system =
                internalScopeManager.getDependencyScope(DS_SYSTEM).orElse(null);

    }

    val typeParameters: List<ApiTypeUsage> by unsafeLazy {
        context.apiTypeParametersFor(visitedSignature)
    }

    val functions: List<ApiFunction> by unsafeLazy {
        delegate.methods.filter(::isSignificantDeclaration).map { ApiFunction(asmLevel, incubatingAnnotationTypeDescriptor, this, it, context) }
    }

    private
    fun singleAbstractMethodOf(classNode: ClassNode) =

import org.codelibs.fess.opensearch.log.cbean.cq.FavoriteLogCQ;
import org.codelibs.fess.opensearch.log.cbean.cq.bs.BsFavoriteLogCQ;
import org.opensearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
import org.opensearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;

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

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

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

    public void filtered(FilteredCall<CrawlingInfoParamCQ, CrawlingInfoParamCQ> filteredLambda,
            ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

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