private final Map<Long, ResolutionData> resolutionData = new ConcurrentHashMap<>();
    private final Lazy<InjectedInstrumentationServices> internalServices = Lazy.locking().of(() -> getObjectFactory().newInstance(InjectedInstrumentationServices.class));

                id 'java'
            }

            ${mavenCentralRepository()}

            abstract class MyTask extends DefaultTask {
                @Inject
                public abstract ObjectFactory getObjectFactory()

                @Input
                $elementInitialization

                @TaskAction
                void action() {
                    logger.warn("Input file: {}", $elementRead)
                }

    private CopySpec lib;
    private final DirectoryProperty appDir;

    public Ear() {
        getArchiveExtension().set(EAR_EXTENSION);
        setMetadataCharset("UTF-8");
        generateDeploymentDescriptor = getObjectFactory().property(Boolean.class);
        generateDeploymentDescriptor.convention(true);
        lib = getRootSpec().addChildBeforeSpec(getMainSpec()).into(
            callable(() -> GUtil.elvis(getLibDirName(), DEFAULT_LIB_DIR_NAME))

        // To avoid code duplication, the initialization logic is extracted to an instance initialization block.
        ObjectFactory objectFactory = getObjectFactory();
        this.analysisMappingFile = objectFactory.fileProperty();
        this.analysisFiles = getProject().files();
        this.compileOptions = objectFactory.newInstance(CompileOptions.class);

    public CreateStartScripts() {
        this.mainModule = getObjectFactory().property(String.class);
        this.mainClass = getObjectFactory().property(String.class);
        this.modularity = getObjectFactory().newInstance(DefaultModularitySpec.class);
    }

    @Inject
    protected ObjectFactory getObjectFactory() {
        throw new UnsupportedOperationException();
    }

    @Inject

    private boolean parameters;

    private final SetProperty<String> disabledGlobalASTTransformations = getObjectFactory().setProperty(String.class);

    @Inject
    protected ObjectFactory getObjectFactory() {
        throw new UnsupportedOperationException();
    }

    /**
     * Tells whether the compilation task should fail if compile errors occurred. Defaults to {@code true}.
     */
    @Input

    private final Property<Boolean> enableExternalDtdLoad;

    public Checkstyle() {
        super();
        this.configDirectory = getObjectFactory().directoryProperty();
        this.reports = getObjectFactory().newInstance(CheckstyleReportsImpl.class, this);
        this.enableExternalDtdLoad = getObjectFactory().property(Boolean.class).convention(false);
    }

    /**
     * The Checkstyle configuration file to use.
     */

        this.sourceSet = sourceSets.create(getName());
        this.taskDependencyFactory = taskDependencyFactory;
        this.toolchainFactory = new ToolchainFactory(getObjectFactory(), getParentServices(), getInstantiatorFactory());

        this.targets = getObjectFactory().polymorphicDomainObjectContainer(JvmTestSuiteTarget.class);
        this.targets.registerBinding(JvmTestSuiteTarget.class, DefaultJvmTestSuiteTarget.class);

    private final Property<JavaLauncher> javaLauncher;
    private final ListProperty<String> jvmArguments;

    public JavaExec() {
        ObjectFactory objectFactory = getObjectFactory();
        mainModule = objectFactory.property(String.class);
        mainClass = objectFactory.property(String.class);
        modularity = objectFactory.newInstance(DefaultModularitySpec.class);

            import javax.inject.Inject;

            abstract public class SoftwareTypeImplPlugin implements Plugin<Project> {
                @Inject
                abstract protected ObjectFactory getObjectFactory();

                @SoftwareType(name="testSoftwareType", modelPublicType=TestSoftwareTypeExtension.class)
                abstract public TestSoftwareTypeExtension getTestSoftwareTypeExtension();