protected List<File> getFiles() { if (files == null) { files = filesFactory.create(); } return files; }
public <T> T synchronize(Factory<T> factory) { lock.lock(); try { return factory.create(); } finally { lock.unlock(); } }
@Nullable public static <T> T whileDisabled(Factory<T> factory) { ENABLED.set(false); try { return factory.create(); } finally { ENABLED.set(true); } }
public T create() { SoftReference<T> reference = cachedReference.get(); T value = reference != null ? reference.get() : null; if (value == null) { value = factory.create(); cachedReference.set(new SoftReference<T>(value)); } return value; } }
public T create() { SoftReference<T> reference = cachedReference.get(); T value = reference != null ? reference.get() : null; if (value == null) { value = factory.create(); cachedReference.set(new SoftReference<T>(value)); } return value; } }
@Override public <T> T useCache(Factory<? extends T> action) { assertNotClosed(); // The contract of useCache() means we have to provide some basic synchronization. synchronized (this) { return action.create(); } }
public DefaultCopySpec(FileResolver resolver, Instantiator instantiator) { this.fileResolver = resolver; this.instantiator = instantiator; sourcePaths = new LinkedHashSet<Object>(); childSpecs = new ArrayList<CopySpecInternal>(); childSpecsInAdditionOrder = new ArrayList<CopySpecInternal>(); patternSet = resolver.getPatternSetFactory().create(); duplicatesStrategy = null; }
@Override public void onOutput(OutputEvent event) { if (delegate == null) { delegate = factory.create(); factory = null; } delegate.onOutput(event); } }
@Override public String create() { if (cachedValue == null) { cachedValue = STRING_INTERNER.intern(descriptor.create()); } return cachedValue; } };
@Override public T transform(MutableModelNode modelNode) { T t = factory.create(); initializer.execute(modelNode); return t; } });
public File createTemporaryFile(String prefix, @Nullable String suffix, String... path) { File dir = new File(baseDirFactory.create(), CollectionUtils.join("/", path)); GFileUtils.mkdirs(dir); try { return File.createTempFile(prefix, suffix, dir); } catch (IOException e) { throw new UncheckedIOException(e); } }
@Override public LoggingManagerInternal getLogging() { if (loggingManager == null) { loggingManager = new LoggingManagerInternalCompatibilityBridge(services.getFactory(org.gradle.internal.logging.LoggingManagerInternal.class).create()); } return loggingManager; }
private void walkDir(File file, RelativePath path, FileVisitor visitor, Spec<FileTreeElement> spec, AtomicBoolean stopFlag) { DirectoryWalker directoryWalker; if (visitor instanceof ReproducibleFileVisitor && ((ReproducibleFileVisitor) visitor).isReproducibleFileOrder()) { directoryWalker = REPRODUCIBLE_DIRECTORY_WALKER; } else { directoryWalker = directoryWalkerFactory.create(); } directoryWalker.walkDir(file, path, visitor, spec, stopFlag, postfix); }
public static DefaultGradleConnector createConnector() { checkJavaVersion(); return singletonRegistry.getFactory(DefaultGradleConnector.class).create(); } public static CancellationTokenSource createCancellationTokenSource() {
public DefaultConfigurableFileTree(Map<String, ?> args, FileResolver resolver, TaskResolver taskResolver, FileCopier fileCopier, DirectoryFileTreeFactory directoryFileTreeFactory) { this.resolver = resolver; this.fileCopier = fileCopier; this.directoryFileTreeFactory = directoryFileTreeFactory; patternSet = resolver.getPatternSetFactory().create(); buildDependency = new DefaultTaskDependency(taskResolver); ConfigureUtil.configureByMap(args, this); }
private void convertFileToFileTree(File file, Collection<? super FileTreeInternal> result) { if (file.isDirectory()) { result.add(new FileTreeAdapter(new DirectoryFileTree(file, patternSetFactory.create(), FileSystems.getDefault()))); } else if (file.isFile()) { result.add(new FileTreeAdapter(new SingletonFileTree(file))); } } }
@Override public Directory getOrNull() { if (!isPresent()) { return null; } // TODO - factory should cache, and use a FixedDirectory instance when the value is fixed File dir = valueFactory.create(); return new FixedDirectory(dir, resolver.newResolver(dir)); } }
public DefaultSourceDirectorySet(String name, String displayName, FileResolver fileResolver, DirectoryFileTreeFactory directoryFileTreeFactory) { this.name = name; this.displayName = displayName; this.fileResolver = fileResolver; this.directoryFileTreeFactory = directoryFileTreeFactory; this.patterns = fileResolver.getPatternSetFactory().create(); this.filter = fileResolver.getPatternSetFactory().create(); this.dirs = new FileCollectionAdapter(new SourceDirectories()); ProviderFactory providerFactory = new DefaultProviderFactory(); this.outputDir = providerFactory.property(File.class); }
public void execute() { Timer clock = Time.startTimer(); ensurePopulated(); graphListeners.getSource().graphPopulated(this); try { taskPlanExecutor.process(taskExecutionPlan, new EventFiringTaskWorker(taskExecuter.create(), buildOperationExecutor.getCurrentOperation())); LOGGER.debug("Timing: Executing the DAG took " + clock.getElapsed()); } finally { taskExecutionPlan.clear(); } }
public PatternSet getPatternSet() { PatternSet patterns = fileResolver.getPatternSetFactory().create(); patterns.setCaseSensitive(isCaseSensitive()); patterns.include(this.getAllIncludes()); patterns.includeSpecs(getAllIncludeSpecs()); patterns.exclude(this.getAllExcludes()); patterns.excludeSpecs(getAllExcludeSpecs()); return patterns; }