if (StringUtil.isNotBlank(getFessConfig().getCrawlerDocumentSiteEncoding())
                    && (!getFessConfig().isCrawlerDocumentUseSiteEncodingOnEnglish() || "ISO-8859-1".equalsIgnoreCase(encoding)
                            || "US-ASCII".equalsIgnoreCase(encoding))) {
                enc = getFessConfig().getCrawlerDocumentSiteEncoding();
            } else {
                enc = encoding;
            }

            try {

     *         or empty OptionalEntity otherwise
     */
    public static OptionalEntity<String> getOverrideConfPath() {
        if (FESS_APP_DOCKER.equalsIgnoreCase(getAppType())) {
            final String confPath = System.getenv(FESS_OVERRIDE_CONF_PATH);
            if (StringUtil.isNotBlank(confPath)) {
                return OptionalEntity.of(confPath);
            }

        private ExactMatcher(String provides) {
            this.provides = provides;
        }

        @Override
        public boolean matches(String requirement) {
            return provides.equalsIgnoreCase(requirement);
        }

        @Override
        public String toString() {
            return provides;
        }
    }

    private static final class VersionMatcher implements RequirementMatcher {

        if (other instanceof final MIEName terg) {
            if (Objects.equals(this.oid, terg.oid)
                    && (this.name == null && terg.name == null || this.name != null && this.name.equalsIgnoreCase(terg.name))) {
                return true;
            }
        }
        return false;
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#hashCode()
     */

                        final String secure = fessConfig.getCookieSearchParameterSecure();
                        if (StringUtil.isBlank(secure)) {
                            final String forwardedProto = req.getHeader("X-Forwarded-Proto");
                            if ("https".equalsIgnoreCase(forwardedProto)) {

   * String#equalsIgnoreCase}). However in almost all cases that ASCII strings are used, the author
   * probably wanted the behavior provided by this method rather than the subtle and sometimes
   * surprising behavior of {@code toUpperCase()} and {@code toLowerCase()}.
   *
   * @since 16.0
   */
  public static boolean equalsIgnoreCase(CharSequence s1, CharSequence s2) {

     * @return best available RDMA provider, or null if none available
     */
    public static RdmaProvider createProvider(String preference) {
        if ("auto".equalsIgnoreCase(preference)) {
            return selectBestProvider();
        }

        switch (preference.toLowerCase()) {
        case "disni":
            RdmaProvider disniProvider = new DisniRdmaProvider();

            while (st.hasMoreTokens()) {
                final String s = st.nextToken().trim();
                if (s.equalsIgnoreCase("LMHOSTS")) {
                    this.resolverOrder.add(ResolverType.RESOLVER_LMHOSTS);
                } else if (s.equalsIgnoreCase("WINS")) {
                    if (this.winsServer.length == 0) {

                sb.append(" [ ").append(sw.toString()).append(" ]");
            } catch (final IOException ignore) {}
            return sb.toString();
        };

        if (Constants.TRUE.equalsIgnoreCase(ComponentUtil.getFessConfig().getApiJsonResponseExceptionIncluded())) {
            return stacktraceString.get();
        }

        final String errorCode = UUID.randomUUID().toString();

     */
    public static boolean isCheckboxEnabled(final String value) {
        if (value == null) {
            return false;
        }
        return Constants.ON.equalsIgnoreCase(value) || Constants.TRUE.equalsIgnoreCase(value);
    }