CABundleWatcher: caBundleWatcher,
	}
	p.queue = newWebhookPatcherQueue(p.webhookPatchTask)

	p.webhooks = kclient.New[*v1.MutatingWebhookConfiguration](client)
	p.webhooks.AddEventHandler(controllers.ObjectHandler(p.queue.AddObject))

	return p, nil
}

func newWebhookPatcherQueue(reconciler controllers.ReconcilerFn) controllers.Queue {
	return controllers.NewQueue("webhook patcher",
		controllers.WithReconciler(reconciler),

		controllers.WithReconciler(c.Reconcile),
		controllers.WithMaxAttempts(5))

	// For any ingress change, enqueue it - we may need to update the status.
	c.ingresses.AddEventHandler(controllers.ObjectHandler(c.queue.AddObject))
	// For any class change, sync all ingress; the handler will filter non-matching ones already
	c.ingressClasses.AddEventHandler(controllers.ObjectHandler(func(o controllers.Object) {
		// Just sync them all
		c.enqueueAll()

				if err == nil {
					l, err := meta.ExtractList(objs)
					if err != nil {
						return false, nil, err
					}
					for _, object := range l {
						watch.(addObject).Add(object)
					}
				}
				return true, watch, nil
			})
			k.Dynamic().Resource(gvr.VirtualService).Namespace("default").Create(context.Background(),

	c.configmaps.AddEventHandler(controllers.FilteredObjectSpecHandler(c.queue.AddObject, func(o controllers.Object) bool {
		// skip special kubernetes system namespaces
		return !c.ignoredNamespaces.Contains(o.GetNamespace())
	}))

	c.namespaces.AddEventHandler(controllers.FilteredObjectSpecHandler(c.queue.AddObject, func(o controllers.Object) bool {

	// No more data in either list.
	if s.freeBuf != nil {
		putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
		s.freeBuf = nil
	}
	return 0, false
}

// addObject adds a stack object at addr of type typ to the set of stack objects.
func (s *stackScanState) addObject(addr uintptr, r *stackObjectRecord) {
	x := s.tail
	if x == nil {
		// initial setup
		x = (*stackObjectBuf)(unsafe.Pointer(getempty()))
		x.next = nil

	}
	q.log = log.WithLabels("controller", q.name)
	return q
}

// Add an item to the queue.
func (q Queue) Add(item any) {
	q.queue.Add(item)
}

// AddObject takes an Object and adds the types.NamespacedName associated.
func (q Queue) AddObject(obj Object) {
	q.queue.Add(config.NamespacedName(obj))
}

// Run the queue. This is synchronous, so should typically be called in a goroutine.

	p.queue = controllers.NewQueue("default revision", controllers.WithReconciler(p.setDefault))
	p.webhooks = kclient.New[*admitv1.MutatingWebhookConfiguration](client)
	p.webhooks.AddEventHandler(controllers.FilteredObjectHandler(p.queue.AddObject, isDefaultTagWebhook))

	return p
}

func (p *defaultWatcher) Run(stopCh <-chan struct{}) {
	kube.WaitForCacheSync("default revision", stopCh, p.webhooks.HasSynced)
	p.queue.Run(stopCh)
}

			rev := o.GetLabels()[label.IoIstioRev.Name]
			if rev == "" {
				return nil
			}
			return []string{rev}
		}, controllers.ObjectHandler(p.queue.AddObject))
	return p
}

func (p *tagWatcher) Run(stopCh <-chan struct{}) {
	if !kube.WaitForCacheSync("tag watcher", stopCh, p.webhooks.HasSynced) {
		return
	}
	// Notify handlers of initial state
	p.notifyHandlers()

		controllers.WithReconciler(gc.Reconcile),
		controllers.WithMaxAttempts(25))

	gc.classes = kclient.New[*gateway.GatewayClass](kc)
	gc.classes.AddEventHandler(controllers.FilteredObjectHandler(gc.queue.AddObject, func(o controllers.Object) bool {
		_, f := builtinClasses[gateway.ObjectName(o.GetName())]
		return f
	}))
	return gc
}

func (c *ClassController) Run(stop <-chan struct{}) {

        Bean otherObject = new Bean();
        otherObject.defineProperty("otherObject", "value");

        Bean bean = new Bean();
        bean.extensibleDynamicObject.addObject(otherObject.getAsDynamicObject(), ExtensibleDynamicObject.Location.BeforeConvention);

        assertTrue(bean.hasProperty("otherObject"));
        assertThat(bean.getProperty("otherObject"), equalTo((Object) "value"));