import org.gradle.internal.RelativePathSupplier;

import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
import java.util.Iterator;

/**
 * Tracks the relative path. Useful when visiting {@link FileSystemLocationSnapshot}s.
 */
public class RelativePathTracker implements RelativePathSupplier {
    private final Deque<String> segments = new ArrayDeque<>();
    private String rootName;

     *
     * @param options : 'type' and 'classifier'
     */
    ModuleArtifact getArtifact(Map<String, ?> options)

    /**
     * Returns a file relative to this module, using a relative path.
     */
    ModuleArtifact getArtifact(String relativePath)

    TestFile getArtifactFile()

    TestFile getArtifactFile(Map options)

    TestFile getMetaDataFile()

 */
package org.apache.maven.api.services.model;

import java.nio.file.Path;

import org.apache.maven.api.model.Model;
import org.apache.maven.api.services.ModelBuilderRequest;

/**
 * Resolves relative paths of a model against a specific base directory.
 *
 */
public interface ModelPathTranslator {

    /**
     * Resolves the well-known paths of the specified model against the given base directory. Paths within plugin

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api.services.model;

import java.nio.file.Path;

/**
 * Resolves relative paths against a specific base directory.
 *
 */
public interface PathTranslator {

    /**
     * Resolves the specified path against the given base directory. The resolved path will be absolute and uses the

            throw new UnsupportedOperationException(String.format("Cannot convert relative path %s to an absolute file.", path));
        }
        return file;
    }

    @Override
    public String resolveAsRelativePath(Object path) {
        throw new UnsupportedOperationException(String.format("Cannot convert path %s to a relative path.", path));
    }

    @Override
    public boolean canResolveRelativePath() {

	runtime.SetFinalizer(file, nil)
	return err
}

// seek sets the offset for the next Read or Write on file to offset, interpreted
// according to whence: 0 means relative to the origin of the file, 1 means
// relative to the current offset, and 2 means relative to the end.
// It returns the new offset and an error, if any.
func (f *File) seek(offset int64, whence int) (ret int64, err error) {
	if info := f.dirinfo.Swap(nil); info != nil {

# Regression test for issue #48557.
# Since builds in module mode do not support relative imports at all, the build
# ID for (and other contents of) a binary built with -trimpath in module mode
# should not depend on its working directory, even if the binary is specified as
# a list of relative source files.

[short] skip  # links and runs binaries

env GOFLAGS=-trimpath
env GOCACHE=$WORK/gocache

        def location = tmpDir.createDir("dir")

        expect:
        def dir = factory.dir(location)
        dir.asFile == location
    }

    def "can create directory instance from relative file"() {
        def location = projectDir.createDir("dir")

        expect:
        def dir = factory.dir(new File("dir"))
        dir.asFile == location
    }

		cwd = UncachedCwd()
	})
	return cwd
}

// ShortPath returns an absolute or relative name for path, whatever is shorter.
func ShortPath(path string) string {
	if rel, err := filepath.Rel(Cwd(), path); err == nil && len(rel) < len(path) {
		return rel
	}
	return path
}

// RelPaths returns a copy of paths with absolute paths
// made relative to the current directory if they would be shorter.
func RelPaths(paths []string) []string {

//
// The arctangent ranges from -PI to +PI.
//
// ACCURACY:
//
//                      Relative error:
// arithmetic   domain     # trials      peak         rms
//    DEC       -10,+10      7000       8.5e-17     1.9e-17
//    IEEE      -10,+10     30000       5.0e-15     1.1e-16
//
// Larger relative error can be observed for z near 1 +i0.
// In IEEE arithmetic the peak absolute error is 5.2e-16, rms