protected Queue<Event> initialValue() {
            return Queues.newArrayDeque();
          }
        };

    /** Per-thread dispatch state, used to avoid reentrant event dispatching. */
    private final ThreadLocal<Boolean> dispatching =
        new ThreadLocal<Boolean>() {
          @Override
          protected Boolean initialValue() {
            return false;
          }
        };

    @Override

                dispatchLock.unlock();
            }
        } catch (MessageIOException e) {
            if (suspect) {
                LOG.debug("Problem dispatching message to the daemon.", e);
            } else {
                LOG.debug("Problem dispatching message to the daemon. Performing 'on failure' operation...");
                if (!hasReceived && staleAddressDetector.maybeStaleAddress(e)) {

	// Complete returns a QueueSet configured by the given
	// dispatching configuration.
	Complete(DispatchingConfig) QueueSet
}

// QueueSet is the abstraction for the queuing and dispatching
// functionality of one non-exempt priority level.  It covers the
// functionality described in the "Assignment to a Queue", "Queuing",
// and "Dispatching" sections of

 */
package org.gradle.internal.dispatch;

public interface DispatchFailureHandler<T> {
    /**
     * Called when a message could not be dispatched. This method can throw an exception to abort further dispatching.
     */
    void dispatchFailed(T message, Throwable failure);

import java.lang.reflect.Method;
import java.util.concurrent.Executor;
import javax.annotation.CheckForNull;

/**
 * A subscriber method on a specific object, plus the executor that should be used for dispatching
 * events to it.
 *
 * <p>Two subscribers are equivalent when they refer to the same method on the same object (not
 * class). This property is used to ensure that no subscriber method is registered more than once.
 *

import java.lang.reflect.Method;
import java.util.concurrent.Executor;
import javax.annotation.CheckForNull;

/**
 * A subscriber method on a specific object, plus the executor that should be used for dispatching
 * events to it.
 *
 * <p>Two subscribers are equivalent when they refer to the same method on the same object (not
 * class). This property is used to ensure that no subscriber method is registered more than once.
 *

    @Override
    public void execute(DaemonCommandExecution execution) {
        execution.proceed();

        Result result = new Success(execution.getResult());

        LOGGER.debug("Daemon is dispatching the build result: {}", result);
        execution.getConnection().completed(result);
    }

        where:
        notation << ['org', 'org.foo', 'foo-core', '1.0', 'org.foo:foo-core', 'org.foo:foo-core:1.0']
    }

    def "knows mismatching dependencies"() {
        expect:
        !new DependencyResultSpec(notation).isSatisfiedBy(newDependency("org.foo", "foo-core", "1.0"))

        where:
        notation << ['org1', '2.0', 'core-foo']
    }

        new StrictDependencyResultSpec(moduleIdentifier).isSatisfiedBy(newDependency("org.foo", "foo-core", "1.0"))

        where:
        moduleIdentifier << [id('org.foo', 'foo-core')]
    }

    def "knows mismatching dependencies"() {
        expect:
        !new StrictDependencyResultSpec(moduleIdentifier).isSatisfiedBy(newDependency("org.foo", "foo-core", "1.0"))

        where:

        try {
            Runnable command = new Runnable() {
                @Override
                public void run() {
                    LOGGER.info("Daemon is about to start building {}. Dispatching build started information...", build);
                    execution.getConnection().buildStarted(new BuildStarted(diagnostics));
                    execution.proceed();
                }
            };