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

  if (this is QueueDispatcher) return this.delegate

  val delegate = this
  return object : mockwebserver3.Dispatcher() {
    override fun dispatch(request: mockwebserver3.RecordedRequest): mockwebserver3.MockResponse {
      return delegate.dispatch(request.unwrap()).wrap()
    }

    override fun peek(): mockwebserver3.MockResponse {
      return delegate.peek().wrap()
    }

    override fun shutdown() {

            if (connection == null) {
                continue;
            }
            try {
                LOGGER.debug("Requesting daemon {} stop when idle", daemon);
                stopDispatcher.dispatch(connection, new StopWhenIdle(idGenerator.generateId(), connection.getDaemon().getToken()));
                LOGGER.lifecycle("Gradle daemon stopped.");
            } finally {
                connection.stop();
            }

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

/**
 * Creates a proxy object which sets the context ClassLoader when invoking methods on the target object.
 */
public class ContextClassLoaderProxy<T> {
    private final ProxyDispatchAdapter<T> adapter;

 * 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 javax.annotation.Nullable;

/**
 * A source for messages. Implementations do not have to be thread-safe.
 */
public interface Receive<T> {
    /**

 * 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 DispatchFailureHandler<T> {
    /**
     * Called when a message could not be dispatched. This method can throw an exception to abort further dispatching.
     */

 *
 * @since 8.6
 */
public interface InternalStreamedValueRelay {
    /**
     * Asynchronously sends an object back to the client application.
     *
     * @since 8.6
     */
    void dispatch(Object value);

/**
 * A decorated domain object type may optionally implement this interface to dynamically expose properties 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 properties. That is, methods such as propertyMissing() will be ignored.
 */
public interface PropertyMixIn {
    PropertyAccess getAdditionalProperties();

 * limitations under the License.
 */

package org.gradle.initialization;

public class NoOpBuildEventConsumer implements BuildEventConsumer {
    @Override
    public void dispatch(Object message) {
    }

        return listOfNotNull(
            smartCastedImplicitReceiver(firQualifiedExpression, KaImplicitReceiverSmartCastKind.DISPATCH),
            smartCastedImplicitReceiver(firQualifiedExpression, KaImplicitReceiverSmartCastKind.EXTENSION),
        )
    }

    private fun smartCastedImplicitReceiver(