*
 * @param <T> the type of the property value
 */
public class DefaultProperty<T> extends AbstractProperty<T, ProviderInternal<? extends T>> implements Property<T> {
    private final Class<T> type;
    private final ValueSanitizer<T> sanitizer;
    private final static ProviderInternal<?> NOT_DEFINED = Providers.notDefined();

    public DefaultProperty(PropertyHost propertyHost, Class<T> type) {
        super(propertyHost);

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface PropertyFactory {
    <T> DefaultProperty<T> property(Class<T> type);

    <T> DefaultListProperty<T> listProperty(Class<T> elementType);

    <T> DefaultSetProperty<T> setProperty(Class<T> elementType);

) : Codec<DefaultProperty<*>> {

    override suspend fun WriteContext.encode(value: DefaultProperty<*>) {
        encodePreservingIdentityOf(value) {
            writeClass(value.type as Class<*>)
            providerCodec.run { encodeProvider(value.provider) }
        }
    }

    override suspend fun ReadContext.decode(): DefaultProperty<*> {
        return decodePreservingIdentity { id ->

import org.gradle.util.TestUtil

class DefaultPropertyTest extends AbstractPropertySpec<String> {
    DefaultProperty<String> property() {
        return propertyWithDefaultValue(String)
    }

    DefaultProperty propertyWithDefaultValue(Class type) {
        return new DefaultProperty(host, type)
    }

    @Override
    DefaultProperty<String> propertyWithNoValue() {
        return property()
    }

    @Override

 *
 * <p>Other classes implementing <code>Property</code> in this module:</p>
 * <ul>
 *     <li>{@link org.gradle.api.internal.provider.DefaultProperty} - a concrete implementation for general-purpose properties.</li>
 *     <li>{@link org.gradle.api.internal.provider.AbstractCollectionProperty} - implements the API for

import org.gradle.api.cache.CacheResourceConfiguration;
import org.gradle.api.cache.Cleanup;
import org.gradle.api.cache.MarkingStrategy;
import org.gradle.api.internal.DocumentationRegistry;
import org.gradle.api.internal.provider.DefaultProperty;
import org.gradle.api.internal.provider.DefaultProvider;
import org.gradle.api.internal.provider.PropertyHost;
import org.gradle.api.invocation.Gradle;
import org.gradle.api.model.ObjectFactory;

import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.internal.provider.AbstractMinimalProvider;
import org.gradle.api.internal.provider.BiProvider;
import org.gradle.api.internal.provider.DefaultProperty;
import org.gradle.api.internal.provider.MappingProvider;
import org.gradle.api.internal.provider.PropertyHost;
import org.gradle.api.internal.provider.Providers;
import org.gradle.api.provider.Provider;

                subclass(ConfigureAccessorInternal.DefaultConfiguringLambdaArgument::class)
                subclass(ConfigureAccessorInternal.DefaultCustom::class)
                subclass(ConfigureAccessorInternal.DefaultProperty::class)
            }
            polymorphic(DataType::class) {
                subclass(DataTypeInternal.DefaultIntDataType::class)
                subclass(DataTypeInternal.DefaultLongDataType::class)

            private
            fun readResolve(): Any = DefaultRequired
        }
    }
}


object ConfigureAccessorInternal {
    @Serializable
    @SerialName("property")
    data class DefaultProperty(override val dataProperty: DataProperty) : ConfigureAccessor.Property

    @Serializable
    @SerialName("custom")

                val accessor = if (property != null) ConfigureAccessorInternal.DefaultProperty(property) else ConfigureAccessorInternal.DefaultConfiguringLambdaArgument(configuredType.toDataTypeRefOrError())
                FunctionSemanticsInternal.DefaultAccessAndConfigure(accessor, returnType, blockRequirement)