.singleOrNull()
}

/**
 * Implicit dispatch receiver is present when an extension function declared in object
 * is imported somewhere else and used without directly referencing the object instance
 * itself:
 *
 * ```kt
 * import Foo.bar
 *
 * object Foo { fun String.bar() {} }
 *
 * fun usage() {
 *   "hello".bar() // this call has implicit 'Foo' dispatch receiver
 * }
 * ```
 */

        super(buildController, adapter, modelMapping, gradleVersion, rootDir);
        this.relay = (InternalStreamedValueRelay) buildController;
    }

    @Override
    public <T> void send(T value) {
        relay.dispatch(value);
    }

/**
 * A decorated domain object type may optionally implement this interface to dynamically expose methods in addition to those declared statically on the type.
 *
 * Note that when a type implements this interface, dynamic Groovy dispatch will not be used to discover opaque methods. That is, methods such as methodMissing() will be ignored.
 */
public interface MethodMixIn {
    MethodAccess getAdditionalMethods();

package okhttp3.mockwebserver

import mockwebserver3.QueueDispatcher

class QueueDispatcher : Dispatcher() {
  internal val delegate = QueueDispatcher()

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  override fun peek(): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

    # package for your domain name, e.g. com.example
    ; domainPackage = org.codelibs.fess

    # keywords for environment properties, same as directory name
    ; environmentList = list:{}

    # environment dispatch by lasta.env of system property?
    ; isUseLastaEnv = false

    # settings for web applications
    ; appMap = map:{
        ; fess = map:{
            ; path = ..

    private final BlockingQueue<InterHubMessage> outgoing = new LinkedBlockingQueue<>()
    private final BlockingQueue<InterHubMessage> outgoingBuffered = new LinkedBlockingQueue<>()

    @Override
    void dispatch(InterHubMessage message) {
        outgoingBuffered.put(message)
    }

    @Override
    void flush() {
        outgoingBuffered.drainTo(outgoing)
    }

    @Override
    InterHubMessage receive() {

	admission.Attributes
	resource schema.GroupVersionResource
}

func (a *attrWithResourceOverride) GetResource() schema.GroupVersionResource { return a.resource }

// Dispatch is called by the downstream Validate or Admit methods.
func (a *Webhook) Dispatch(ctx context.Context, attr admission.Attributes, o admission.ObjectInterfaces) error {
	if rules.IsExemptAdmissionConfigurationResource(attr) {
		return nil
	}

        file("settings.gradle") << "// empty"
        def projectdir = file("project dir").createDir()

        //requesting x failing builds creates enough stress to expose issues with unsynchronized dispatch
        50.times {
            executer.usingProjectDirectory(projectdir)
                    .withTasks("tasks")
                    .runWithFailure()
        }
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal.event;

import org.gradle.internal.dispatch.MethodInvocation;
import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.exceptions.DefaultMultiCauseException;

import javax.annotation.Nullable;

/**

Dispatcher (`import okhttp3.mockwebserver.Dispatcher`) to handle requests using another policy. One natural policy is to
dispatch on the request path.
You can, for example, filter the request instead of using `server.enqueue()`.

```java
final Dispatcher dispatcher = new Dispatcher() {

    @Override
    public MockResponse dispatch (RecordedRequest request) throws InterruptedException {

        switch (request.getPath()) {