* 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 org.gradle.util.internal.CollectionUtils;

import java.lang.reflect.Method;
import java.util.Arrays;

public class MethodInvocation {
    private static final Object[] ZERO_ARGS = new Object[0];

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

	}
	return nil
}

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

    public DaemonConnectionBackedEventConsumer(DaemonCommandExecution execution) {
        this.execution = execution;
        forwarder.start();
    }

    @Override
    public void dispatch(Object event) {
        queue.offer(event);
    }

    public void waitForFinish() {
        forwarder.waitForFinish();
    }

    private class ForwardEvents extends Thread {

  @Override public synchronized void onOpen(WebSocket webSocket, Response response) {
    System.out.println("onOpen: " + response);
  }

  // TOOD(jwilson): decode incoming messages and dispatch them somewhere.
  @Override public void onMessage(WebSocket webSocket, String text) {
    System.out.println("onMessage: " + text);
  }

  @Override public void onClosing(WebSocket webSocket, int code, String reason) {

    // Now we find the task in our Executor and explicitly activate it.
    List<Runnable> tasks = executor.getTasks();
    assertEquals("One event dispatch task should be queued.", 1, tasks.size());

    tasks.get(0).run();

    assertEquals("One event should be delivered.", 1, events.size());
    assertEquals("Correct string should be delivered.", EVENT, events.get(0));

        // execute
        reader.readArtifactDescriptor(session, request);

        // verify
        verify(eventDispatcher).dispatch(event.capture());

        boolean missingArtifactDescriptor = false;

        for (RepositoryEvent evt : event.getAllValues()) {
            if (EventType.ARTIFACT_DESCRIPTOR_MISSING.equals(evt.getType())) {

/**
 * Injects the logic for Groovy calls instrumentation into the Groovy metaclasses.
 */
@NonNullApi
public class InstrumentedGroovyMetaClassHelper {
    /**
     * Should be invoked on an object that a Groovy Closure can dispatch the calls to. Injects the call interception logic into the metaclass of that object.
     * This is done for closure delegates that are reassigned, while the owner, thisObject, and the initial delegate are covered in

        return listOfNotNull(
            smartCastedImplicitReceiver(smartCasts.receiverTypes[resolvedCall.dispatchReceiver], KaImplicitReceiverSmartCastKind.DISPATCH),
            smartCastedImplicitReceiver(smartCasts.receiverTypes[resolvedCall.extensionReceiver], KaImplicitReceiverSmartCastKind.EXTENSION)
        )
    }

        return Objects.hash(backingType, backingKind)
    }
}

public typealias KtImplicitReceiverSmartCast = KaImplicitReceiverSmartCast

public enum class KaImplicitReceiverSmartCastKind {
    DISPATCH, EXTENSION
}