import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public void add(final Class<? extends FilterReader> filterType, final Map<String, ?> properties) {
    transformers.add(new Transformer<Reader, Reader>() {
        public Reader transform(Reader original) {
            try {
                Constructor<? extends FilterReader> constructor = filterType.getConstructor(Reader.class);
                FilterReader result = constructor.newInstance(original);

                if (properties != null) {
                    ConfigureUtil.configureByMap(properties, result);
                }
                return result;
            } catch (Throwable th) {
                throw new InvalidUserDataException("Error - Invalid filter specification for " + filterType.getName(), th);
            }
        }
    });
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
@Override
public DefaultManifest from(Object mergePaths, Closure<?> closure) {
    DefaultManifestMergeSpec mergeSpec = new DefaultManifestMergeSpec();
    mergeSpec.from(mergePaths);
    manifestMergeSpecs.add(mergeSpec);
    ConfigureUtil.configure(closure, mergeSpec);
    return this;
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
private RemoteRepository createRepository(Map properties, Closure closure) {
    RemoteRepository repository = new MavenRemoteRepository();
    ConfigureUtil.configureByMap(properties, repository);
    // Should be using ConfigureUtil (with DELEGATE_FIRST strategy), however for backwards compatibility need to use OWNER_FIRST
    new ClosureBackedAction<RemoteRepository>(closure, Closure.OWNER_FIRST).execute(repository);
    return repository;
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
private TestFramework useTestFramework(TestFramework testFramework, Closure testFrameworkConfigure) {
    if (testFramework == null) {
        throw new IllegalArgumentException("testFramework is null!");
    }

    this.testFramework = testFramework;

    if (testFrameworkConfigure != null) {
        ConfigureUtil.configure(testFrameworkConfigure, this.testFramework.getOptions());
    }

    return this.testFramework;
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
void mode(String name, Closure<?> configuration) {
  if (Platform.anySectionNameMatches(name)) { throw new GradleException("Capsule mode cannot be named as platform '" + name + "'."); }
  if (JavaVersion.validRepresentation(name)) { throw new GradleException("Capsule mode cannot be named as java version '" + name + "'."); }
  
  ModeManifest modeManifest = new ModeManifest(name);
  ConfigureUtil.configure(configuration, modeManifest);
  nestedManifests.add(modeManifest);
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
@Override
protected void _configure(String name, Object[] params, InvokeMethodResult result) {
    if (params.length == 1 && params[0] instanceof Closure) {
        result.result(_container.create(name, (Closure) params[0]));
    } else if (params.length == 1 && params[0] instanceof Class) {
        result.result(_container.create(name, (Class) params[0]));
    } else if (params.length == 2 && params[0] instanceof Class && params[1] instanceof Closure){
        result.result(_container.create(name, (Class) params[0], ConfigureUtil.configureUsing((Closure) params[1])));
    }
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
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);
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public WorkResult copy(final Closure closure) {
    return fileCopier.copy(new Action<CopySpec>() {
        public void execute(CopySpec copySpec) {
            copySpec.from(DefaultConfigurableFileTree.this);
            ConfigureUtil.configure(closure, copySpec);
        }
    });
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
@Override
public void invokeMethod(String name, InvokeMethodResult result, Object... arguments) {
    if (isConfigureMethod(name, arguments)) {
        T element = getByName(name);
        Object lastArgument = arguments[arguments.length - 1];
        if (lastArgument instanceof Closure) {
            ConfigureUtil.configure((Closure) lastArgument, element);
        }
        result.result(element);
    }
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public void pluginRepositories(Closure config) {
    try {
        inPluginRepositoriesBlock = true;
        ConfigureUtil.configure(config, getPluginRepositorySpec());
    } finally {
        inPluginRepositoriesBlock = false;
    }
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public RootManifest capsuleManifest(Closure<?> configuration) {
  ConfigureUtil.configure(configuration, capsuleManifest);
  
  return this.capsuleManifest;
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
@Override
public void dependencies(Closure<?> configureAction) {
    ConfigureUtil.configure(configureAction, dependencies);
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public void configure(SigningExtension settings, Closure closure) {
    ConfigureUtil.configure(closure, new Dsl(settings.getProject(), signatories, factory));
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public DefaultMavenPom whenConfigured(final Closure closure) {
    whenConfiguredActions.add(ConfigureUtil.configureUsing(closure));
    return this;
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public GroovyMavenDeployer mavenDeployer(Closure configureClosure) {
    return container.addRepository(createMavenDeployer(), DEFAULT_MAVEN_DEPLOYER_NAME, ConfigureUtil.configureUsing(configureClosure));
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
/**
 * Executes the given closure against this object.
 */
public SignOperation configure(Closure closure) {
    ConfigureUtil.configureSelf(closure, this);
    return this;
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public MavenResolver mavenInstaller(Closure configureClosure) {
    return container.addRepository(createMavenInstaller(), DEFAULT_MAVEN_INSTALLER_NAME, ConfigureUtil.configureUsing(configureClosure));
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public RepositoryPolicy releases(Map properties) {
    RepositoryPolicy policy = new RepositoryPolicy();
    ConfigureUtil.configureByMap(properties, policy);
    addReleases(policy);
    return policy;
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
public RepositoryPolicy snapshots(Map properties) {
    RepositoryPolicy policy = new RepositoryPolicy();
    ConfigureUtil.configureByMap(properties, policy);
    addSnapshots(policy);
    return policy;
}
 

import org.gradle.util.ConfigureUtil; //导入依赖的package包/类
@Override
public WorkResult copy(Closure closure) {
    return copy(ConfigureUtil.configureUsing(closure));
}