import org.gradle.cache.scopes.BuildTreeScopedCacheBuilderFactory;
import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory;
import org.gradle.internal.file.Chmod;
import org.gradle.internal.id.UniqueId;
import org.gradle.internal.service.Provides;
import org.gradle.internal.service.ServiceRegistrationProvider;

public class ScopeIdsServices implements ServiceRegistrationProvider {

    @Provides

        realizeOps.last().details.eager == true
        def uniqueId = Iterables.getOnlyElement(realizeOps*.details*.taskId as Set)

        when:
        configurationCacheRun(":foo")
        then:
        def realizeOp = buildOperations.only(RealizeTaskBuildOperationType)
        with(realizeOp.details) {
            taskPath == ":foo"
            taskId == uniqueId
            eager == true
        }
    }

    private final UniqueId buildInvocationScopeId;
    private final OutputSnapshotter outputSnapshotter;
    private final AfterExecutionOutputFilter<? super C> outputFilter;
    private final Step<? super C, ? extends Result> delegate;

    public CaptureOutputsAfterExecutionStep(
        BuildOperationRunner buildOperationRunner,
        UniqueId buildInvocationScopeId,

        val taskType = readClassOf<Task>()
        val projectPath = readString()
        val taskName = readString()
        val uniqueId = readLong()
        val incompatibleReason = readNullableString()

        val task = createTask(projectPath, taskName, taskType, uniqueId, incompatibleReason)

        withTaskOf(taskType, task, userTypesCodec) {
            readUpToDateSpec(task)

	UserAgent    string
}

// ToEvent - converts to notification event.
func (args eventArgs) ToEvent(escape bool) event.Event {
	eventTime := UTCNow()
	uniqueID := fmt.Sprintf("%X", eventTime.UnixNano())
	if !args.Object.ModTime.IsZero() {
		uniqueID = fmt.Sprintf("%X", args.Object.ModTime.UnixNano())
	}

	respElements := map[string]string{
		"x-amz-request-id": args.RespElements["requestId"],

import org.gradle.internal.buildtree.BuildTreeState;
import org.gradle.internal.buildtree.RunTasksRequirements;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hashing;
import org.gradle.internal.id.UniqueId;
import org.gradle.internal.invocation.BuildAction;
import org.gradle.internal.scopeids.id.BuildInvocationScopeId;
import org.gradle.internal.session.BuildSessionActionExecutor;

import org.gradle.internal.execution.timeout.TimeoutHandler;
import org.gradle.internal.file.Deleter;
import org.gradle.internal.hash.ClassLoaderHierarchyHasher;
import org.gradle.internal.id.UniqueId;
import org.gradle.internal.operations.BuildOperationProgressEventEmitter;
import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.operations.CurrentBuildOperationRef;

import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.composite.IncludedBuildInternal;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.id.UniqueId;
import org.gradle.internal.logging.services.LoggingServiceRegistry;
import org.gradle.internal.nativeintegration.services.NativeServices;
import org.gradle.internal.nativeintegration.services.NativeServices.NativeServicesMode;

        });
    }

    @Override
    public <T extends Task> T createWithoutConstructor(String name, Class<T> type, long uniqueId) {
        assertMutable("createWithoutConstructor(String, Class, Object...)");
        return doCreate(taskIdentityFactory.recreate(name, type, project, uniqueId), null, Actions.doNothing());
    }

    @Override
    public Task findByPath(String path) {
        Path.validatePath(path);

		if v, err := base64.StdEncoding.DecodeString(userDefined[ReplicationSsecChecksumHeader]); err == nil {
			fi.Checksum = v
		}
	}
	delete(userDefined, ReplicationSsecChecksumHeader)
	uniqueID := mustGetUUID()
	tempObj := uniqueID

	// Initialize erasure metadata.
	for index := range partsMetadata {
		partsMetadata[index] = fi
	}

	// Order disks according to erasure distribution