*/

package org.gradle.internal.remote.internal;

import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.Receive;

/**
 * <p>A messaging endpoint which allows push-style dispatch and pull-style receive.
 *
 * <p>Implementations are not guaranteed to be completely thread-safe.
 * However, the implementations:
 * <ul>

    def connection = Mock(Connection)

    def "ignores failed dispatch and does not receive"() {
        given:
        def message = new ReportStatus(UUID.randomUUID(), "TOKEN".bytes)
        connection.dispatch(message) >> { throw new RuntimeException("Cannot dispatch") }

        when:
        dispatcher.dispatch(connection, message)

        then:
        0 * connection.receive()

    def dispatcher = new StopDispatcher()
    def connection = Mock(Connection)

    def "ignores failed dispatch and does not receive"() {
        given:
        def message = new Stop(UUID.randomUUID())
        connection.dispatch(message) >> { throw new RuntimeException("Cannot dispatch") }

        when:
        dispatcher.dispatch(connection, message)

        then:
        0 * connection.receive()
        noExceptionThrown()

    }

    public void cleanup() {
        Thread.currentThread().contextClassLoader = original
    }

    def 'sets ContextClassLoader during dispatch'() {
        when:
        dispatch.dispatch('message')

        then:
        1 * target.dispatch('message') >> {
            assertContextClassloaderIs(appClassLoader)
        }
        0 * _._

        assertContextClassloaderIs(original)
    }

	})
}

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

    public DaemonCancelForwarder(final Dispatch<? super Cancel> dispatch, BuildCancellationToken cancellationToken) {
        this.cancellationToken = cancellationToken;
        cancellationCallback = new Runnable() {
            @Override
            public void run() {
                LOGGER.info("Request daemon to cancel build...");
                dispatch.dispatch(new Cancel());
            }
        };
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub.queue;

import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.remote.internal.hub.protocol.EndOfStream;
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage;

public class QueueInitializer {
    private EndOfStream endOfStream;

 * limitations under the License.
 */

package org.gradle.internal.actor.internal

import org.gradle.internal.concurrent.ThreadSafe
import org.gradle.internal.dispatch.DispatchException
import org.gradle.internal.dispatch.MethodInvocation
import org.gradle.test.fixtures.concurrent.ConcurrentSpec

class DefaultActorFactorySpec extends ConcurrentSpec {
    private final TargetObject target = Mock()

/**
 * An {@link EventBus} that takes the Executor of your choice and uses it to dispatch events,
 * allowing dispatch to occur asynchronously.
 *
 * @author Cliff Biffle
 * @since 10.0
 */
@ElementTypesAreNonnullByDefault
public class AsyncEventBus extends EventBus {

  /**
   * Creates a new AsyncEventBus that will use {@code executor} to dispatch events. Assigns {@code
   * identifier} as the bus's name for logging purposes.
   *

 * limitations under the License.
 */

package org.gradle.internal.event;

import org.gradle.api.Action;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.MethodInvocation;
import org.gradle.internal.dispatch.ProxyDispatchAdapter;

import java.util.Collection;

/**
 * <p>Manages a set of listeners of type T. Provides an implementation of T which can be used to broadcast to all