import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Override
public void apply(Project project) {
    final ConfigurationContainer configurations = project.getConfigurations();
    configurations.maybeCreate("test");
    configurations.maybeCreate("build");
    configurations.maybeCreate("tool");

    final ExtensionContainer extensions = project.getExtensions();
    final ExtensionAware golang = (ExtensionAware) extensions.create("golang", GolangSettings.class, true, project);
    golang.getExtensions().create("build", BuildSettings.class, true, project);
    golang.getExtensions().create("toolchain", ToolchainSettings.class, true, project);
    golang.getExtensions().create("dependencies", DependenciesSettings.class, true, project);
    golang.getExtensions().create("testing", TestingSettings.class, true, project);

    extensions.create(INSTANCE_PROPERTY_NAME, Reference.class, this);

    final TaskContainer tasks = project.getTasks();
    addTasks(tasks);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
public void generate() {
  ExtensionContainer extensions = project.getExtensions();
  EclipseCheckstyleExtension prefs = extensions.getByType(EclipseCheckstyleExtension.class);
  
  CheckstyleExtension ext = project.getExtensions().getByType(CheckstyleExtension.class);
  if (ext == null) {
    return;
  }
  
  // Without a checkstyle config file defined, we currently don't do anything.
  File configFile = ext.getConfigFile();
  if (configFile == null || !configFile.exists()) {
    return;
  }

  log.info("eclipse checkstyle: configuring eclipse checkstyle using config {}", configFile);
  String configPath = configFile.toString();
  String projectDir = project.getProjectDir().getAbsolutePath() + File.separator;
  String name = project.getName() + "-checkstyle";
  write(projectDir, CHECKSTYLE_CONFIG, build(name, configPath, prefs));
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Before
public void setUp() {
	project = mock(Project.class);
	// project.getExtensions().getExtraProperties().set(passwordProperty, pass);
	ExtensionContainer extensionContainer = mock(ExtensionContainer.class);
	when(project.getExtensions()).thenReturn(extensionContainer);
	extraProperties = mock(ExtraPropertiesExtension.class);
	when(extensionContainer.getExtraProperties()).thenReturn(extraProperties);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
public Settings(@Nonnull Project project, @Nonnull ExtensionContainer container) {
    _project = project;
    _golang = container.getByType(GolangSettings.class);
    if (!(_golang instanceof ExtensionAware)) {
        throw new IllegalStateException("golang instance (" + _golang + ") of provided extension container (" + container + ") is not an instance of " + ExtensionAware.class.getName() + ".");
    }
    final ExtensionContainer globalExtensions = ((ExtensionAware) _golang).getExtensions();
    _build = globalExtensions.getByType(BuildSettings.class);
    _toolchain = globalExtensions.getByType(ToolchainSettings.class);
    _dependencies = globalExtensions.getByType(DependenciesSettings.class);
    _testing = globalExtensions.getByType(TestingSettings.class);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
/**
 * Create task to update readme file from template
 *
 * @param tasks Task container to create new tasks
 * @param projectConfig Project configuration
 * @param projectContext Project context
 * @param extensions Extension container
 */
@Mutate
public void createReadmeUpdateTasks(ModelMap<Task> tasks, ProjectConfig projectConfig,
        ProjectContext projectContext, ExtensionContainer extensions) {
    // Create task to update the README
    Map<String, Object> context = new HashMap<>();

    extensions.getExtraProperties().getProperties().forEach((name, value) -> {
        context.put(name, value);
    });

    context.put("project", projectContext);
    context.put("projectConfig", projectConfig);

    tasks.create("readmeUpdate", Copy.class, t -> {
        t.setDescription("Update README from template.");
        t.setGroup("documentation");
        t.from("src/doc/templates");
        t.include("README.template.md");
        t.rename(n -> n.replace(".template.", "."));
        t.expand(context);

        ConventionMapping parameters = t.getConventionMapping();
        parameters.map("destinationDir", () -> projectContext.getProjectDir());
    });

    tasks.named("assemble", t -> {
        t.dependsOn("readmeUpdate");
    });
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Before
public void setUp() {
    this.project = mock(Project.class);
    ExtensionContainer extensionContainer = mock(ExtensionContainer.class);
    this.pluginExtension = sampleExtension(this.project);
    when(extensionContainer.findByType(CfPluginExtension.class)).thenReturn(this.pluginExtension);
    when(this.project.getExtensions()).thenReturn(extensionContainer);
    this.cfPropertiesMapper = new CfPropertiesMapper(this.project);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
protected RegisterTypeRule(ModelType<? extends T> type, ModelType<? extends U> implementation, ModelRuleDescriptor descriptor, Action<? super RegistrationContext<T, U>> registerAction) {
    this.type = type;
    this.implementation = implementation;
    this.descriptor = descriptor;
    this.registerAction = registerAction;

    subject = ModelReference.of("extensions", ExtensionContainer.class);
    inputs = ImmutableList.<ModelReference<?>>of(ModelReference.of(ProjectIdentifier.class));
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
public final void mutate(final ExtensionContainer extensionContainer, final Inputs inputs) {
    RuleContext.inContext(getDescriptor(), new Runnable() {
        public void run() {
            RegistrationContext<T, U> context = new RegistrationContext<T, U>(type, implementation, extensionContainer, inputs.get(0, ModelType.of(ProjectIdentifier.class)).getInstance());
            registerAction.execute(context);
        }
    });
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Mutate
void registerPlatformExtension(ExtensionContainer extensions, PlatformContainer platforms) {
    extensions.add("platforms", platforms);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Model
PublishingExtension publishing(ExtensionContainer extensions) {
    return extensions.getByType(PublishingExtension.class);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
public void apply(Project project) {
    project.getPluginManager().apply(RhinoPlugin.class);

    JavaScriptExtension jsExtension = project.getExtensions().getByType(JavaScriptExtension.class);

    ExtensionContainer extensionContainer = ((ExtensionAware) jsExtension).getExtensions();
    final CoffeeScriptExtension csExtension = extensionContainer.create(CoffeeScriptExtension.NAME, CoffeeScriptExtension.class);
    final Configuration jsConfiguration = addJsConfiguration(project.getConfigurations(), project.getDependencies(), csExtension);

    ConventionMapping conventionMapping = ((IConventionAware) csExtension).getConventionMapping();
    conventionMapping.map("js", new Callable<Configuration>() {
        @Override
        public Configuration call() {
            return jsConfiguration;
        }
    });
    conventionMapping.map("version", new Callable<String>() {
        @Override
        public String call() {
            return CoffeeScriptExtension.DEFAULT_JS_DEPENDENCY_VERSION;
        }
    });

    final RhinoExtension rhinoExtension = extensionContainer.getByType(RhinoExtension.class);

    project.getTasks().withType(CoffeeScriptCompile.class, new Action<CoffeeScriptCompile>() {
        @Override
        public void execute(CoffeeScriptCompile task) {
            task.getConventionMapping().map("rhinoClasspath", new Callable<FileCollection>() {
                public FileCollection call() {
                    return rhinoExtension.getClasspath();
                }
            });
            task.getConventionMapping().map("coffeeScriptJs", new Callable<FileCollection>() {
                public FileCollection call() {
                    return csExtension.getJs();
                }
            });
        }
    });
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Model
NativeToolChainRegistryInternal toolChains(ExtensionContainer extensionContainer) {
    return extensionContainer.getByType(NativeToolChainRegistryInternal.class);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Model
BuildTypeContainer buildTypes(ExtensionContainer extensionContainer) {
    return extensionContainer.getByType(BuildTypeContainer.class);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Model
FlavorContainer flavors(ExtensionContainer extensionContainer) {
    return extensionContainer.getByType(FlavorContainer.class);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Model
public GradlePluginDevelopmentExtension gradlePluginDevelopmentExtension(ExtensionContainer extensionContainer) {
    return extensionContainer.getByType(GradlePluginDevelopmentExtension.class);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
public ExtensionContainer getExtensions() {
    return convention;
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
public ExtensionContainer getExtensions() {
    return getConvention();
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
public ExtensionContainer getExtensions() {
    if (extensionContainer == null) {
        this.extensionContainer = toType(object, ExtensionAware.class).getExtensions();
    }
    return extensionContainer;
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
@Model
PlayPluginConfigurations configurations(ExtensionContainer extensions) {
    return extensions.getByType(PlayPluginConfigurations.class);
}
 

import org.gradle.api.plugins.ExtensionContainer; //导入依赖的package包/类
public RegistrationContext(ModelType<? extends T> type, ModelType<? extends U> implementation, ExtensionContainer extensions, ProjectIdentifier projectIdentifier) {
    this.type = type;
    this.implementation = implementation;
    this.extensions = extensions;
    this.projectIdentifier = projectIdentifier;
}