* The instance is not injected directly into this service as the instance will be constructed in some other scope.
     * </p>
     */
    void dispatchTo(UserInputReceiver userInput);

    /**
     * Discards the current {@link UserInputReceiver} instance used by this service.
     */
    void stopDispatching();

        if (userInput == null) {
            throw new IllegalStateException("User input has not been initialized.");
        }
        return userInput;
    }

    @Override
    public void dispatchTo(UserInputReceiver userInput) {
        if (!delegate.compareAndSet(null, userInput)) {
            throw new IllegalStateException("User input has already been initialized.");
        }
    }

    @Override

        userInput.dispatchTo(forwarder);
    }

    @Override
    public void stop() {
        userInput.stopDispatching();
        forwarder.stop();
        executor.shutdown();
    }

    private static class ForwardingUserInput implements UserInputReceiver {
        private final Dispatch<? super InputMessage> dispatch;
        private final BufferedReader reader;

import okhttp3.internal.threadFactory

/**
 * Policy on when async requests are executed.
 *
 * Each dispatcher uses an [ExecutorService] to run calls internally. If you supply your own
 * executor, it should be able to run [the configured maximum][maxRequests] number of calls
 * concurrently.
 */
class Dispatcher() {
  internal val lock: ReentrantLock = ReentrantLock()

  /**

	// HasSynced returns true if the source has completed its initial sync.
	HasSynced() bool
}

// Dispatcher dispatches evaluates an admission request against the currently
// active hooks returned by the source.
type Dispatcher[H Hook] interface {
	// Dispatch a request to the policies. Dispatcher may choose not to
	// call a hook, either because the rules of the hook does not match, or

	})
}

func debugCallWrap2(dispatch uintptr) {
	// Call the dispatch function and trap panics.
	var dispatchF func()
	dispatchFV := funcval{dispatch}
	*(*unsafe.Pointer)(unsafe.Pointer(&dispatchF)) = noescape(unsafe.Pointer(&dispatchFV))

	var ok bool
	defer func() {
		if !ok {
			err := recover()
			debugCallPanicked(err)
		}
	}()
	dispatchF()
	ok = true

	return nil
}

func (c *Plugin[H]) Dispatch(
	ctx context.Context,
	a admission.Attributes,
	o admission.ObjectInterfaces,
) (err error) {
	if !c.enabled {
		return nil
	} else if c.shouldIgnoreResource(a) {
		return nil
	} else if !c.WaitForReady() {
		return admission.NewForbidden(a, fmt.Errorf("not yet ready to handle request"))
	}

	return c.dispatcher.Dispatch(ctx, a, o, c.source.Hooks())
}

	*admission.Handler

	sourceFactory sourceFactory

	hookSource       Source
	clientManager    *webhookutil.ClientManager
	namespaceMatcher *namespace.Matcher
	objectMatcher    *object.Matcher
	dispatcher       Dispatcher
	filterCompiler   cel.FilterCompiler
	authorizer       authorizer.Authorizer
}

var (
	_ genericadmissioninit.WantsExternalKubeClientSet = &Webhook{}

     */
    void onCancel(@Nullable Runnable handler);

    /**
     * Dispatches a daemon unavailable message to the client.
     */
    void daemonUnavailable(DaemonUnavailable unavailable);

    /**
     * Dispatches a build started message to the client.
     */
    void buildStarted(BuildStarted buildStarted);

    /**
     * Dispatches a log event message to the client.
     */
    void logEvent(OutputEvent logEvent);

 * limitations under the License.
 */

package org.gradle.internal.dispatch;

/**
 * Creates a proxy object which sets the context ClassLoader when invoking methods on the target object.
 */
public class ContextClassLoaderProxy<T> {
    private final ProxyDispatchAdapter<T> adapter;

    /**
     * Creates a proxy which dispatches to the given target object.
     */