private Action<? super ActionConfiguration> componentMetadataListerRuleConfiguration;
    private final ObjectFactory objectFactory;
    private final RepositoryContentDescriptorInternal repositoryContentDescriptor;

    protected AbstractArtifactRepository(ObjectFactory objectFactory, VersionParser versionParser) {
        this.objectFactory = objectFactory;
        this.repositoryContentDescriptor = createRepositoryDescriptor(versionParser);
    }

            return objectFactory.newInstance(DefaultJvmToolchainManagement.class, registry);
        }

        @Provides
        protected JdkCacheDirectory createJdkCacheDirectory(ObjectFactory objectFactory, GradleUserHomeDirProvider homeDirProvider, FileOperations operations, FileLockManager lockManager, JvmMetadataDetector detector) {

    @Inject
    public DefaultJavaDebugOptions(ObjectFactory objectFactory) {
        this.enabled = objectFactory.property(Boolean.class).convention(false);
        this.host = objectFactory.property(String.class);
        this.port = objectFactory.property(Integer.class).convention(5005);
        this.server = objectFactory.property(Boolean.class).convention(true);
        this.suspend = objectFactory.property(Boolean.class).convention(true);
    }

        @Provides
        VcsMappings createVcsMappings(ObjectFactory objectFactory, VcsMappingsStore vcsMappingsStore, Gradle gradle, NotationParser<String, ModuleIdentifier> notationParser) {
            return objectFactory.newInstance(DefaultVcsMappings.class, vcsMappingsStore, gradle, notationParser);
        }

        @Provides

        // disallow changing property values
        finalizeProperties();
    }

    public static SpecificInstallationToolchainSpec fromJavaHome(ObjectFactory objectFactory, File javaHome) {
        if (javaHome.exists()) {
            if (javaHome.isDirectory()) {
                return objectFactory.newInstance(SpecificInstallationToolchainSpec.class, javaHome);
            } else {

        TaskDependencyFactory taskDependencyFactory,
        ObjectFactory objectFactory
    ) {
        NotationParser<Object, Capability> capabilityNotationParser = new CapabilityNotationParserFactory(false).create();
        return new DefaultProjectDependencyFactory(instantiator, startParameter.isBuildProjectDependencies(), capabilityNotationParser, objectFactory, attributesFactory, taskDependencyFactory);
    }

    @Provides

        this.objectFactory = objectFactory
    }

    @TaskAction
    void doTaskAction() {
        var outputDirectory = objectFactory.directoryProperty()
        outputDirectory.convention(project.layout.projectDirectory)
        println(outputDirectory.get())
    }
}

tasks.register("myInjectedObjectFactoryTask",MyObjectFactoryTask) {}
// end::object-factory-inject[]

// tag::project-layout[]

import org.gradle.api.attributes.Usage
import org.gradle.api.attributes.java.TargetJvmEnvironment
import org.gradle.api.model.ObjectFactory
import org.gradle.kotlin.dsl.named


fun ConsumableConfiguration.configureAsRuntimeElements(objects: ObjectFactory) {
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))

class Dog(name: String, val breed: String) : Animal(name)

abstract class MyPluginExtensionExtensiblePolymorphicDomainObjectContainer(objectFactory: ObjectFactory) {
    // Define a container for animals
    private val animals: ExtensiblePolymorphicDomainObjectContainer<Animal> = objectFactory.polymorphicDomainObjectContainer(Animal::class)

    // Add a dog to the container
    fun addDog(name: String, breed: String) {

        this.dependencyLockingProvider = dependencyLockingProvider;
        this.capabilitiesResolution = capabilitiesResolution;
        this.objectFactory = objectFactory;
        this.useGlobalDependencySubstitutionRules = objectFactory.property(Boolean.class).convention(true);
        // This is only used for testing purposes so we can test handling of fluid dependencies without adding dependency substitution rule