org.gradle.internal.reflect.Instantiator Java Examples

public static PluginResolver jcenterGradleOfficial(Instantiator instantiator, DependencyResolutionServices dependencyResolutionServices, final CacheRepository cacheRepository) {
    Supplier<PersistentIndexedCache<PluginRequest, String>> cacheSupplier = Suppliers.wrap(
            Suppliers.ofQuietlyClosed(new Factory<PersistentCache>() {
                public PersistentCache create() {
                    return cacheRepository.cache("plugins").withLockOptions(LockOptionsBuilder.mode(FileLockManager.LockMode.Exclusive)).open();
                }
            }),
            new Transformer<PersistentIndexedCache<PluginRequest, String>, PersistentCache>() {
                public PersistentIndexedCache<PluginRequest, String> transform(PersistentCache original) {
                    PersistentIndexedCacheParameters<PluginRequest, String> cacheParams = new PersistentIndexedCacheParameters<PluginRequest, String>("jcenter", new PluginRequestSerializer(), BaseSerializerFactory.STRING_SERIALIZER);
                    return original.createCache(cacheParams);
                }
            });

    final JCenterPluginMapper mapper = new JCenterPluginMapper(cacheSupplier);

    return new ModuleMappingPluginResolver("jcenter plugin resolver", dependencyResolutionServices, instantiator, mapper, new JCenterRepositoryConfigurer()) {
        @Override
        public String getDescriptionForNotFoundMessage() {
            return String.format("Gradle Bintray Plugin Repository (listing: %s)", mapper.getBintrayRepoUrl());
        }
    };
}
 

@Mutate
public static void addGccToolChain(NativeToolChainRegistryInternal toolChainRegistry, ServiceRegistry serviceRegistry) {
    final FileResolver fileResolver = serviceRegistry.get(FileResolver.class);
    final ExecActionFactory execActionFactory = serviceRegistry.get(ExecActionFactory.class);
    final Instantiator instantiator = serviceRegistry.get(Instantiator.class);
    final OperatingSystem operatingSystem = serviceRegistry.get(OperatingSystem.class);
    final VisualStudioLocator visualStudioLocator = serviceRegistry.get(VisualStudioLocator.class);
    final WindowsSdkLocator windowsSdkLocator = serviceRegistry.get(WindowsSdkLocator.class);

    toolChainRegistry.registerFactory(VisualCpp.class, new NamedDomainObjectFactory<VisualCpp>() {
        public VisualCpp create(String name) {
            return instantiator.newInstance(VisualCppToolChain.class, name, operatingSystem, fileResolver, execActionFactory, visualStudioLocator, windowsSdkLocator, instantiator);
        }
    });
    toolChainRegistry.registerDefaultToolChain(VisualCppToolChain.DEFAULT_NAME, VisualCpp.class);
}
 

TaskArtifactStateRepository createTaskArtifactStateRepository(Instantiator instantiator, TaskArtifactStateCacheAccess cacheAccess, StartParameter startParameter, FileSnapshotter fileSnapshotter) {
    FileCollectionSnapshotter fileCollectionSnapshotter = new DefaultFileCollectionSnapshotter(fileSnapshotter, cacheAccess);

    FileCollectionSnapshotter outputFilesSnapshotter = new OutputFilesCollectionSnapshotter(fileCollectionSnapshotter, new RandomLongIdGenerator(), cacheAccess);

    SerializerRegistry<FileCollectionSnapshot> serializerRegistry = new DefaultSerializerRegistry<FileCollectionSnapshot>();
    fileCollectionSnapshotter.registerSerializers(serializerRegistry);
    outputFilesSnapshotter.registerSerializers(serializerRegistry);

    TaskHistoryRepository taskHistoryRepository = new CacheBackedTaskHistoryRepository(cacheAccess,
            new CacheBackedFileSnapshotRepository(cacheAccess,
                    serializerRegistry.build(),
                    new RandomLongIdGenerator()));

    return new ShortCircuitTaskArtifactStateRepository(
                    startParameter,
                    instantiator,
                    new DefaultTaskArtifactStateRepository(
                            taskHistoryRepository,
                            instantiator,
                            outputFilesSnapshotter,
                            fileCollectionSnapshotter
                    )
    );
}
 

private OsgiManifest createDefaultOsgiManifest(final ProjectInternal project) {
    OsgiManifest osgiManifest = project.getServices().get(Instantiator.class).newInstance(DefaultOsgiManifest.class, project.getFileResolver());
    ConventionMapping mapping = ((IConventionAware) osgiManifest).getConventionMapping();
    final OsgiHelper osgiHelper = new OsgiHelper();

    mapping.map("version", new Callable<Object>() {
        public Object call() throws Exception {
            return osgiHelper.getVersion(project.getVersion().toString());
        }
    });
    mapping.map("name", new Callable<Object>() {
        public Object call() throws Exception {
            return project.getConvention().getPlugin(BasePluginConvention.class).getArchivesBaseName();
        }
    });
    mapping.map("symbolicName", new Callable<Object>() {
        public Object call() throws Exception {
            return osgiHelper.getBundleSymbolicName(project);
        }
    });

    return osgiManifest;
}
 

public TestNGTestFramework(Test testTask, DefaultTestFilter filter, Instantiator instantiator) {
    this.testTask = testTask;
    this.filter = filter;
    options = instantiator.newInstance(TestNGOptions.class, testTask.getProject().getProjectDir());
    options.setAnnotationsOnSourceCompatibility(JavaVersion.toVersion(testTask.getProject().property("sourceCompatibility")));
    conventionMapOutputDirectory(options, testTask.getReports().getHtml());
    detector = new TestNGDetector(new ClassFileExtractionManager(testTask.getTemporaryDirFactory()));
}
 

@Override
protected CopySpecInternal createRootSpec() {
    Instantiator instantiator = getInstantiator();
    FileResolver fileResolver = getFileResolver();

    return instantiator.newInstance(DestinationRootCopySpec.class, fileResolver, super.createRootSpec());
}
 

@Mutate
public void registerNativePlatformFactory(PlatformContainer platforms, ServiceRegistry serviceRegistry) {
    final Instantiator instantiator = serviceRegistry.get(Instantiator.class);
    NamedDomainObjectFactory<NativePlatform> nativePlatformFactory = new NamedDomainObjectFactory<NativePlatform>() {
        public NativePlatform create(String name) {
            return instantiator.newInstance(DefaultNativePlatform.class, name);
        }
    };

    //TODO freekh: remove cast/this comment when registerDefault exists on interface
    ((DefaultPlatformContainer) platforms).registerDefaultFactory(nativePlatformFactory);
    platforms.registerFactory(NativePlatform.class, nativePlatformFactory);
}
 

protected PluginResolverFactory createPluginResolverFactory() {
    return new PluginResolverFactory(
            get(PluginRegistry.class),
            get(Instantiator.class),
            get(DependencyManagementServices.class),
            get(FileResolver.class),
            new DependencyMetaDataProviderImpl(),
            get(DocumentationRegistry.class),
            get(CacheRepository.class)
    );
}
 

ConfigurationContainerInternal createConfigurationContainer(Instantiator instantiator, ConfigurationResolver configurationResolver, DomainObjectContext domainObjectContext,
                                                            ListenerManager listenerManager, DependencyMetaDataProvider metaDataProvider) {
    return instantiator.newInstance(DefaultConfigurationContainer.class,
            configurationResolver,
            instantiator,
            domainObjectContext,
            listenerManager,
            metaDataProvider);
}
 

public PrebuiltLibraryInitializer(Instantiator instantiator,
                                  Collection<? extends Platform> allPlatforms, Collection<? extends BuildType> allBuildTypes, Collection<? extends Flavor> allFlavors) {
    this.instantiator = instantiator;
    this.allPlatforms.addAll(allPlatforms);
    this.allBuildTypes.addAll(allBuildTypes);
    this.allFlavors.addAll(allFlavors);
}
 

public DefaultTaskArtifactStateRepository(TaskHistoryRepository taskHistoryRepository, Instantiator instantiator,
                                          FileCollectionSnapshotter outputFilesSnapshotter, FileCollectionSnapshotter inputFilesSnapshotter) {
    this.taskHistoryRepository = taskHistoryRepository;
    this.instantiator = instantiator;
    this.outputFilesSnapshotter = outputFilesSnapshotter;
    this.inputFilesSnapshotter = inputFilesSnapshotter;
}
 

BaseRepositoryFactory createBaseRepositoryFactory(LocalMavenRepositoryLocator localMavenRepositoryLocator, Instantiator instantiator, FileResolver fileResolver,
                                                  RepositoryTransportFactory repositoryTransportFactory, LocallyAvailableResourceFinder<ModuleComponentArtifactMetaData> locallyAvailableResourceFinder,
                                                  ResolverStrategy resolverStrategy, ArtifactIdentifierFileStore artifactIdentifierFileStore) {
    return new DefaultBaseRepositoryFactory(
            localMavenRepositoryLocator,
            fileResolver,
            instantiator,
            repositoryTransportFactory,
            locallyAvailableResourceFinder,
            resolverStrategy,
            artifactIdentifierFileStore
    );
}
 

private DefaultRepositories(final Instantiator instantiator, final FileResolver fileResolver, final Action<PrebuiltLibrary> binaryFactory) {
    super(ArtifactRepository.class, instantiator, new ArtifactRepositoryNamer());
    registerFactory(PrebuiltLibraries.class, new NamedDomainObjectFactory<PrebuiltLibraries>() {
        public PrebuiltLibraries create(String name) {
            return instantiator.newInstance(DefaultPrebuiltLibraries.class, name, instantiator, fileResolver, binaryFactory);
        }
    });
}
 

protected SettingsProcessor createSettingsProcessor() {
    return new PropertiesLoadingSettingsProcessor(
            new ScriptEvaluatingSettingsProcessor(
                    get(ScriptPluginFactory.class),
                    get(ScriptHandlerFactory.class),
                    new SettingsFactory(
                            get(Instantiator.class),
                            get(ServiceRegistryFactory.class)
                    ),
                    get(IGradlePropertiesLoader.class)),
            get(IGradlePropertiesLoader.class));
}
 

public DependencyClassPathNotationParser(Instantiator instantiator, ClassPathRegistry classPathRegistry,
                                         FileResolver fileResolver) {
    super(DependencyFactory.ClassPathNotation.class);

    this.instantiator = instantiator;
    this.classPathRegistry = classPathRegistry;
    this.fileResolver = fileResolver;
}
 

public DefaultIvyPublication(
        String name, Instantiator instantiator, IvyPublicationIdentity publicationIdentity, NotationParser<Object, IvyArtifact> ivyArtifactNotationParser,
        ProjectDependencyPublicationResolver projectDependencyResolver
) {
    this.name = name;
    this.publicationIdentity = publicationIdentity;
    this.projectDependencyResolver = projectDependencyResolver;
    configurations = instantiator.newInstance(DefaultIvyConfigurationContainer.class, instantiator);
    ivyArtifacts = instantiator.newInstance(DefaultIvyArtifactSet.class, name, ivyArtifactNotationParser);
    ivyDependencies = instantiator.newInstance(DefaultIvyDependencySet.class);
    descriptor = instantiator.newInstance(DefaultIvyModuleDescriptor.class, this);
}
 

AbstractGccCompatibleToolChain(String name, OperatingSystem operatingSystem, FileResolver fileResolver, ExecActionFactory execActionFactory, ToolSearchPath tools, CompilerMetaDataProvider metaDataProvider, Instantiator instantiator) {
    super(name, operatingSystem, fileResolver);
    this.execActionFactory = execActionFactory;
    this.toolSearchPath = tools;
    this.metaDataProvider = metaDataProvider;
    this.instantiator = instantiator;

    target(new ToolChainDefaultArchitecture());
    target(new Intel32Architecture());
    target(new Intel64Architecture());
    configInsertLocation = 0;
}
 

ConfigurationContainerInternal createConfigurationContainer(Instantiator instantiator, ConfigurationResolver configurationResolver, DomainObjectContext domainObjectContext,
                                                            ListenerManager listenerManager, DependencyMetaDataProvider metaDataProvider) {
    return instantiator.newInstance(DefaultConfigurationContainer.class,
            configurationResolver,
            instantiator,
            domainObjectContext,
            listenerManager,
            metaDataProvider);
}
 

public ModuleMappingPluginResolver(String name, DependencyResolutionServices dependencyResolutionServices, Instantiator instantiator, Mapper mapper, Action<? super RepositoryHandler> repositoriesConfigurer) {
    this.name = name;
    this.dependencyResolutionServices = dependencyResolutionServices;
    this.instantiator = instantiator;
    this.mapper = mapper;
    this.repositoriesConfigurer = repositoriesConfigurer;
}
 

public DefaultConfigurationContainer(ConfigurationResolver resolver,
                                     Instantiator instantiator, DomainObjectContext context, ListenerManager listenerManager,
                                     DependencyMetaDataProvider dependencyMetaDataProvider) {
    super(Configuration.class, instantiator, new Configuration.Namer());
    this.resolver = resolver;
    this.instantiator = instantiator;
    this.context = context;
    this.listenerManager = listenerManager;
    this.dependencyMetaDataProvider = dependencyMetaDataProvider;
}
 

public DefaultCopySpec(FileResolver resolver, Instantiator instantiator) {
    this.fileResolver = resolver;
    this.instantiator = instantiator;
    sourcePaths = new LinkedHashSet<Object>();
    childSpecs = new ArrayList<CopySpecInternal>();
    patternSet = new PatternSet();
    duplicatesStrategy = null;
}
 

public PluginResolverFactory(PluginRegistry pluginRegistry, Instantiator instantiator, DependencyManagementServices dependencyManagementServices, FileResolver fileResolver, DependencyMetaDataProvider dependencyMetaDataProvider, DocumentationRegistry documentationRegistry, CacheRepository cacheRepository) {
    this.pluginRegistry = pluginRegistry;
    this.instantiator = instantiator;
    this.dependencyManagementServices = dependencyManagementServices;
    this.fileResolver = fileResolver;
    this.dependencyMetaDataProvider = dependencyMetaDataProvider;
    this.documentationRegistry = documentationRegistry;
    this.cacheRepository = cacheRepository;
}
 

public DefaultTestLoggingContainer(Instantiator instantiator) {
    for (LogLevel level: LogLevel.values()) {
        perLevelTestLogging.put(level, instantiator.newInstance(DefaultTestLogging.class));
    }

    setEvents(EnumSet.of(TestLogEvent.FAILED));
    setExceptionFormat(TestExceptionFormat.SHORT);

    getInfo().setEvents(EnumSet.of(TestLogEvent.FAILED, TestLogEvent.SKIPPED, TestLogEvent.STANDARD_OUT, TestLogEvent.STANDARD_ERROR));
    getInfo().setStackTraceFilters(EnumSet.of(TestStackTraceFilter.TRUNCATE));

    getDebug().setEvents(EnumSet.allOf(TestLogEvent.class));
    getDebug().setMinGranularity(0);
    getDebug().setStackTraceFilters(EnumSet.noneOf(TestStackTraceFilter.class));
}
 

public DefaultFileOperations(FileResolver fileResolver, TaskResolver taskResolver, TemporaryFileProvider temporaryFileProvider, Instantiator instantiator, FileLookup fileLookup) {
    this.fileResolver = fileResolver;
    this.taskResolver = taskResolver;
    this.temporaryFileProvider = temporaryFileProvider;
    this.instantiator = instantiator;
    this.deleteAction = new DeleteActionImpl(fileResolver);
    this.resourceHandler = new DefaultResourceHandler(this, temporaryFileProvider);
    fileCopier = new FileCopier(this.instantiator, this.fileResolver, fileLookup);
    fileSystem = fileLookup.getFileSystem();
}
 

public DefaultNamedDomainObjectSet(Class<? extends T> type, Instantiator instantiator) {
    this(type, instantiator, Named.Namer.forType(type));
}
 

public ClientModuleNotationParserFactory(Instantiator instantiator) {
    this.instantiator = instantiator;
}
 

DefaultComponentModuleMetadataHandler createComponentModuleMetadataHandler(Instantiator instantiator) {
    return instantiator.newInstance(DefaultComponentModuleMetadataHandler.class);
}
 

RepositoryHandler createRepositoryHandler(Instantiator instantiator, BaseRepositoryFactory baseRepositoryFactory) {
    return instantiator.newInstance(DefaultRepositoryHandler.class, baseRepositoryFactory, instantiator);
}
 

@Inject
public EarPlugin(Instantiator instantiator, FileResolver fileResolver) {
    this.instantiator = instantiator;
    this.fileResolver = fileResolver;
}
 

public VisualStudioSolutionRegistry(FileResolver fileResolver, VisualStudioProjectResolver projectResolver, Instantiator instantiator) {
    super(DefaultVisualStudioSolution.class, instantiator);
    this.fileResolver = fileResolver;
    this.projectResolver = projectResolver;
}