* limitations under the License.
 */
package org.gradle.internal.dispatch;

/**
 * A general purpose sink for a stream of messages.
 *
 * <p>Implementations are not required to be thread-safe.
 */
public interface Dispatch<T> {
    /**
     * Dispatches the next message. Blocks until the messages has been accepted but generally does not wait for the

    }

    def "ERROR is dispatched to the stderr chain"() {
        when:
        dispatcher.onOutput(event(LogLevel.ERROR))

        then:
        0 * stdoutChain.onOutput(_)
        1 * stderrChain.onOutput(_)
    }

    def "event without log level is dispatched to both chains"() {
        when:
        dispatcher.onOutput(event(null))

        then:

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()

  /**

 * #enqueue enqueueing} and then {@linkplain #dispatch dispatching} events.
 *
 * <p>The API of this class is designed to make it easy to achieve the following properties
 *
 * <ul>
 *   <li>Multiple events for the same listener are never dispatched concurrently.
 *   <li>Events for the different listeners are dispatched concurrently.
 *   <li>All events for a given listener dispatch on the provided {@link #executor}.

	Resource    schema.GroupVersionResource
	Subresource string
	Kind        schema.GroupVersionKind
}

// Dispatcher dispatches webhook call to a list of webhooks with admission attributes as argument.
type Dispatcher interface {
	// Dispatch a request to the webhooks. Dispatcher may choose not to
	// call a hook, either because the rules of the hook does not match, or

 * #enqueue enqueueing} and then {@linkplain #dispatch dispatching} events.
 *
 * <p>The API of this class is designed to make it easy to achieve the following properties
 *
 * <ul>
 *   <li>Multiple events for the same listener are never dispatched concurrently.
 *   <li>Events for the different listeners are dispatched concurrently.
 *   <li>All events for a given listener dispatch on the provided {@link #executor}.

import org.gradle.internal.concurrent.ThreadSafe;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.DispatchException;
import org.gradle.internal.dispatch.MethodInvocation;

/**
 * <p>An {@code Actor} dispatches method calls to a target object in a thread-safe manner. Methods are called either by
 * calling {@link Dispatch#dispatch(Object)} on the actor, or using the proxy object

        then:
        1 * dispatch1.dispatch(invocation)
        then:
        1 * dispatch2.dispatch(invocation)
        0 * _._
    }

    def 'visit listeners does not visit dispatch instances'() {
        def dispatch = Mock(Dispatch)
        def visitor = Mock(Action)

        given:
        broadcast.add(dispatch)

        when:
        broadcast.visitListeners(visitor)

        then:

	// 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