runner.addBuildMutator { invocationSettings ->
            new ApplyDevelocityPluginMutator(invocationSettings.projectDir)
        }
    }

    static {
        // TODO - find a better way to cleanup
        System.addShutdownHook {
            RESULTS_STORE.close()
        }
    }
}

class ApplyDevelocityPluginMutator implements BuildMutator {

    private final File projectDir

        } catch (NoClassDefFoundError e) {
            return null;
        }
    }

    @Nullable
    private Class<T> inferTypeFromCallableGenericArgument() {
        // We could do a better job of figuring this out
        // Extract the type for common case that is quick to calculate
        for (Type superType : value.getClass().getGenericInterfaces()) {
            if (superType instanceof ParameterizedType) {

    // way it is due to how we render chained exceptions on build failures.
    // That is, because the information is usually dense, splitting things up this way provides better output.

    private final String descriptor;

    public InvalidModelRuleException(ModelRuleDescriptor descriptor, Throwable cause) {
        super("There is a problem with model rule " + descriptor.toString() + ".", cause);

import org.gradle.platform.base.component.internal.DefaultComponentSpec;

/**
 * Base class that may be used for custom {@link GeneralComponentSpec} implementations. However, it is generally better to use an
 * interface annotated with {@link org.gradle.model.Managed} and not use an implementation class at all.
 */
@Incubating
public class BaseComponentSpec extends DefaultComponentSpec implements GeneralComponentSpec {

 */
package org.apache.maven.artifact.resolver.filter;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * Filter to only retain objects in the given scope or better. This implementation allows the accumulation of multiple
 * scopes and their associated implied scopes, so that the user can filter apply a series of implication rules in a

     * resources
     */
    JvmEcosystemAttributesDetails asJar();

    /**
     * Configures the target JVM version. For producers of a library, it's in general
     * a better idea to rely on inference which will calculate the target JVM version
     * lazily, for example calling {@code JvmLanguageUtilities#useDefaultTargetPlatformInference(Configuration, TaskProvider)}.

            // that would happen here should cause the build to fail at a later stage
            // (when actually parsing the POM) and will lead to a better exception being
            // displayed to the user, so just bail out and return false.
        }
        return false;
    }

     * However, it is currently easy for state to leak from one project to another so this is not a strong guarantee.
     *
     * <p>It is usually a better option to use {@link #newCalculatedValue(Object)} instead of this method.</p>
     */
    <S> S fromMutableState(Function<? super T, ? extends S> factory);

    /**

    }

    public void drain(Collection<InterHubMessage> drainTo) {
        drainTo.addAll(queue);
        queue.clear();
    }

    private void flush() {
        // TODO - need to do a better job of routing messages when there are multiple endpoints. This is just going to forward all queued messages to the first
        // waiting endpoint, even if there are multiple waiting to do work

        // This may be called from an unmanaged thread, so temporarily enlist the current thread
        // as a worker if it is not already so that it can visit the results. It would be better
        // to instead to memoize the results on the first visit so that this is not required.
        workerLeaseService.runAsUnmanagedWorkerThread(() -> visitArtifacts(artifacts, visitor, resolutionHost));
    }