counter++;
        }

        @Override
        public void close() {
            if (counter > 1) {
                counter--;
            } else {
                contextLocal.remove();
                if (context != null) {
                    try {
                        context.close();
                    } catch (final NamingException e) {
                        // ignored

            Throwable e = (Throwable) objs[2];
            if (e instanceof MultipleCrawlingAccessException) {
                final Throwable[] causes = ((MultipleCrawlingAccessException) e).getCauses();
                if (causes.length > 0) {
                    e = causes[causes.length - 1];
                }
            }

            String errorName;
            final Throwable cause = e.getCause();

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalEntity;

public class StemmerOverrideFile extends DictionaryFile<StemmerOverrideItem> {
    private static final Logger logger = LogManager.getLogger(StemmerOverrideFile.class);

    private static final String STEMMER_OVERRIDE = "stemmeroverride";

    List<StemmerOverrideItem> stemmerOverrideItemList;

            try {
                final byte[] buf = new byte[1024];
                while ((is.read(buf)) != -1) {}
            } catch (final Exception ignored) {} finally {
                try {
                    is.close();
                } catch (final Exception ignored) {}
            }
        } catch (final Exception ignored) {}
    }

                    throw new DictionaryException("Failed to write: " + item, e);
                }
            }
            return null;
        }

        @Override
        public void close() {
            try {
                writer.flush();
            } catch (final IOException e) {
                // ignore
            }
            CloseableUtil.closeQuietly(writer);

            } catch (final Exception e) {
                logger.warn("Failed to flush indices.", e);
            }
        }
        try {
            client.close();
        } catch (final OpenSearchException e) {
            logger.warn("Failed to close Client: {}", client, e);
        }
    }

    public long updateByQuery(final String index, final Function<SearchRequestBuilder, SearchRequestBuilder> option,

                    throw new DictionaryException("Failed to write: " + item, e);
                }
            }
            return null;
        }

        @Override
        public void close() {
            try {
                writer.flush();
            } catch (final IOException e) {
                // ignore
            }
            CloseableUtil.closeQuietly(writer);

import org.lastaflute.web.util.LaRequestUtil;
import org.lastaflute.web.util.LaResponseUtil;

public class RankFusionProcessor implements AutoCloseable {

    private static final Logger logger = LogManager.getLogger(RankFusionProcessor.class);

    protected RankFusionSearcher[] searchers = new RankFusionSearcher[1];

    protected ExecutorService executorService;

    /** The key of the message: Search Options */
    public static final String LABELS_search_options = "{labels.search_options}";

    /** The key of the message: Close */
    public static final String LABELS_search_options_close = "{labels.search_options_close}";

    /** The key of the message: Clear */
    public static final String LABELS_search_options_clear = "{labels.search_options_clear}";

import org.codelibs.fess.exception.JobProcessingException;
import org.codelibs.fess.util.InputStreamThread;
import org.codelibs.fess.util.JobProcess;

public class ProcessHelper {
    private static final Logger logger = LogManager.getLogger(ProcessHelper.class);

    protected final ConcurrentHashMap<String, JobProcess> runningProcessMap = new ConcurrentHashMap<>();

    protected int processDestroyTimeout = 10;

    @PreDestroy