* <p>
     * The license may be added to the {@link #approvedLicenses} using the {@code familyName}.
     *
     * @param categoryName A 5-character string identifier for the license
     * @param familyName   An expanded string name for the license
     * @param pattern      A pattern to search for, which if found, indicates a file contains the license
     */

        if (searchParameters.length > 0) {
            final List<String> paramList = new ArrayList<>();
            for (final RequestParameter param : searchParameters) {
                for (final String value : param.getValues()) {
                    paramList.add(param.getName());
                    paramList.add(URLEncoder.encode(value, Constants.CHARSET_UTF_8));
                }
            }

	return targets, nil
}

func getEnvVarName(subSys, target, param string) string {
	if target == Default {
		return fmt.Sprintf("%s%s%s%s", EnvPrefix, strings.ToUpper(subSys), Default, strings.ToUpper(param))
	}

	return fmt.Sprintf("%s%s%s%s%s%s", EnvPrefix, strings.ToUpper(subSys), Default, strings.ToUpper(param),
		Default, target)
}

    abstract ExecutionListWrapper newExecutionList();
  }

  private ThreadPoolExecutor executorService;
  private CountDownLatch listenerLatch;
  private ExecutionListWrapper list;

  @Param Impl impl;

  @Param({"1", "5", "10"})
  int numListeners;

  private final Runnable listener =
      new Runnable() {
        @Override
        public void run() {
          listenerLatch.countDown();
        }

    public CrawlJob() {
        super();
    }

    /**
     * Sets the namespace for the crawling session.
     * The namespace is used to organize and identify crawling activities.
     *
     * @param namespace the namespace identifier for the crawling session
     * @return this CrawlJob instance for method chaining
     */
    public CrawlJob namespace(final String namespace) {
        this.namespace = namespace;

   * MultimapBuilder.hashKeys(expectedKeys).hashSetValues(expectedValuesPerKey).build()}, which
   * provides more control over the underlying data structure.
   *
   * @param expectedKeys the expected number of distinct keys
   * @param expectedValuesPerKey the expected average number of values per key
   * @throws IllegalArgumentException if {@code expectedKeys} or {@code expectedValuesPerKey} is
   *     negative
   */

        clone.setRepository(artifact.getRepository());

        return clone;
    }

    /**
     * Copy artifact to a collection.
     *
     * @param <T> the target collection type
     * @param from an artifact collection
     * @param to the target artifact collection
     * @return <code>to</code> collection
     */

        return relatedQueryMap.size();
    }

    /**
     * Extracts the virtual host key from a RelatedQuery entity.
     * If the virtual host is blank or null, returns an empty string.
     *
     * @param entity the RelatedQuery entity to extract the host key from
     * @return the virtual host key, or empty string if blank or null
     */
    protected String getHostKey(final RelatedQuery entity) {

import java.util.Map;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A base implementation of {@link NetworkConnections} for directed networks.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 * @param <E> Edge parameter type
 */
abstract class AbstractDirectedNetworkConnections<N, E> implements NetworkConnections<N, E> {
  /** Keys are edges incoming to the origin node, values are the source node. */

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code
   * Runnable}, and arrange that {@code get} will return the given result on successful completion.
   *
   * @param runnable the runnable task
   * @param result the result to return on successful completion. If you don't need a particular
   *     result, consider using constructions of the form: {@code ListenableFuture<?> f =