type SourcesReadyFn func(sourcesSeen sets.Set[string]) bool

// SourcesReady tracks the set of configured sources seen by the kubelet.
type SourcesReady interface {
	// AddSource adds the specified source to the set of sources managed.
	AddSource(source string)
	// AllReady returns true if the currently configured sources have all been seen.
	AllReady() bool
}

// NewSourcesReady returns a SourcesReady with the specified function.

                            sourceFile.bufferedReader().readText().replace("@org.jetbrains.annotations.Nullable", "")
                        addSource(StringReader(filteredSourceCode))
                    } else {
                        addSource(sourceFile)
                    }
                }
        }

    override fun close() =
        loader.close()
}


/**

	analyzer := analyzers.AllCombined()
	all := kuberesource.ConvertInputsToSchemas(analyzer.Metadata().Inputs)

	ia := local.NewIstiodAnalyzer(analyzer, "", resource.Namespace(namespace), func(name config.GroupVersionKind) {})
	ia.AddSource(rwConfigStore)

	// Filter out configs watched by rwConfigStore so we don't watch multiple times
	store := crdclient.NewForSchemas(kubeClient,
		crdclient.Option{
			Revision:     revision,
			DomainSuffix: domainSuffix,

        def classesDir = tmpDir.createDir("classes/$className")
        def compilationUnit = new CompilationUnit(new GroovyClassLoader(getClass().classLoader))
        compilationUnit.addSource(className, classText)

        def configuration = new CompilerConfiguration()
        configuration.setTargetDirectory(classesDir)

        compilationUnit.setConfiguration(configuration)

		}
	}
}

// AddSource adds a source based on user supplied configstore to the current IstiodAnalyzer
// Assumes that the source has same or subset of resource types that this analyzer is configured with.
// This can be used by external users who import the analyzer as a module within their own controllers.
func (sa *IstiodAnalyzer) AddSource(src model.ConfigStoreController) {
	sa.stores = append(sa.stores, src)

}

func TestAddInMemorySource(t *testing.T) {
	g := NewWithT(t)

	sa := NewSourceAnalyzer(blankCombinedAnalyzer, "", "", nil)

	src := model.NewFakeStore()
	sa.AddSource(dfCache{ConfigStore: src})
	assert.Equal(t, sa.meshCfg, mesh.DefaultMeshConfig()) // Base default meshcfg
	g.Expect(sa.meshNetworks.Networks).To(HaveLen(0))
	g.Expect(sa.stores).To(HaveLen(1))
}

        def matchingChildren = op.children.findAll { it.hasDetailsOfType(ExecuteListenerBuildOperationType.Details) && it.details.applicationId == expectedApplicationId }
        verifyExpectedOps(matchingChildren, addSource(expectedOps, sourceName))
        matchingChildren
    }

    private static void verifyHasNoChildren(BuildOperationRecord op, long expectedApplicationId) {

}

type sourcesReadyStub struct{}

// PodReusableDevices is a map by pod name of devices to reuse.
type PodReusableDevices map[string]map[string]sets.Set[string]

func (s *sourcesReadyStub) AddSource(source string) {}
func (s *sourcesReadyStub) AllReady() bool          { return true }

// NewManagerImpl creates a new manager.

			klog.ErrorS(nil, "Kubelet does not support snapshot update")
		default:
			klog.ErrorS(nil, "Invalid operation type received", "operation", u.Op)
		}

		kl.sourcesReady.AddSource(u.Source)

	case e := <-plegCh:
		if isSyncPodWorthy(e) {
			// PLEG event for a pod; sync it.
			if pod, ok := kl.podManager.GetPodByUID(e.ID); ok {

		{"Float64", Func, 21},
		{"Float64Value", Func, 21},
		{"Group", Func, 21},
		{"GroupValue", Func, 21},
		{"Handler", Type, 21},
		{"HandlerOptions", Type, 21},
		{"HandlerOptions.AddSource", Field, 21},
		{"HandlerOptions.Level", Field, 21},
		{"HandlerOptions.ReplaceAttr", Field, 21},
		{"Info", Func, 21},
		{"InfoContext", Func, 21},
		{"Int", Func, 21},
		{"Int64", Func, 21},