c.close();
                } catch (Exception e) {
                    if (causes == null) {
                        causes = new ArrayList<>();
                    }
                    causes.add(e);
                }
            }
        }
        if (causes != null) {
            InvokerException exception = new InvokerException("Unable to close context");

        }

        if (readings2.length > index && readings2[index] != null) {
            for (final String reading : readings2[index]) {
                if (!merged.contains(reading)) {
                    merged.add(reading);
                }
            }
        }

        return merged.toArray(new String[merged.size()]);
    }

    /**
     * Merges two string arrays, maintaining uniqueness and order.

    private
    fun visitTree(
        classDetails: ClassDetails,
        classesDir: File,
        jarOutputStream: JarOutputStream,
        visited: MutableSet<ClassDetails>
    ) {

        if (!visited.add(classDetails)) {
            return
        }
        if (classDetails.visited) {
            val fileName = classDetails.outputClassFilename
            val classFile = classesDir.resolve(fileName)

      ule.printStackTrace()
    }
  }

  private fun enableLogging(
    logger: String,
    tag: String,
  ) {
    val logger = Logger.getLogger(logger)
    if (configuredLoggers.add(logger)) {
      logger.useParentHandlers = false
      // log based on levels at startup to avoid logging each frame
      logger.level =
        when {
          Log.isLoggable(tag, Log.DEBUG) -> Level.FINE

  }

  ListenableFutureTask(Runnable runnable, @ParametricNullness V result) {
    super(runnable, result);
  }

  @Override
  public void addListener(Runnable listener, Executor exec) {
    executionList.add(listener, exec);
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws TimeoutException, InterruptedException, ExecutionException {

    public MavenOptions interpolate(UnaryOperator<String> callback) {
        ArrayList<MavenOptions> interpolatedOptions = new ArrayList<>(options.size());
        for (MavenOptions o : options) {
            interpolatedOptions.add((MavenOptions) o.interpolate(callback));
        }
        return layerMavenOptions(interpolatedOptions);
    }

     */
    public synchronized void register(final CrawlerClientFactory crawlerClientFactory) {
        clientMap.entrySet().stream().forEach(e -> load(crawlerClientFactory, e.getKey(), e.getValue()));
        clientFactoryList.add(crawlerClientFactory);
        if (clientFactoryList.size() > maxClientFactorySize) {
            clientFactoryList.remove(0);
        }
    }

    /**
     * Registers a client component with a regular expression.

            final List<String> tagList = new ArrayList<>();
            final String key = ComponentUtil.getVirtualHostHelper().getVirtualHostKey();
            if (StringUtil.isNotBlank(key)) {
                tagList.add(key);
            }
            runtime.registerData("popularWords", popularWordHelper.getWordList(SearchRequestType.SEARCH, null,
                    tagList.toArray(new String[tagList.size()]), null, null, null));
        }

                            successCount.incrementAndGet();
                        } catch (Exception e) {
                            synchronized (exceptions) {
                                exceptions.add(e);
                            }
                        }
                    }
                    long threadEnd = System.nanoTime();
                    totalTime.addAndGet(threadEnd - threadStart);

            bulkRequestBuilder = client.prepareBulk();
        }
        final String index = fessConfig.getIndexDocumentUpdateIndex();
        for (final String id : ids) {
            bulkRequestBuilder.add(client.prepareUpdate()
                    .setIndex(index)
                    .setId(id)
                    .setScript(new Script(ScriptType.INLINE, scriptLang, scriptCode, params)));
        }