rootProject.name = 'artifact-transforms-relocate'...

rootProject.name = "artifact-transforms-relocate"...

	}

	w.rawUvarint(ux)
}

func (w *Encoder) rawReloc(r RelocKind, idx Index) int {
	e := RelocEnt{r, idx}
	if w.RelocMap != nil {
		if i, ok := w.RelocMap[e]; ok {
			return int(i)
		}
	} else {
		w.RelocMap = make(map[RelocEnt]uint32)
	}

	i := len(w.Relocs)
	w.RelocMap[e] = uint32(i)
	w.Relocs = append(w.Relocs, e)
	return i
}

func (w *Encoder) Sync(m SyncMarker) {

    @Override
    protected String getProductionComponentDsl() {
        return "application"
    }

    @Override
    protected List<String> getRunTestTasks() {
        return [tasks.debug.compile, tasks.test.relocate, tasks.test.allToInstall, ":xcTest"]
    }

    @Override
    protected List<String> getLibDebugTasks() {
        return [tasks(":lib").debug.allToLink]
    }

            } doAnswer {

                val location = it.getArgument<File>(3)
                val className = it.getArgument<String>(4)

                val newLocation = relocate(location)

                DummyCompiledScript(
                    classLoaderFor(newLocation)
                        .also { classLoaders += it }
                        .loadClass(className)
                )

In order to determine the classes to relocate, it looks at the packages of the input artifact and the dependencies of the input artifact.
It also does not relocate packages contained in JAR files in an external classpath.

.Artifact transform for class relocation
====
include::sample[dir="snippets/dependencyManagement/artifactTransforms-relocate/kotlin",files="build.gradle.kts[tags=artifact-transform-relocate]"]

        return absolutePath;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Optional<? extends FileSystemLocationSnapshot> relocate(String targetPath, Interner<String> interner) {
        if (accessType == AccessType.VIA_SYMLINK) {
            return Optional.empty();
        }
        String internedTargetPath = interner.intern(targetPath);

     * - re-snapshot relocated locations pointed to by snapshots,
     * - a combination of the two.
     */
    Optional<? extends FileSystemLocationSnapshot> relocate(String targetPath, Interner<String> interner);

    /**
     * The hash of the snapshot.
     *
     * This makes it possible to uniquely identify the snapshot.
     * <dl>
     *     <dt>Directories</dt>

    @RequiresInstalledToolChain(ToolChainRequirement.VISUALCPP)
    @Issue("https://github.com/gradle/gradle-native/issues/277")
    @ToBeFixedForConfigurationCache
    def "can relocate Windows specific _wmain symbol"() {
        makeSingleProject()
        file("src/main/cpp/main.cpp") << """
            #include <iostream>

            int wmain(int argc, wchar_t *argv[], wchar_t *envp[] ) {

                        if (literal == null) {
                            // tries to relocate literals in the form of foo/bar/Bar
                            literal = remapper.maybeRelocateResource((String) cst);
                        }
                        if (literal == null) {
                            // tries to relocate literals in the form of foo.bar.Bar