ConnectionState state = new ConnectionState(this, connection, queue);
        connections.add(state);
        return state;
    }

    /**
     * Called when all dispatch and receive has completed on the given connection.
     */
    public void finished(ConnectionState connectionState) {
        connections.remove(connectionState);
        if (stopping) {
            maybeStop();

        call.setMethod(new ConstantExpression("create"));
        call.setArguments(replacedArgumentList);

        // Call directly on the delegate to avoid some dynamic dispatch
        call.setImplicitThis(true);
        call.setObjectExpression(new MethodCallExpression(VariableExpression.THIS_EXPRESSION, "getDelegate", ArgumentListExpression.EMPTY_ARGUMENTS));

abstract class Dispatcher {
  /**
   * Returns a response to satisfy `request`. This method may block (for instance, to wait on
   * a CountdownLatch).
   */
  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  /**
   * Returns an early guess of the next response, used for policy on how an incoming request should

	return p, nil
}

// Validate makes an admission decision based on the request attributes.
func (a *Plugin) Validate(ctx context.Context, attr admission.Attributes, o admission.ObjectInterfaces) error {
	return a.Webhook.Dispatch(ctx, attr, o)

        }
    }

    @Override
    public void dispatch(Object value) {
        SerializedPayload serializedModel = payloadSerializer.serialize(value);
        StreamedValue streamedValue = new StreamedValue(serializedModel);
        BuildEventConsumer buildEventConsumer = this.buildEventConsumer;
        sideEffectExecutor.runIsolatableSideEffect(() -> buildEventConsumer.dispatch(streamedValue));
    }

  "IMPLICIT_NOTHING_AS_TYPE_PARAMETER",
)
class KotlinSourceModernTest {
  @Test @Ignore
  fun dispatcherFromMockWebServer() {
    val dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse = TODO()

        override fun peek(): MockResponse = TODO()

        override fun shutdown() = TODO()
      }
  }

  @Test @Ignore
  fun mockResponse() {

    private final IncomingQueue incomingQueue;

    OutgoingQueue(IncomingQueue incomingQueue, Lock lock) {
        super(lock);
        this.incomingQueue = incomingQueue;
    }

    void endOutput() {
        dispatch(new EndOfStream());
    }

    void discardQueued() {
        List<InterHubMessage> rejected = new ArrayList<InterHubMessage>();
        drain(rejected);
        for (InterHubMessage message : rejected) {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal.dispatch

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEqual
import static org.hamcrest.MatcherAssert.assertThat

class MethodInvocationTest extends Specification {

	Entries [1]InterfaceSwitchCacheEntry // Mask+1 entries total
}

type InterfaceSwitchCacheEntry struct {
	// type of source value (a *Type)
	Typ uintptr
	// case # to dispatch to
	Case int
	// itab to use for resulting case variable (a *runtime.itab)
	Itab uintptr
}

const go122InterfaceSwitchCache = true

func UseInterfaceSwitchCache(goarch string) bool {

 */

package org.gradle.internal.logging.sink;

import org.gradle.internal.logging.events.OutputEvent;
import org.gradle.internal.logging.events.OutputEventListener;

/**
 * Manages dispatch of output events to the renderer and at most one other arbitrary listener.
 *
 * This is a degeneralisation of the standard ListenerManager pattern as a performance optimisation.