package sample.documentation

import org.gradle.model.Managed
import org.gradle.platform.base.GeneralComponentSpec

// tag::component-declaration[]
@Managed
interface DocumentationComponent extends GeneralComponentSpec {}

package sample.documentation

import org.gradle.model.Managed
import org.gradle.platform.base.BinarySpec

// tag::binary-declaration[]
@Managed
interface DocumentationBinary extends BinarySpec {
    File getOutputDir()
    void setOutputDir(File outputDir)
}

        }

        @Override
        public Isolatable<?> managedImmutableValue(Managed managed) {
            return new IsolatedImmutableManagedValue(managed, managedFactoryRegistry);
        }

        @Override
        public Isolatable<?> managedValue(Managed value, Isolatable<?> state) {

        then:
        succeeds "echo"

        and:
        output.contains('value: foo')
    }

    def "unmanaged property of managed type can be targeted by rules"() {
        when:
        buildScript '''
            @Managed
            interface Platform {
                @Unmanaged
                OperatingSystem getOperatingSystem()
                void setOperatingSystem(OperatingSystem os)
            }

)

// ExtractInto extracts the applied configuration state from object for fieldManager
// into applyConfiguration. If no managed fields are found for the given fieldManager,
// no error is returned, but applyConfiguration is left unpopulated. It is possible
// that no managed fields were found for the fieldManager because other field managers
// have taken ownership of all the fields previously owned by the fieldManager. It is

 * limitations under the License.
 */

package org.gradle.model.internal.manage.projection
import org.gradle.model.Managed

class SetModelProjectionTest extends AbstractCollectionModelProjectionTest<String, Set<String>> {

    @Managed
    static interface Internal {
        Set<String> getItems()
    }

    @Override
    Class<?> holderType() {
        Internal

        class Widget {
            String name
        }

        @Managed
        interface Container {
            @Unmanaged
            List<Widget> getWidgets()
            void setWidgets(List<Widget> l)

            @Unmanaged
            Set<Widget> getItems()
            void setItems(Set<Widget> s)

            @Unmanaged
            List getRawWidgets()
            void setRawWidgets(List l)
        }

package sample.documentation

import org.gradle.language.base.LanguageSourceSet
import org.gradle.model.Managed

// tag::text-lang-declaration[]
@Managed
interface TextSourceSet extends LanguageSourceSet {}

import org.gradle.internal.serialize.graph.readCollection
import org.gradle.internal.serialize.graph.readNonNull
import org.gradle.internal.serialize.graph.writeCollection
import org.gradle.internal.state.Managed
import org.gradle.internal.state.ManagedFactoryRegistry


class AttributeContainerCodec(
    private val attributesFactory: ImmutableAttributesFactory,
    private val managedFactories: ManagedFactoryRegistry

 * limitations under the License.
 */

package org.gradle.model.managed

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.UnsupportedWithConfigurationCache

@UnsupportedWithConfigurationCache(because = "software model")
class ManagedTypeImplementationClassCachingSpec extends AbstractIntegrationSpec {

    def "managed type implementation class is generated once for each type and reused"() {