* limitations under the License.
 */
package org.gradle.internal;

import java.lang.ref.SoftReference;
import java.util.concurrent.atomic.AtomicReference;

public final class Factories {

    private Factories() {
        /* no-op */
    }

    public static <T> Factory<T> toFactory(final Runnable runnable) {
        return new Factory<T>() {
            @Override
            public T create() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * This package contains different accessory factories for excludes.
 */

    if (cls.isEnum()) {
      return;
    }
    List<? extends Invokable<?, ?>> factories = Lists.reverse(getFactories(TypeToken.of(cls)));
    if (factories.isEmpty()) {
      return;
    }
    int numberOfParameters = factories.get(0).getParameters().size();
    List<ParameterNotInstantiableException> paramErrors = Lists.newArrayList();

    @Inject
    public DefaultToolchainManagerPrivate(Map<String, ToolchainFactory> factories) {
        super(factories);
    }

    /**
     * Ctor needed for UT.
     */
    DefaultToolchainManagerPrivate(Map<String, ToolchainFactory> factories, Logger logger) {
        super(factories, logger);
    }

    @Override

    final Map<String, ToolchainFactory> factories;

    @Inject
    public DefaultToolchainManager(Map<String, ToolchainFactory> factories) {
        this.factories = factories;
        this.logger = LoggerFactory.getLogger(DefaultToolchainManager.class);
    }

    /**
     * Ctor needed for UT.
     */
    DefaultToolchainManager(Map<String, ToolchainFactory> factories, Logger logger) {
        this.factories = factories;

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.factories.CachingExcludeFactory;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.factories.ExcludeFactory;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.factories.LoggingExcludeFactory;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.factories.NormalizingExcludeFactory;

            throw new IllegalArgumentException(message);
        }
        if (factories.containsKey(type)) {
            throw new GradleException(String.format("Cannot register a factory for type %s because a factory for this type is already registered.", type.getSimpleName()));
        }
        factories.put(type, factory);
    }

    @Override
    public Set<? extends Class<? extends T>> getCreatableTypes() {

            for (JvmBytecodeCallInterceptor.Factory factory : ServiceLoader.load(JvmBytecodeCallInterceptor.Factory.class, classLoader)) {
                if (factory.getClass().getPackage().getName().startsWith(forPackage)) {
                    factories.add(factory);
                }
            }
            return factories.build();
        }

        @Override

    final List<ServiceMethod> decorators;
    final List<ServiceMethod> factories;
    final List<ServiceMethod> configurers;

    private RelevantMethods(List<ServiceMethod> decorators, List<ServiceMethod> factories, List<ServiceMethod> configurers) {
        this.decorators = decorators;
        this.factories = factories;
        this.configurers = configurers;
    }

    @Test
    void testMetadataGeneratorFactory() throws ComponentLookupException {
        List<MetadataGeneratorFactory> factories = plexusContainer.lookupList(MetadataGeneratorFactory.class);
        assertNotNull(factories);
        factories.forEach(f -> System.out.println(f.getClass().getName()));
        assertEquals(3, factories.size());
    }

    @Test
    void testProjectDependencies() {