375 lines
10 KiB
Java
375 lines
10 KiB
Java
package net.minecraft.server.packs.linkfs;
|
|
|
|
import com.google.common.base.Joiner;
|
|
import com.google.common.collect.ImmutableList;
|
|
import com.google.common.collect.ImmutableList.Builder;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.net.URI;
|
|
import java.net.URISyntaxException;
|
|
import java.nio.file.LinkOption;
|
|
import java.nio.file.NoSuchFileException;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.ProviderMismatchException;
|
|
import java.nio.file.ReadOnlyFileSystemException;
|
|
import java.nio.file.WatchKey;
|
|
import java.nio.file.WatchService;
|
|
import java.nio.file.WatchEvent.Kind;
|
|
import java.nio.file.WatchEvent.Modifier;
|
|
import java.nio.file.attribute.BasicFileAttributeView;
|
|
import java.nio.file.attribute.BasicFileAttributes;
|
|
import java.nio.file.attribute.FileTime;
|
|
import java.util.Comparator;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import org.jetbrains.annotations.Nullable;
|
|
|
|
class LinkFSPath implements Path {
|
|
private static final BasicFileAttributes DIRECTORY_ATTRIBUTES = new DummyFileAttributes() {
|
|
public boolean isRegularFile() {
|
|
return false;
|
|
}
|
|
|
|
public boolean isDirectory() {
|
|
return true;
|
|
}
|
|
};
|
|
private static final BasicFileAttributes FILE_ATTRIBUTES = new DummyFileAttributes() {
|
|
public boolean isRegularFile() {
|
|
return true;
|
|
}
|
|
|
|
public boolean isDirectory() {
|
|
return false;
|
|
}
|
|
};
|
|
private static final Comparator<LinkFSPath> PATH_COMPARATOR = Comparator.comparing(LinkFSPath::pathToString);
|
|
private final String name;
|
|
private final LinkFileSystem fileSystem;
|
|
@Nullable
|
|
private final LinkFSPath parent;
|
|
@Nullable
|
|
private List<String> pathToRoot;
|
|
@Nullable
|
|
private String pathString;
|
|
private final PathContents pathContents;
|
|
|
|
public LinkFSPath(LinkFileSystem fileSystem, String name, @Nullable LinkFSPath parent, PathContents pathContents) {
|
|
this.fileSystem = fileSystem;
|
|
this.name = name;
|
|
this.parent = parent;
|
|
this.pathContents = pathContents;
|
|
}
|
|
|
|
private LinkFSPath createRelativePath(@Nullable LinkFSPath parent, String name) {
|
|
return new LinkFSPath(this.fileSystem, name, parent, PathContents.RELATIVE);
|
|
}
|
|
|
|
public LinkFileSystem getFileSystem() {
|
|
return this.fileSystem;
|
|
}
|
|
|
|
public boolean isAbsolute() {
|
|
return this.pathContents != PathContents.RELATIVE;
|
|
}
|
|
|
|
public File toFile() {
|
|
if (this.pathContents instanceof PathContents.FileContents fileContents) {
|
|
return fileContents.contents().toFile();
|
|
} else {
|
|
throw new UnsupportedOperationException("Path " + this.pathToString() + " does not represent file");
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public LinkFSPath getRoot() {
|
|
return this.isAbsolute() ? this.fileSystem.rootPath() : null;
|
|
}
|
|
|
|
public LinkFSPath getFileName() {
|
|
return this.createRelativePath(null, this.name);
|
|
}
|
|
|
|
@Nullable
|
|
public LinkFSPath getParent() {
|
|
return this.parent;
|
|
}
|
|
|
|
public int getNameCount() {
|
|
return this.pathToRoot().size();
|
|
}
|
|
|
|
private List<String> pathToRoot() {
|
|
if (this.name.isEmpty()) {
|
|
return List.of();
|
|
} else {
|
|
if (this.pathToRoot == null) {
|
|
Builder<String> builder = ImmutableList.builder();
|
|
if (this.parent != null) {
|
|
builder.addAll(this.parent.pathToRoot());
|
|
}
|
|
|
|
builder.add(this.name);
|
|
this.pathToRoot = builder.build();
|
|
}
|
|
|
|
return this.pathToRoot;
|
|
}
|
|
}
|
|
|
|
public LinkFSPath getName(int index) {
|
|
List<String> list = this.pathToRoot();
|
|
if (index >= 0 && index < list.size()) {
|
|
return this.createRelativePath(null, (String)list.get(index));
|
|
} else {
|
|
throw new IllegalArgumentException("Invalid index: " + index);
|
|
}
|
|
}
|
|
|
|
public LinkFSPath subpath(int start, int end) {
|
|
List<String> list = this.pathToRoot();
|
|
if (start >= 0 && end <= list.size() && start < end) {
|
|
LinkFSPath linkFSPath = null;
|
|
|
|
for (int i = start; i < end; i++) {
|
|
linkFSPath = this.createRelativePath(linkFSPath, (String)list.get(i));
|
|
}
|
|
|
|
return linkFSPath;
|
|
} else {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
public boolean startsWith(Path path) {
|
|
if (path.isAbsolute() != this.isAbsolute()) {
|
|
return false;
|
|
} else if (path instanceof LinkFSPath linkFSPath) {
|
|
if (linkFSPath.fileSystem != this.fileSystem) {
|
|
return false;
|
|
} else {
|
|
List<String> list = this.pathToRoot();
|
|
List<String> list2 = linkFSPath.pathToRoot();
|
|
int i = list2.size();
|
|
if (i > list.size()) {
|
|
return false;
|
|
} else {
|
|
for (int j = 0; j < i; j++) {
|
|
if (!((String)list2.get(j)).equals(list.get(j))) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public boolean endsWith(Path path) {
|
|
if (path.isAbsolute() && !this.isAbsolute()) {
|
|
return false;
|
|
} else if (path instanceof LinkFSPath linkFSPath) {
|
|
if (linkFSPath.fileSystem != this.fileSystem) {
|
|
return false;
|
|
} else {
|
|
List<String> list = this.pathToRoot();
|
|
List<String> list2 = linkFSPath.pathToRoot();
|
|
int i = list2.size();
|
|
int j = list.size() - i;
|
|
if (j < 0) {
|
|
return false;
|
|
} else {
|
|
for (int k = i - 1; k >= 0; k--) {
|
|
if (!((String)list2.get(k)).equals(list.get(j + k))) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public LinkFSPath normalize() {
|
|
return this;
|
|
}
|
|
|
|
public LinkFSPath resolve(Path path) {
|
|
LinkFSPath linkFSPath = this.toLinkPath(path);
|
|
return path.isAbsolute() ? linkFSPath : this.resolve(linkFSPath.pathToRoot());
|
|
}
|
|
|
|
private LinkFSPath resolve(List<String> names) {
|
|
LinkFSPath linkFSPath = this;
|
|
|
|
for (String string : names) {
|
|
linkFSPath = linkFSPath.resolveName(string);
|
|
}
|
|
|
|
return linkFSPath;
|
|
}
|
|
|
|
LinkFSPath resolveName(String name) {
|
|
if (isRelativeOrMissing(this.pathContents)) {
|
|
return new LinkFSPath(this.fileSystem, name, this, this.pathContents);
|
|
} else if (this.pathContents instanceof PathContents.DirectoryContents directoryContents) {
|
|
LinkFSPath linkFSPath = (LinkFSPath)directoryContents.children().get(name);
|
|
return linkFSPath != null ? linkFSPath : new LinkFSPath(this.fileSystem, name, this, PathContents.MISSING);
|
|
} else if (this.pathContents instanceof PathContents.FileContents) {
|
|
return new LinkFSPath(this.fileSystem, name, this, PathContents.MISSING);
|
|
} else {
|
|
throw new AssertionError("All content types should be already handled");
|
|
}
|
|
}
|
|
|
|
private static boolean isRelativeOrMissing(PathContents pathContents) {
|
|
return pathContents == PathContents.MISSING || pathContents == PathContents.RELATIVE;
|
|
}
|
|
|
|
public LinkFSPath relativize(Path path) {
|
|
LinkFSPath linkFSPath = this.toLinkPath(path);
|
|
if (this.isAbsolute() != linkFSPath.isAbsolute()) {
|
|
throw new IllegalArgumentException("absolute mismatch");
|
|
} else {
|
|
List<String> list = this.pathToRoot();
|
|
List<String> list2 = linkFSPath.pathToRoot();
|
|
if (list.size() >= list2.size()) {
|
|
throw new IllegalArgumentException();
|
|
} else {
|
|
for (int i = 0; i < list.size(); i++) {
|
|
if (!((String)list.get(i)).equals(list2.get(i))) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
return linkFSPath.subpath(list.size(), list2.size());
|
|
}
|
|
}
|
|
}
|
|
|
|
public URI toUri() {
|
|
try {
|
|
return new URI("x-mc-link", this.fileSystem.store().name(), this.pathToString(), null);
|
|
} catch (URISyntaxException var2) {
|
|
throw new AssertionError("Failed to create URI", var2);
|
|
}
|
|
}
|
|
|
|
public LinkFSPath toAbsolutePath() {
|
|
return this.isAbsolute() ? this : this.fileSystem.rootPath().resolve(this);
|
|
}
|
|
|
|
public LinkFSPath toRealPath(LinkOption... options) {
|
|
return this.toAbsolutePath();
|
|
}
|
|
|
|
public WatchKey register(WatchService watchService, Kind<?>[] kinds, Modifier... modifiers) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public int compareTo(Path path) {
|
|
LinkFSPath linkFSPath = this.toLinkPath(path);
|
|
return PATH_COMPARATOR.compare(this, linkFSPath);
|
|
}
|
|
|
|
public boolean equals(Object object) {
|
|
if (object == this) {
|
|
return true;
|
|
} else if (object instanceof LinkFSPath linkFSPath) {
|
|
if (this.fileSystem != linkFSPath.fileSystem) {
|
|
return false;
|
|
} else {
|
|
boolean bl = this.hasRealContents();
|
|
if (bl != linkFSPath.hasRealContents()) {
|
|
return false;
|
|
} else {
|
|
return bl ? this.pathContents == linkFSPath.pathContents : Objects.equals(this.parent, linkFSPath.parent) && Objects.equals(this.name, linkFSPath.name);
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private boolean hasRealContents() {
|
|
return !isRelativeOrMissing(this.pathContents);
|
|
}
|
|
|
|
public int hashCode() {
|
|
return this.hasRealContents() ? this.pathContents.hashCode() : this.name.hashCode();
|
|
}
|
|
|
|
public String toString() {
|
|
return this.pathToString();
|
|
}
|
|
|
|
private String pathToString() {
|
|
if (this.pathString == null) {
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
if (this.isAbsolute()) {
|
|
stringBuilder.append("/");
|
|
}
|
|
|
|
Joiner.on("/").appendTo(stringBuilder, this.pathToRoot());
|
|
this.pathString = stringBuilder.toString();
|
|
}
|
|
|
|
return this.pathString;
|
|
}
|
|
|
|
private LinkFSPath toLinkPath(@Nullable Path path) {
|
|
if (path == null) {
|
|
throw new NullPointerException();
|
|
} else if (path instanceof LinkFSPath linkFSPath && linkFSPath.fileSystem == this.fileSystem) {
|
|
return linkFSPath;
|
|
} else {
|
|
throw new ProviderMismatchException();
|
|
}
|
|
}
|
|
|
|
public boolean exists() {
|
|
return this.hasRealContents();
|
|
}
|
|
|
|
@Nullable
|
|
public Path getTargetPath() {
|
|
return this.pathContents instanceof PathContents.FileContents fileContents ? fileContents.contents() : null;
|
|
}
|
|
|
|
@Nullable
|
|
public PathContents.DirectoryContents getDirectoryContents() {
|
|
return this.pathContents instanceof PathContents.DirectoryContents directoryContents ? directoryContents : null;
|
|
}
|
|
|
|
public BasicFileAttributeView getBasicAttributeView() {
|
|
return new BasicFileAttributeView() {
|
|
public String name() {
|
|
return "basic";
|
|
}
|
|
|
|
public BasicFileAttributes readAttributes() throws IOException {
|
|
return LinkFSPath.this.getBasicAttributes();
|
|
}
|
|
|
|
public void setTimes(FileTime fileTime, FileTime fileTime2, FileTime fileTime3) {
|
|
throw new ReadOnlyFileSystemException();
|
|
}
|
|
};
|
|
}
|
|
|
|
public BasicFileAttributes getBasicAttributes() throws IOException {
|
|
if (this.pathContents instanceof PathContents.DirectoryContents) {
|
|
return DIRECTORY_ATTRIBUTES;
|
|
} else if (this.pathContents instanceof PathContents.FileContents) {
|
|
return FILE_ATTRIBUTES;
|
|
} else {
|
|
throw new NoSuchFileException(this.pathToString());
|
|
}
|
|
}
|
|
}
|