}

    @Override
    public ValueSnapshot asSnapshot() {
        return new ImmutableManagedValueSnapshot(getValue().publicType().getName(), (String) getValue().unpackState());
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        asSnapshot().appendToHasher(hasher);
    }

    @Nullable
    @Override
    public <S> S coerce(Class<S> type) {

        !bean.isImmutable()
        def state = bean.unpackState()
        state.length == 1
        state[0] == null

        def copy = managedFactoryRegistry.lookup(bean.getFactoryId()).fromState(BeanWithAbstractProperty, state)
        !copy.is(bean)
        copy.name == null

        bean.setName("name")
        copy.name == null

        def state2 = bean.unpackState()
        state2.length == 1
        state2[0] == "name"

        expect:
        def n1 = factory.named(Named, "a")
        n1 instanceof Managed
        n1.publicType() == Named
        n1.isImmutable()
        def state = n1.unpackState()
        state == "a"

        def n2 = factory.fromState(Named, state)
        n2.is(n1)
    }

    def "creates instance of subtype of Named"() {
        expect:

     *
     * <p>Note that currently the state should reference only JVM and core Gradle types when {@link #isImmutable()} returns true.</p>
     */
    @Nullable
    Object unpackState();

    /**
     * Is this object graph immutable? Returns false if this object may be mutable, in which case the state should be unpacked and isolated.
     */
    boolean isImmutable();

    /**

        };

        void beforeGet(BuildServiceProvider<?, ?> provider);
    }

    @Override
    public boolean isImmutable() {
        return true;
    }

    @Override
    public Object unpackState() {
        throw new UnsupportedOperationException("Build services cannot be serialized.");
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {

                _GETFIELD(generatedTypeName, NAME_FIELD, STRING);
                _ARETURN();
            }});

            //
            // Add `Object unpackState() { return name }`
            //
            publicMethod("unpackState", RETURN_OBJECT, methodVisitor -> new MethodVisitorScope(methodVisitor) {{
                _ALOAD(0);
                _GETFIELD(generatedTypeName, NAME_FIELD, STRING);

}


private
suspend fun WriteContext.writeManaged(value: Managed) {
    writeSmallInt(value.factoryId)
    writeClass(value.publicType())
    write(value.unpackState())
}


private
suspend fun ReadContext.readManaged(managedFactories: ManagedFactoryRegistry): Any {
    val factoryId = readSmallInt()
    val type = readClass()
    val state = read()

            return true;
        }

        @Override
        public Class<?> publicType() {
            return Directory.class;
        }

        @Override
        public Object unpackState() {
            return getAsFile();
        }

        @Override
        public int getFactoryId() {
            return ManagedFactories.DirectoryManagedFactory.FACTORY_ID;
        }

        }

        @Override
        public ValueSnapshot managedImmutableValue(Managed managed) {
            return new ImmutableManagedValueSnapshot(managed.publicType().getName(), (String) managed.unpackState());
        }

        @Override
        public ValueSnapshot managedValue(Managed value, ValueSnapshot state) {
            return new ManagedValueSnapshot(value.publicType().getName(), state);
        }

        if (managed.isImmutable()) {
            return visitor.managedImmutableValue(managed);
        } else {
            // May (or may not) be mutable - unpack the state
            T state = processValue(managed.unpackState(), visitor);
            return visitor.managedValue(managed, state);
        }
    }

    private <T> T processMap(Map<?, ?> map, ValueVisitor<T> visitor) {