*/
@NonNullApi
public class ExternalResourceName implements Describable {
    @Nullable
    private final String encodedRoot;
    private final String path;
    private final String encodedQuery;

    public ExternalResourceName(URI uri) {
        this(encodeRoot(uri), extractPath(uri), extractQuery(uri));
    }

    public ExternalResourceName(String path) {
        this(null, path, "");
    }

    @Nullable
    @Override
    public <T> T withContent(ExternalResourceName location, boolean revalidate, ExternalResource.ContentAndMetadataAction<T> action) throws ResourceException {
        return buildOperationRunner.call(new DownloadOperation<>(location, revalidate, action));
    }

    @Override
    @Nullable
    public ExternalResourceMetaData getMetaData(ExternalResourceName location, boolean revalidate) {

        if (startParameter.isOffline) {
            true
        } else {
            val externalResourceName = ExternalResourceName(uri)

            val cached = cachedExternalResourceIndex.lookup(externalResourceName.toString())
            val remoteMetaData = externalResourceConnector.getMetaData(externalResourceName, true)

    @NonNullApi
    private static class SnapshotMetadataResult {
        public final ExternalResourceName snapshotMetadataPath;
        public final Metadata snapshotMetadata;

        public SnapshotMetadataResult(ExternalResourceName snapshotMetadataPath, Metadata snapshotMetadata) {

        def name = new ExternalResourceName(URI.create("http://host"), "a/b/c")
        def same = new ExternalResourceName(URI.create("http://host"), "a/b/c")
        def samePath = new ExternalResourceName(URI.create("http://host/a/b"), "c")
        def differentRoot = new ExternalResourceName(URI.create("http://other"), "a/b/c")
        def differentPath = new ExternalResourceName(URI.create("http://host"), "x/y/z")

    };

    private class ListOperation implements CallableBuildOperation<List<String>> {
        private final ExternalResourceName parent;

        public ListOperation(ExternalResourceName parent) {
            this.parent = parent;
        }

        @Override
        public List<String> call(BuildOperationContext context) {
            try {

import org.gradle.cache.internal.ProducerGuard
import org.gradle.internal.hash.Hashing
import org.gradle.internal.resource.ExternalResource
import org.gradle.internal.resource.ExternalResourceName
import org.gradle.internal.resource.ExternalResourceReadResult
import org.gradle.internal.resource.ExternalResourceRepository
import org.gradle.internal.resource.cached.CachedExternalResource

    public AbstractResourcePattern(String pattern) {
        this(new ExternalResourceName(pattern));

    }

    public AbstractResourcePattern(URI baseUri, String pattern) {
        this(new ExternalResourceName(baseUri, pattern));
    }

    private AbstractResourcePattern(ExternalResourceName pattern) {
        this.pattern = pattern;

        }
    }

    private class UploadOperation implements RunnableBuildOperation {
        private final ExternalResourceName destination;
        private final ReadableContent resource;

        public UploadOperation(ExternalResourceName destination, ReadableContent resource) {
            this.destination = destination;
            this.resource = resource;
        }

        @Override

    LocallyAvailableExternalResource resource(File file, URI originUri, ExternalResourceMetaData originMetadata);

    @Override
    LocallyAvailableExternalResource resource(ExternalResourceName resource);

    @Override
    LocallyAvailableExternalResource resource(ExternalResourceName resource, boolean revalidate);