org.gradle.api.NamedDomainObjectContainer Java Examples

private void createJdk(Project project,
                       String name,
                       String vendor,
                       String version,
                       String os,
                       String arch) {
    //noinspection unchecked
    var jdks = (NamedDomainObjectContainer<Jdk>) project.getExtensions().getByName("jdks");
    jdks.create(name, jdk -> {
        if (vendor != null) {
            jdk.setVendor(vendor);
        }
        if (version != null) {
            jdk.setVersion(version);
        }
        if (os != null) {
            jdk.setOs(os);
        }
        if (arch != null) {
            jdk.setArch(arch);
        }
    }).finalizeValues();
}
 

public AtlasExtension createExtendsion(Project project, Instantiator instantiator) {

        AtlasExtension atlasExtension = getExtendsion(project);

        if (null != atlasExtension) {
            return atlasExtension;
        }

        final NamedDomainObjectContainer<TBuildType> buildTypeContainer = project.container(TBuildType.class,
                                                                                            new TBuildTypeFactory(
                                                                                                instantiator, project,
                                                                                                project.getLogger()));
        final NamedDomainObjectContainer<PatchConfig> patchConfigContainer = project.container(PatchConfig.class,
                                                                                               new PatchConfigFactory(
                                                                                                   instantiator,
                                                                                                   project, project
                                                                                                       .getLogger()));
        final NamedDomainObjectContainer<DexConfig>dexConfigContainer = project.container(DexConfig.class,new DexConfigFactory(instantiator,project,project.getLogger()));

        return project.getExtensions().create("atlas", AtlasExtension.class, project, instantiator,
                                              buildTypeContainer, patchConfigContainer,dexConfigContainer);

    }
 

public void apply(Project project) {
    NamedDomainObjectContainer<BeanstalkDeployment> deployments = project.container(BeanstalkDeployment.class);
    BeanstalkPluginExtension beanstalk = project.getExtensions().create("beanstalk", BeanstalkPluginExtension.class);
    ((ExtensionAware) beanstalk).getExtensions().add("deployments", deployments);

    project.afterEvaluate(p -> {
        for (BeanstalkDeployment deployment : deployments) {
            String name = deployment.getName();
            String task = "deploy" + Character.toUpperCase(name.charAt(0)) + name.substring(1);

            p.getTasks().create(task, DeployTask.class, deployTask -> {
                deployTask.setBeanstalk(beanstalk);
                deployTask.setDeployment(deployment);
            });
        }
    });
}
 

private static void createCompoundSourceSets(
        @NonNull List<? extends ProductFlavor> productFlavorList,
        GradleVariantConfiguration variantConfig,
        NamedDomainObjectContainer<AndroidSourceSet> sourceSetsContainer) {
    if (!productFlavorList.isEmpty() && !variantConfig.getType().isSingleBuildType()) {
        DefaultAndroidSourceSet variantSourceSet =
                (DefaultAndroidSourceSet) sourceSetsContainer.maybeCreate(
                        computeSourceSetName(
                                variantConfig.getFullName(),
                                variantConfig.getType()));
        variantConfig.setVariantSourceProvider(variantSourceSet);
    }

    if (productFlavorList.size() > 1) {
        DefaultAndroidSourceSet multiFlavorSourceSet =
                (DefaultAndroidSourceSet) sourceSetsContainer.maybeCreate(
                        computeSourceSetName(
                                variantConfig.getFlavorName(),
                                variantConfig.getType()));
        variantConfig.setMultiFlavorSourceProvider(multiFlavorSourceSet);
    }
}
 

public AppExtension(@NonNull ProjectInternal project, @NonNull Instantiator instantiator,
                    @NonNull AndroidBuilder androidBuilder, @NonNull SdkHandler sdkHandler,
                    @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
                    @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
                    @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs,
                    @NonNull ExtraModelInfo extraModelInfo, boolean isLibrary) {
    super(project, instantiator, androidBuilder, sdkHandler, buildTypes, productFlavors,
            signingConfigs, extraModelInfo, isLibrary);
}
 

@Inject
public DownloadedToolManager(
    Project project, NamedDomainObjectContainer<ToolDownloaderExtension> tools) {
  this.tools = tools;

  curiostackDir = project.getGradle().getGradleUserHomeDir().toPath().resolve("curiostack");
}
 

public AndroidConfigAdaptor(
        AndroidConfig model,
        NamedDomainObjectContainer<AndroidSourceSet> sourceSetsContainer) {
    this.model = model;
    this.sourceSetsContainer = sourceSetsContainer;
    applyProjectSourceSet();
}
 

@Override
public void apply(Project project) {
    NamedDomainObjectContainer<Jdk> jdksContainer = project.container(
        Jdk.class,
        name -> new Jdk(name, project.getConfigurations().create("jdk_" + name), project.getObjects())
    );
    project.getExtensions().add(EXTENSION_NAME, jdksContainer);

    project.afterEvaluate(p ->
        jdksContainer.all(jdk -> {
            jdk.finalizeValues();
            // depend on the jdk directory "artifact" from the root project
            var dependencies = project.getDependencies();
            Map<String, Object> depConfig = Map.of(
                "path", ":",
                "configuration", configName(
                    "extract",
                    jdk.vendor(),
                    jdk.version(),
                    jdk.platform()));
            dependencies.add(
                jdk.configuration().getName(),
                dependencies.project(depConfig));

            setupRootJdkDownload(project.getRootProject(), jdk);
        })
    );
}
 

@Override
public void createDefaultComponents(
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs) {
    // must create signing config first so that build type 'debug' can be initialized
    // with the debug signing config.
    signingConfigs.create(DEBUG);
    buildTypes.create(DEBUG);
    buildTypes.create(RELEASE);
}
 

public static void setProperty(Object object,
                               String fieldName,
                               String value)
    throws IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {

    String[] fieldNames = fieldName.split("\\.");

    Object last = object;
    for (int i = 0; i < fieldNames.length - 1; i++) {

        String field = fieldNames[i];

        if (last instanceof NamedDomainObjectContainer) {
            last = ((NamedDomainObjectContainer)last).maybeCreate(field);
        } else {
            Field declaredField = last.getClass().getField(field);
            declaredField.setAccessible(true);

            if (null == declaredField.get(last)) {
                Object newInstance = declaredField.getType()
                    .getConstructors()
                    .getClass()
                    .newInstance();
                declaredField.set(last, newInstance);
            }

            last = declaredField.get(last);
        }
    }

    BeanUtils.setProperty(last, fieldNames[fieldNames.length - 1], value);
}
 

@Override
public void createDefaultComponents(
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs) {
    // must create signing config first so that build type 'debug' can be initialized
    // with the debug signing config.
    signingConfigs.create(DEBUG);
    buildTypes.create(DEBUG);
    buildTypes.create(RELEASE);
}
 

public NamedDomainObjectContainer<ToolDownloaderExtension> tools() {
  return tools;
}
 

default ProtobufExtension sources(
    Action<? super NamedDomainObjectContainer<SourceDirectorySet>> action) {
  action.execute(getSources());
  return this;
}
 

default TerraformSetupExtension providers(
    Action<? super NamedDomainObjectContainer<CustomProvider>> action) {
  action.execute(getProviders());
  return this;
}
 

public void builds(Action<? super NamedDomainObjectContainer<? super ClojureBuild>> configureAction) {
  configureAction.execute(builds);
}
 

public NamedDomainObjectContainer<ExternalRepo> getExternalRepos() {
    return externalRepos;
}
 

public NamedDomainObjectContainer<Sample> getSamples() {
    return samples;
}
 

public DefaultJvmComponentExtension(NamedDomainObjectContainer<JvmLibrarySpec> libraries) {
    this.libraries = libraries;
}
 

public NamedDomainObjectContainer<JvmLibrarySpec> getLibraries() {
    return libraries;
}
 

public void libraries(Action<? super NamedDomainObjectContainer<? super JvmLibrarySpec>> action) {
    action.execute(libraries);
}
 

public DefaultNativeComponentExtension(NamedDomainObjectContainer<NativeExecutableSpec> executables, NamedDomainObjectContainer<NativeLibrarySpec> libraries) {
    this.executables = executables;
    this.libraries = libraries;
}
 

public NamedDomainObjectContainer<ClojureBuild> getBuilds() {
  return builds;
}
 

void createDefaultComponents(
@NonNull NamedDomainObjectContainer<BuildType> buildTypes,
@NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
@NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs);
 

public NamedDomainObjectContainer<NativeExecutableSpec> getExecutables() {
    return executables;
}
 

@Override
public NamedDomainObjectContainer<AndroidSourceSet> getSourceSets() {
    return sourceSetsContainer;
}
 

/**
 * All source sets. Note that the Android plugin uses its own implementation of
 * source sets, {@link AndroidSourceSet}.
 */
@Override
public NamedDomainObjectContainer<AndroidSourceSet> getSourceSets() {
    return sourceSetsContainer;
}
 

/**
 * Configures the signing configs.
 */
public void signingConfigs(Action<? super NamedDomainObjectContainer<SigningConfig>> action) {
    checkWritability();
    action.execute(signingConfigs);
}
 

/**
 * Configures the product flavors.
 */
public void productFlavors(Action<? super NamedDomainObjectContainer<CoreProductFlavor>> action) {
    checkWritability();
    action.execute(productFlavors);
}
 

/**
 * Configures the build types.
 */
public void buildTypes(Action<? super NamedDomainObjectContainer<BuildType>> action) {
    checkWritability();
    action.execute(buildTypes);
}
 

BaseExtension(
        @NonNull final ProjectInternal project,
        @NonNull Instantiator instantiator,
        @NonNull AndroidBuilder androidBuilder,
        @NonNull SdkHandler sdkHandler,
        @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
        @NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
        @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs,
        @NonNull ExtraModelInfo extraModelInfo,
        final boolean isLibrary) {
    this.androidBuilder = androidBuilder;
    this.sdkHandler = sdkHandler;
    this.buildTypes = buildTypes;
    //noinspection unchecked
    this.productFlavors = (NamedDomainObjectContainer) productFlavors;
    this.signingConfigs = signingConfigs;
    this.extraModelInfo = extraModelInfo;
    this.project = project;

    logger = Logging.getLogger(this.getClass());

    defaultConfig = instantiator.newInstance(ProductFlavor.class, BuilderConstants.MAIN,
            project, instantiator, project.getLogger());

    aaptOptions = instantiator.newInstance(AaptOptions.class);
    dexOptions = instantiator.newInstance(DexOptions.class);
    lintOptions = instantiator.newInstance(LintOptions.class);
    compileOptions = instantiator.newInstance(CompileOptions.class);
    packagingOptions = instantiator.newInstance(PackagingOptions.class);
    preprocessingOptions = instantiator.newInstance(PreprocessingOptions.class);
    splits = instantiator.newInstance(Splits.class, instantiator);

    sourceSetsContainer = project.container(AndroidSourceSet.class,
            new AndroidSourceSetFactory(instantiator, project, isLibrary));

    sourceSetsContainer.whenObjectAdded(new Action<AndroidSourceSet>() {
        @Override
        public void execute(AndroidSourceSet sourceSet) {
            ConfigurationContainer configurations = project.getConfigurations();

            createConfiguration(
                    configurations,
                    sourceSet.getCompileConfigurationName(),
                    "Classpath for compiling the " + sourceSet.getName() + " sources.");

            String packageConfigDescription;
            if (isLibrary) {
                packageConfigDescription
                        = "Classpath only used when publishing '" + sourceSet.getName() + "'.";
            } else {
                packageConfigDescription
                        = "Classpath packaged with the compiled '" + sourceSet.getName() + "' classes.";
            }
            createConfiguration(
                    configurations,
                    sourceSet.getPackageConfigurationName(),
                    packageConfigDescription);

            createConfiguration(
                    configurations,
                    sourceSet.getProvidedConfigurationName(),
                    "Classpath for only compiling the " + sourceSet.getName() + " sources.");

            createConfiguration(
                    configurations,
                    sourceSet.getWearAppConfigurationName(),
                    "Link to a wear app to embed for object '" + sourceSet.getName() + "'.");

            sourceSet.setRoot(String.format("src/%s", sourceSet.getName()));
        }
    });

    sourceSetsContainer.create(defaultConfig.getName());
}