*
 * @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);

    public DefaultPropertyFactory(PropertyHost propertyHost) {
        this.propertyHost = propertyHost;
    }

    @Override
    public <T> DefaultProperty<T> property(Class<T> type) {
        return new DefaultProperty<>(propertyHost, type);
    }

    @Override
    public <T> DefaultListProperty<T> listProperty(Class<T> elementType) {
        return new DefaultListProperty<>(propertyHost, elementType);

 */

package org.gradle.api.services.internal;

import org.gradle.api.artifacts.component.BuildIdentifier;
import org.gradle.api.internal.provider.AbstractMinimalProvider;
import org.gradle.api.internal.provider.DefaultProperty;
import org.gradle.api.internal.provider.ProviderInternal;
import org.gradle.api.provider.Provider;
import org.gradle.api.services.BuildService;
import org.gradle.api.services.BuildServiceParameters;

import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.file.SourceDirectorySet;
import org.gradle.api.internal.provider.DefaultListProperty;
import org.gradle.api.internal.provider.DefaultProperty;
import org.gradle.api.internal.provider.PropertyHost;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.ListProperty;
import org.gradle.api.provider.MapProperty;

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);

     * Intended for tests of providers which aren't properties.
     */
    trait UsesStringProperty {
        DefaultProperty<String> property() {
            return TestUtil.objectFactory().property(String) as DefaultProperty<String>
        }
    }

    static class ProducerDiscardingProvider<T> extends AbstractMinimalProvider<T> {
        private final ProviderInternal<T> provider

    @SuppressWarnings("FieldMayBeFinal")
    private String value = "value";

    private Property<String> property;

    @Setup
    public void setUp() {
        property = new DefaultProperty<>(host, String.class);
        property.set(new TransformBackedProvider<>(String.class, new DefaultProvider<>(() -> value), v -> v + v));
    }

    @Benchmark
    public void getPropertyValue(Blackhole bh) {

 *
 * <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

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

        }
    }

    public static class PropertyManagedFactory implements ManagedFactory {
        private static final Class<?> PUBLIC_TYPE = Property.class;
        private static final Class<?> IMPL_TYPE = DefaultProperty.class;
        public static final int FACTORY_ID = Objects.hashCode(IMPL_TYPE.getName());
        private final PropertyFactory propertyFactory;

        public PropertyManagedFactory(PropertyFactory propertyFactory) {