handlers        []DefaultHandler

	queue    controllers.Queue
	webhooks kclient.Client[*admitv1.MutatingWebhookConfiguration]
	mu       sync.RWMutex
}

func NewDefaultWatcher(client kube.Client, revision string) DefaultWatcher {
	p := &defaultWatcher{
		revision: revision,
		mu:       sync.RWMutex{},
	}
	p.queue = controllers.NewQueue("default revision", controllers.WithReconciler(p.setDefault))

	"istio.io/istio/pkg/kube/controllers"
	"istio.io/istio/pkg/util/sets"
)

// Index maintains a simple index over an informer
type Index[K comparable, O controllers.ComparableObject] struct {
	mu      sync.RWMutex
	objects map[K]sets.Set[types.NamespacedName]
	client  Informer[O]
}

// Lookup finds all objects matching a given key
func (i *Index[K, O]) Lookup(k K) []O {
	i.mu.RLock()
	defer i.mu.RUnlock()

types 13 2 24 84 208 17 30 41 147 86 17 64 25 75
type 1 "Apple" <type 2>
type 2 struct { .issue30628.hey <type 3>; .issue30628.x <type -11>; RQ <type 11>; }
type 3 "sync.RWMutex" <type 7>
 func (rw <type 4>) Lock ()
 func (rw <esc:0x12> <type 4>) RLocker () ($ret8 <type 5>)
 func (rw <type 4>) RUnlock ()
 func (rw <type 4>) Unlock ()
 func (rw <type 4>) RLock ()
type 4 *<type 3>

type bucketThrottle struct {
	*rate.Limiter
	NodeBandwidthPerSec int64
}

// Monitor holds the state of the global bucket monitor
type Monitor struct {
	tlock sync.RWMutex // mutex for bucket throttling
	mlock sync.RWMutex // mutex for bucket measurement

	bucketsThrottle    map[BucketOptions]*bucketThrottle
	bucketsMeasurement map[BucketOptions]*bucketMeasurement // Buckets with objects in flight

	"k8s.io/kubernetes/pkg/scheduler/framework"
)

// waitingPodsMap a thread-safe map used to maintain pods waiting in the permit phase.
type waitingPodsMap struct {
	pods map[types.UID]*waitingPod
	mu   sync.RWMutex
}

// NewWaitingPodsMap returns a new waitingPodsMap.
func NewWaitingPodsMap() *waitingPodsMap {
	return &waitingPodsMap{
		pods: make(map[types.UID]*waitingPod),
	}
}

// add a new WaitingPod to the map.

)

// PluginsStore holds a list of DRA Plugins.
type pluginsStore struct {
	sync.RWMutex
	store map[string]*plugin
}

// draPlugins map keeps track of all registered DRA plugins on the node
// and their corresponding sockets.
var draPlugins = &pluginsStore{}

// Get lets you retrieve a DRA Plugin by name.
// This method is protected by a mutex.
func (s *pluginsStore) get(pluginName string) *plugin {
	s.RLock()
	defer s.RUnlock()

var dirApplierMap = make(map[string]common.LinuxVolumeQuotaApplier)
var dirApplierLock sync.RWMutex

// Pod -> refcount
var podDirCountMap = make(map[types.UID]int)

// ID -> size
var quotaSizeMap = make(map[common.QuotaID]int64)
var quotaLock sync.RWMutex

var supportsQuotasMap = make(map[string]bool)
var supportsQuotasLock sync.RWMutex

// Directory -> backingDev
var backingDevMap = make(map[string]string)

}

type TrustAnchorUpdate struct {
	TrustAnchorConfig
	Source Source
}

type TrustBundle struct {
	sourceConfig       map[Source]TrustAnchorConfig
	mutex              sync.RWMutex
	mergedCerts        []string
	updatecb           func()
	endpointMutex      sync.RWMutex
	endpoints          []string
	endpointUpdateChan chan struct{}
	remoteCaCertPool   *x509.CertPool
	meshConfig         mesh.Watcher
}

var (

	highestSupportedVersion *utilversion.Version
}

// DriversStore holds a list of CSI Drivers
type DriversStore struct {
	store
	sync.RWMutex
}

type store map[string]Driver

// Get lets you retrieve a CSI Driver by name.
// This method is protected by a mutex.
func (s *DriversStore) Get(driverName string) (Driver, bool) {
	s.RLock()
	defer s.RUnlock()

	driver, ok := s.store[driverName]
	return driver, ok

package socktest

import (
	"fmt"
	"sync"
)

// A Switch represents a callpath point switch for socket system
// calls.
type Switch struct {
	once sync.Once

	fmu   sync.RWMutex
	fltab map[FilterType]Filter

	smu   sync.RWMutex
	sotab Sockets
	stats stats
}

func (sw *Switch) init() {
	sw.fltab = make(map[FilterType]Filter)
	sw.sotab = make(Sockets)
	sw.stats = make(stats)
}