Java Action.execute方法代码示例

import org.gradle.api.Action; //导入方法依赖的package包/类
public Set<Task> getTasksByName(final String name, boolean recursive) {
    if (!isTrue(name)) {
        throw new InvalidUserDataException("Name is not specified!");
    }
    final Set<Task> foundTasks = new HashSet<Task>();
    Action<Project> action = new Action<Project>() {
        public void execute(Project project) {
            // Don't force evaluation of rules here, let the task container do what it needs to
            ((ProjectInternal) project).evaluate();

            Task task = project.getTasks().findByName(name);
            if (task != null) {
                foundTasks.add(task);
            }
        }
    };
    if (recursive) {
        allprojects(action);
    } else {
        action.execute(this);
    }
    return foundTasks;
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
private <T extends Task> void maybeAddTask(Project project, IdePlugin plugin, String taskName, Class<T> taskType, Action<T> action) {
    if (project.getTasks().findByName(taskName) != null) {
        return;

    }

    T task = project.getTasks().create(taskName, taskType);
    action.execute(task);
    plugin.addWorker(task);
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
private void eachLine(Action<String> action) {
    BufferedReader reader = new BufferedReader(new StringReader(getOutput()));
    String line;
    try {
        while ((line = reader.readLine()) != null) {
            action.execute(line);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public CopySpec from(Object sourcePath, Action<? super CopySpec> configureAction) {
    if (configureAction == null) {
        from(sourcePath);
        return this;
    } else {
        CopySpecInternal child = addChild();
        child.from(sourcePath);
        CopySpecWrapper wrapper = instantiator.newInstance(CopySpecWrapper.class, child);
        configureAction.execute(wrapper);
        return wrapper;
    }
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public void removeCollection(DomainObjectCollection<? extends T> collection) {
    getStore().removeComposited(collection);
    Action<? super T> action = this.backingSet.getEventRegister().getRemoveAction();
    for (T item : collection) {
        action.execute(item);
    }
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public void submit(Action<ClojureWorkerConfiguration> action) {
  ClojureWorkerConfiguration config = new ClojureWorkerConfiguration();
  action.execute(config);

  FileCollection realClasspath = config.getClasspath().plus(resolveShim());
  workerExecutor.submit(ClojureWorker.class, worker -> {
    worker.setIsolationMode(IsolationMode.PROCESS);
    worker.params(config.getNamespace(), config.getFunction(), config.getArgs());
    config.getConfigureFork().forEach(worker::forkOptions);
    worker.forkOptions(fork -> fork.systemProperty("shim.classpath", realClasspath.getAsPath()));
    worker.classpath(resolveWorker());
  });
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
private <T extends ArtifactRepository> T addWithUniqueName(T repository, String defaultName, Action<? super T> insertion) {
    String repositoryName = repository.getName();
    if (!GUtil.isTrue(repositoryName)) {
        repository.setName(uniquifyName(defaultName));
    } else {
        repository.setName(uniquifyName(repositoryName));
    }

    assertCanAdd(repository.getName());
    insertion.execute(repository);
    return repository;
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public boolean mustRefreshArtifact(ArtifactIdentifier artifactIdentifier, File cachedArtifactFile, long ageMillis, boolean belongsToChangingModule, boolean moduleDescriptorInSync) {
    CachedArtifactResolutionControl artifactResolutionControl = new CachedArtifactResolutionControl(artifactIdentifier, cachedArtifactFile, ageMillis, belongsToChangingModule);
    if(belongsToChangingModule && !moduleDescriptorInSync){
        return true;
    }
    for (Action<? super ArtifactResolutionControl> rule : artifactCacheRules) {
        rule.execute(artifactResolutionControl);
        if (artifactResolutionControl.ruleMatch()) {
            return artifactResolutionControl.mustCheck();
        }
    }
    return false;
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public DependencySubstitutionsInternal resolveDependencySubstitutions() {
    if (dependencySubstitutions == null) {
        dependencySubstitutions = DefaultDependencySubstitutions.forIncludedBuild(this);

        for (Action<? super DependencySubstitutions> action : dependencySubstitutionActions) {
            action.execute(dependencySubstitutions);
        }
    }
    return dependencySubstitutions;
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public CopySpec into(Object destPath, Action<? super CopySpec> copySpec) {
    if (copySpec == null) {
        into(destPath);
        return this;
    } else {
        CopySpecInternal child = addChild();
        child.into(destPath);
        CopySpecWrapper wrapper = instantiator.newInstance(CopySpecWrapper.class, child);
        copySpec.execute(wrapper);
        return wrapper;
    }
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public RootManifest capsuleManifest(Action<RootManifest> manifest) {
  manifest.execute(getCapsuleManifest());
  return this.capsuleManifest;
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
@Override
public void artifact(Object notation, Action<? super ConfigurablePublishArtifact> configureAction) {
    ConfigurablePublishArtifact publishArtifact = artifactNotationParser.parseNotation(notation);
    artifacts.add(publishArtifact);
    configureAction.execute(publishArtifact);
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
@Override
public SourceSet java(Action<? super SourceDirectorySet> configureAction) {
    configureAction.execute(getJava());
    return this;
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public ExecResult javaexec(Action<? super JavaExecSpec> action) {
    JavaExecAction javaExecAction = instantiator.newInstance(DefaultJavaExecAction.class, fileResolver);
    action.execute(javaExecAction);
    return javaExecAction.execute();
}
 

import org.gradle.api.Action; //导入方法依赖的package包/类
public ClojureCompileOptions reflectionWarnings(Action<? super ReflectionWarnings> configureAction) {
  configureAction.execute(reflectionWarnings);
  return this;
}