/**
     * Adds a rule to the end of the rule list.
     * @param rule the rule to add
     */
    @Override
    public void addRule(final Rule rule) {
        ruleList.add(rule);
    }

    /**
     * Adds a rule at the specified position in the rule list.
     * @param index the position to insert the rule
     * @param rule the rule to add
     */
    @Override
    public void addRule(final int index, final Rule rule) {

                    activeProfiles.add(profile);

                    if (Profile.SOURCE_POM.equals(profile.getSource())) {
                        activatedPomProfileNotByDefault = true;
                    }
                } else if (isActiveByDefault(profile)) {
                    if (Profile.SOURCE_POM.equals(profile.getSource())) {
                        activePomProfilesByDefault.add(profile);
                    } else {

	}

	kvsMap := c[subSys]
	seen := set.NewStringSet()

	// Add all targets that are configured in the config store.
	for k := range kvsMap {
		seen.Add(k)
	}

	// env:prefix
	filterMap := map[string]string{}
	// Add targets that are configured via environment variables.
	for _, param := range defKVS {

                    filters.add(new HighestVersionFilter());
                } else if (expression.startsWith("h(") && expression.endsWith(")")) {
                    int num = Integer.parseInt(expression.substring(2, expression.length() - 1));
                    filters.add(new HighestVersionFilter(num));
                } else if ("l".equals(expression)) {
                    filters.add(new LowestVersionFilter());

     *
     * @param url URL
     * @return true if url is matched
     */
    boolean match(String url);

    /**
     * Add an url pattern as a target.
     *
     * @param urlPattern Regular expression that is crawled
     */
    void addInclude(String urlPattern);

    /**
     * Add an url pattern as a non-target.
     *
     * @param urlPattern Regular expression that is not crawled
     */

                if (currentArg != null) {
                    currentArg.append(' ').append(arg);
                } else {
                    cleaned.add(arg);
                }
            }
        }

        if (currentArg != null) {
            cleaned.add(currentArg.toString());
        }

        int cleanedSz = cleaned.size();

        String[] cleanArgs;

        if (cleanedSz == 0) {

    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));
    assertEquals(getOrderedElements(), entries);
  }

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testForEachUnknownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));
    assertEqualIgnoringOrder(getSampleEntries(), entries);
  }

            names.add(internalName)
            prefixes.add("$internalName/")
        }
    }

    fun matches(packageName: String): Boolean {
        if (names.contains(packageName)) {
            return true
        }
        for (prefix in prefixes) {
            if (packageName.startsWith(prefix)) {
                names.add(packageName)
                return true
            }

            for (ASN1ObjectIdentifier m : mechs) {
                v.add(m);
            }
            fields.add(new DERTaggedObject(true, 0, new DERSequence(v)));
        }
        if (flags != null && flags != 0) {
            fields.add(new DERTaggedObject(true, 1, new DERBitString(flags)));
        }
        if (mechToken != null) {
            fields.add(new DERTaggedObject(true, 2, new DEROctetString(mechToken)));
        }

): List<T> {
  val ia = a.iterator()
  val ib = b.iterator()

  return buildList {
    while (ia.hasNext() || ib.hasNext()) {
      if (ia.hasNext()) {
        add(ia.next())
      }
      if (ib.hasNext()) {
        add(ib.next())
      }
    }
  }