}

            task extractSymbolsDebug(type: ExtractSymbols) { extract ->
                project.application.binaries.get { !it.optimized }.configure {
                    def linkDebug = linkTask.get()
                    extract.toolChain = linkDebug.toolChain
                    extract.targetPlatform = linkDebug.targetPlatform
                    extract.binaryFile.set linkDebug.linkedFile
                }

  void Extract(tflite::metrics::ConverterErrorData* error_data) {
    using tflite::metrics::ConverterErrorData;
    auto mutable_location = error_data->mutable_location();

    llvm::TypeSwitch<LocationAttr>(impl)
        .Case<OpaqueLoc>([&](OpaqueLoc loc) {
          LocationExtractor(loc.getFallbackLocation()).Extract(error_data);
        })

        expect:
        extract(ClassWithNonRuleMethods).empty
    }

    static abstract class AbstractRules extends RuleSource {}

    def "rule class can be abstract"() {
        expect:
        extract(AbstractRules).empty
    }

    def "can create instance of abstract rule class"() {
        expect:
        def schema = extractor.extract(AbstractRules)

                        into layout.buildDirectory.dir("extract")
                    }
                }
            }
            task extract2(type: CopyAndList) {
                unzipped.from(zipTree(file("hello.zip")))
            }
        """
        when:
        succeeds("extract")
        then:
        file("build/extract/hello.txt").text == "hello"
        cachedFile.assertExists()

	c Collection[I],
	extract func(o I) []K,
) *Index[I, K] {
	idx := Index[I, K]{
		objects: make(map[K]sets.Set[Key[I]]),
		c:       c,
		mu:      sync.RWMutex{},
		extract: extract,
	}
	c.Register(func(o Event[I]) {
		idx.mu.Lock()
		defer idx.mu.Unlock()

		if o.Old != nil {
			obj := *o.Old
			key := GetKey(obj)
			for _, indexKey := range extract(obj) {

            error(unsupportedValueTypeConfig { type('MyTask').property('nestedBean.nestedInput').annotationType(annotation).unsupportedValueType('ResolvedArtifactResult').propertyType('Property<ResolvedArtifactResult>').solution('Extract artifact metadata and annotate with @Input.').solution('Extract...

 *
 * <p>
 * For a given build tree, only a single process is allowed write access to extract archives at a time.
 *
 * Multiple build processes are allowed to extract archives concurrently as long as they use different build trees (in other words, different root directories).
 * <p>

        return uncheckedCast(extract(type, 0));
    }

    public static <D, R, T extends BuildOperationType<D, R>> Class<R> resultType(Class<T> type) {
        return uncheckedCast(extract(type, 1));
    }

    private static <T extends BuildOperationType<?, ?>> Class<?> extract(Class<T> type, int index) {

    }

    def "only one thread is allowed to extract the same archive at once"() {
        given:
        server.start()
        createTar('test.tar') {
            file ('file.txt').text = 'original text 1'
        }
        buildFile << """
            task extract(type: Extract) {
                archiveFile = file('test.tar')
                destinationDir = file('build/extract')
            }

	if e.AddExtendedFunc != nil {
		e.AddExtendedFunc(Extract[T](obj), initialSync)
	} else if e.AddFunc != nil {
		e.AddFunc(Extract[T](obj))
	}
}

func (e EventHandler[T]) OnUpdate(oldObj, newObj interface{}) {
	if e.UpdateFunc != nil {
		e.UpdateFunc(Extract[T](oldObj), Extract[T](newObj))
	}
}

func (e EventHandler[T]) OnDelete(obj interface{}) {