* limitations under the License.
 */

package org.gradle.internal;

import java.util.Collection;

public interface RelativePathSupplier {
    boolean isRoot();

    Collection<String> getSegments();

    String toRelativePath();

        return relativePath;
    }

    public File getBaseDir() {
        if (file == null || relativePath == null) {
            return null;
        }
        int relativeSegments = relativePath.getSegments().length;
        File parentFile = file;
        for (int i=0; i<relativeSegments; i++) {
            parentFile = parentFile.getParentFile();
        }
        return parentFile;
    }

    }

    @Override
    public void execute(FileCopyDetails details) {
        RelativePath relativeSourcePath = details.getRelativeSourcePath();
        if (matcher.test(relativeSourcePath.getSegments(), relativeSourcePath.isFile())) {
            toApply.execute(details);
        }
    }

        this.matcher = matcher;
    }

    @Override
    public boolean isSatisfiedBy(FileTreeElement element) {
        RelativePath relativePath = element.getRelativePath();
        return matcher.test(relativePath.getSegments(), relativePath.isFile());
    }

            rootName = null;
        }
        return name;
    }

    @Override
    public boolean isRoot() {
        return segments.isEmpty();
    }

    @Override
    public Collection<String> getSegments() {
        return segments;
    }

    /**
     * Returns the relative path using '{@literal /}' as the separator.
     */
    @Override
    public String toRelativePath() {

        @Override
        public SymbolicLinkMapping withNewMapping(String source, String target, RelativePathTracker currentPathTracker) {
            return new DefaultSymbolicLinkMapping(source, target, currentPathTracker.getSegments());
        }

        @Override
        public Iterable<String> getRemappedSegments(Iterable<String> segments) {
            return segments;
        }
    };

    private final FileHasher hasher;

            boolean root = relativePath.isRoot();
            Iterable<String> relativePathForFiltering = root
                ? ImmutableList.of(snapshot.getName())
                : relativePath.getSegments();
            SnapshotVisitResult result;
            boolean forceInclude = snapshot.accept(new FileSystemLocationSnapshotTransformer<Boolean>() {
                @Override

    public RelativePath getRelativePath() {
        if (relativePath == null) {
            RelativePath path = fileDetails.getRelativePath();
            relativePath = specResolver.getDestPath().append(path.isFile(), path.getSegments());
        }
        return relativePath;
    }

    @Override
    public FilePermissions getPermissions() {
        if (permissions != null) {
            return permissions;
        }

import static org.junit.Assert.assertEquals;

public class RelativePathTest {

    private void assertPathContains(RelativePath path, boolean isFile, String... expectedSegments) {
        String[] actualPaths = path.getSegments();
        assertArrayEquals(expectedSegments, actualPaths);
        assertEquals(isFile, path.isFile());
    }

    @Test
    public void testConstructors() {
        RelativePath path;

        // 1: [variant:tapi]
        // 2: [spec:org.gradle.kotlin.dsl.tooling.builders.r54.KotlinSettingsScriptModelCrossVersionSpec]
        // 3: [feature:$spock_feature_2_0]
        List<UniqueId.Segment> segments = uniqueId.getSegments();

        if (toolingApiVersionToLoad != null && segments.size() >= 3 && isVariantSelected(segments.get(1))) {
            String classToLoad = segments.get(2).getValue();
            try {