import org.gradle.tooling.internal.provider.serialization.SerializedPayload;

import java.io.Serializable;

/**
 * Result of one of the actions of a phased action. Must be serializable since will be dispatched to client.
 */
public class PhasedBuildActionResult implements Serializable {
    public final SerializedPayload result;
    public final PhasedActionResult.Phase phase;

		}

		init = append(init, r)
	}

	if dflt != nil {
		ir.SetPos(dflt)
		dispatch(ir.NewBinaryExpr(base.Pos, ir.OLT, chosen, ir.NewInt(base.Pos, 0)), dflt)
	}
	for i, cas := range casorder {
		ir.SetPos(cas)
		if i == len(casorder)-1 {
			dispatch(nil, cas)
			break
		}
		dispatch(ir.NewBinaryExpr(base.Pos, ir.OEQ, chosen, ir.NewInt(base.Pos, int64(i))), cas)
	}

	return init
}

 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub

import org.gradle.api.GradleException
import org.gradle.internal.dispatch.MethodInvocation
import org.gradle.internal.dispatch.StreamCompletion
import org.gradle.internal.remote.internal.ConnectCompletion
import org.gradle.internal.remote.internal.TestConnection

   */
  @Throws(IOException::class)
  fun execute(): Response

  /**
   * Schedules the request to be executed at some point in the future.
   *
   * The [dispatcher][OkHttpClient.dispatcher] defines when the request will run: usually
   * immediately unless there are several other requests currently being executed.
   *

        def outgoingMessage = new ChannelMessage(channel, "payload")

        given:
        def incoming = incomingQueue.getChannel(channel).newEndpoint()
        outgoingQueue.dispatch(outgoingMessage)

        when:
        connections.noFurtherConnections()
        def messages = []
        incoming.take(messages)

        then:
        messages.size() == 2

 * 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;

public class DispatchException extends RuntimeException {
    public DispatchException(String message, Throwable cause) {
        super(message, cause);
    }

import javax.annotation.Nullable;

@NonNullApi
public class InstrumentedGroovyCallsHelper {
    /**
     * Executes the given {@code callable} in the context of an entry point produced from entering a dynamically dispatched
     * call described by the {@code callableName} and {@code kind}
     * from a class identified by {@code consumerClass}.

	// If not specified, the carp will not have a domainname at all.
	// +optional
	Subdomain string
	// If specified, the carp will be dispatched by specified scheduler.
	// If not specified, the carp will be dispatched by default scheduler.
	// +optional
	SchedulerName string
}

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

// CarpList is a list of Carps.

    val connection = server.url("/").toUrl().openConnection() as HttpURLConnection
    connection.readTimeout = 500
    try {
      connection.responseCode
      fail<Unit>()
    } catch (expected: SocketTimeoutException) {
      // Expected.
    }

    // Shutting down the server should unblock the dispatcher.
    server.shutdown()
  }

  @Test

 * 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;

public interface StreamCompletion {
    /**
     * Signals the end of the stream of messages.
     */
    void endStream();