* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.state;

import javax.annotation.Nullable;

public interface ManagedFactory {
    /**
     * Creates an instance of a managed object from the given state, if possible.
     */
    @Nullable
    <T> T fromState(Class<T> type, Object state);

    /**

import org.gradle.internal.state.ManagedFactory;

import javax.annotation.Nullable;

public class IsolatedManagedValue extends AbstractManagedValueSnapshot<Isolatable<?>> implements Isolatable<Object> {
    private final ManagedFactory factory;
    private final Class<?> targetType;

    public IsolatedManagedValue(Class<?> targetType, ManagedFactory factory, Isolatable<?> state) {
        super(state);

import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.provider.Provider;
import org.gradle.internal.Cast;
import org.gradle.internal.state.ManagedFactory;

import java.io.File;

public class ManagedFactories {

    public static class RegularFileManagedFactory implements ManagedFactory {
        private static final Class<?> PUBLIC_TYPE = RegularFile.class;

        return baseDirectory.file("other3").get()
    }

    @Override
    PropertyInternal<RegularFile> propertyWithNoValue() {
        return factory.newFileProperty()
    }

    @Override
    ManagedFactory managedFactory() {
        new ManagedFactories.RegularFilePropertyManagedFactory(factory)
    }

import org.gradle.api.provider.SetProperty;
import org.gradle.internal.Cast;
import org.gradle.internal.state.ManagedFactory;

import javax.annotation.Nullable;
import java.util.Map;

public class ManagedFactories {
    public static class ProviderManagedFactory implements ManagedFactory {
        private static final Class<?> PUBLIC_TYPE = Provider.class;

    }

    @Override
    protected List<String> toMutable(Collection<String> values) {
        return new ArrayList<String>(values)
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.ListPropertyManagedFactory(TestUtil.propertyFactory())
    }

    }

    @Override
    Integer someOtherValue3() {
        return 12345
    }

    @Override
    boolean isNoValueProviderImmutable() {
        return true
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.ProviderManagedFactory()
    }

    }

    @Override
    @Nullable
    public ManagedFactory lookup(int id) {
        ManagedFactory factory = managedFactoryCache.getIfPresent(id);
        if (factory == null && parent != null) {
            factory = parent.lookup(id);
        }
        return factory;
    }

    private void register(ManagedFactory factory) {
        ManagedFactory existing = managedFactoryCache.getIfPresent(factory.getId());

    }

    @Override
    String someOtherValue2() {
        "other2"
    }

    @Override
    String someOtherValue3() {
        "other3"
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.ProviderManagedFactory()
    }

    def "is present when value is not null"() {
        expect:
        !provider.present
        provider.value("s1")

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

@ServiceScope({Scope.Global.class, Scope.Project.class})
public interface ManagedFactoryRegistry {
    /**
     * Looks up a {@link ManagedFactory} that can provide the given type.
     */
    ManagedFactory lookup(int id);