n2.is(factory.named(Named, "b"))
    }

    def "can unpack and recreate Named instance"() {
        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)
    }

        super(managed);
        this.managedFactoryRegistry = managedFactoryRegistry;
    }

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

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

    @Nullable
    @Override

        assertThat(sourceSet.scala.srcDirs, equalTo([tmpDir.file('src/scala')] as Set))
    }

    @Test
    void exposesConventionPublicType() {
        sourceSet.publicType == typeOf(ScalaSourceSet)
    }

    def setup() {
        buildFile """
            def extractSchema(container) {
                return container.collectionSchema.elements.collectEntries { e ->
                    [ e.name, e.publicType.simpleName ]
                }.sort()
            }
            def assertSchemaIs(Map expected, NamedDomainObjectCollection container) {
                def actual = extractSchema(container)

        } as Action<SourceDirectorySet>)

        expect:
        CollectionUtils.single(sourceSet.groovy.srcDirs) == tmpDir.file("src/groovy")
    }

    void exposesConventionPublicType() {
        sourceSet.publicType == typeOf(GroovySourceSet)
    }

        when:
        project.pluginManager.apply(AntlrPlugin)

        then:
        def main = project.sourceSets.main
        main.extensions.extensionsSchema.find { it.name == 'antlr' }.publicType == typeOf(AntlrSourceDirectorySet)
    }

     */
    boolean isImmutable();

    /**
     * Returns the public type of this managed instance. Currently is used to identify the implementation.
     */
    Class<?> publicType();

    /**
     * Returns the id of a factory that can be used to create new instances of this type.
     */
    int getFactoryId();

    public DefaultListProperty(PropertyHost host, Class<T> elementType) {
        super(host, List.class, elementType, Cast.uncheckedNonnullCast(FACTORY));
    }

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

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

    @Override

    }

    @Override
    protected Set<T> emptyCollection() {
        return ImmutableSet.of();
    }

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

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

    @Override

    val type = readClass()
    return Attribute.of(name, type.uncheckedCast())
}


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