* limitations under the License.
 */

package org.gradle.tooling.events.internal;

import org.gradle.tooling.events.OperationDescriptor;
import org.gradle.tooling.events.StartEvent;

/**
 * Base implementation of the {@code StartEvent} interface.
 */
public class DefaultStartEvent extends BaseProgressEvent implements StartEvent {

    public DefaultStartEvent(long eventTime, String displayName, OperationDescriptor descriptor) {

 * </ul>
 *
 * <p>All implementations of this interface are required to be thread safe.</p>
 *
 * @since 2.1
 */
public interface CancellationTokenSource {
    /**
     * Initiates cancel request. All operations that have been associated with this token will be cancelled.
     *
     * <p>It is assumed that the implementation will do 'best-effort' attempt to perform cancellation.

 *
 * @author Louis Wasserman
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
final class SortedMultisets {
  private SortedMultisets() {}

  /** A skeleton implementation for {@link SortedMultiset#elementSet}. */
  @SuppressWarnings("JdkObsolete") // TODO(b/6160855): Switch GWT emulations to NavigableSet.
  static class ElementSet<E extends @Nullable Object> extends Multisets.ElementSet<E>

import java.util.Collections;
import java.util.Iterator;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A utility for testing an Iterator implementation by comparing its behavior to that of a "known
 * good" reference implementation. In order to accomplish this, it's important to test a great
 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Implementation of ImmutableMap backed by a JDK HashMap, which has smartness protecting against
 * hash flooding.
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault

 * One notable exception is the computation of the early {@code session.rootDirectory}
 * property which happens very early.  The implementation used in this case
 * will be discovered using the JDK service mechanism.
 *
 * The default implementation will look for a {@code .mvn} child directory
 * or a {@code pom.xml} containing the {@code root="true"} attribute.
 */
public interface RootLocator {

     */
    @Override
    Set<? extends Task> getDependencies(@Nullable Task task);

    /**
     * This function is intended for calling from the Gradle implementation code. The implementation of this function should not perform
     * any validation that is specific to calls from third-party code.
     *

import org.gradle.api.problems.internal.Problem;
import org.gradle.api.problems.internal.ProblemEmitter;
import org.gradle.internal.operations.OperationIdentifier;

import javax.annotation.Nullable;

/**
 * Worker-side implementation of {@link ProblemEmitter}.
 * <p>
 * This emitter will use the {@link WorkerProblemProtocol} to communicate problems to the daemon.
 */
@NonNullApi
public class WorkerProblemEmitter implements ProblemEmitter {

import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to a service implementation to indicate that the instance should be registered as a listener.
 *
 * <p>Generally, it is better to use {@link StatefulListener}, which is lazy and applies some validation to ensure no events are missed.
 */

import org.gradle.tooling.provider.model.ToolingModelBuilder;

@NonNullApi
public interface GradleProjectBuilderInternal extends ToolingModelBuilder {

    /**
     * Builds a structural implementation of the {@link org.gradle.tooling.model.GradleProject} model
     * for the root project of a given project.
     *
     * @param project used to discover the root project to build the model for
     */