* and `square.ca`.
   */
  fun callAcquirePooledConnection(
    doExtensiveHealthChecks: Boolean,
    address: Address,
    connectionUser: ConnectionUser,
    routes: List<Route>?,
    requireMultiplexed: Boolean,
  ): RealConnection? {
    for (connection in connections) {
      // In the first synchronized block, acquire the connection if it can satisfy this call.
      val acquired =

    }

    protected void setAttributeValue(final List<SearchResult> result, final String name, final Consumer<Object> consumer) {
        final List<Object> attrList = getAttributeValueList(result, name);
        if (!attrList.isEmpty()) {
            consumer.accept(attrList.get(0));
        }
    }

    protected List<Object> getAttributeValueList(final List<SearchResult> result, final String name) {
        try {

    private final boolean isGroovy;
    private final List<String> imports = new ArrayList<String>();
    private final List<String> interfaceNames = new ArrayList<String>();
    private final Map<String, PropertyMetaData> declaredProperties = new HashMap<String, PropertyMetaData>();
    private final Set<MethodMetaData> declaredMethods = new HashSet<MethodMetaData>();
    private final List<String> innerClassNames = new ArrayList<String>();

  E[] createArray(int length);

  /**
   * Returns the iteration ordering of elements, given the order in which they were added to the
   * container. This method may return the original list unchanged, the original list modified in
   * place, or a different list.
   *
   * <p>If the order is non-deterministic, as with {@link java.util.HashSet}, this method can return
   * its input unmodified. Provided that the test suite is built without {@link

        if (g.getVertices().size() == 1) {
            return g;
        }

        List<MetadataGraphVertex> visited = new ArrayList<>(g.getVertices().size());
        visit(g.getEntry(), visited, g);

        List<MetadataGraphVertex> dropList = new ArrayList<>(g.getVertices().size());

        // collect drop list
        for (MetadataGraphVertex v : g.getVertices()) {
            if (!visited.contains(v)) {

    private final List<BuilderProblem> problems;

    /**
     * @param message the message to give
     * @param e the {@link Exception}
     */
    public SettingsBuilderException(String message, Exception e) {
        super(message, e);
        this.problems = List.of();
    }

    public SettingsBuilderException(String message, List<BuilderProblem> problems) {

    private final List<BuilderProblem> problems;

    /**
     * @param message the message to give
     * @param e the {@link Exception}
     */
    public ToolchainsBuilderException(String message, Exception e) {
        super(message, e);
        this.problems = List.of();
    }

    public ToolchainsBuilderException(String message, List<BuilderProblem> problems) {

import java.lang.annotation.RetentionPolicy;
import java.util.List;
import java.util.Set;

/**
 * Optional features of classes derived from {@code List}.
 *
 * @author George van den Driessche
 */
@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum ListFeature implements Feature<List> {
  SUPPORTS_SET,
  SUPPORTS_ADD_WITH_INDEX(CollectionFeature.SUPPORTS_ADD),

                                    </la:link>
                                    <la:link href="list/1?dictId=${f:u(dictId)}"
                                             styleClass="btn btn-primary btn-xs">
                                        <em class="fa fa-th-list">
                                        <la:message key="labels.dict_kuromoji_list_link"/>
                                    </la:link>

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.profiles.manager;

import javax.inject.Inject;

import java.util.List;
import java.util.Properties;

import org.apache.maven.model.Activation;
import org.apache.maven.model.ActivationProperty;
import org.apache.maven.model.Profile;
import org.apache.maven.profiles.DefaultProfileManager;