Package edu.uiuc.ncsa.qdl.vfs
Class VFSPaths
- java.lang.Object
-
- edu.uiuc.ncsa.qdl.vfs.VFSPaths
-
public class VFSPaths extends Object
This is compatible with thePath
interface but does not implement it. The reason is that whileFileSystem
is really slick, policies for accessing files are set by the security manager per JVM. So, if this code is to run on a server with restricted access to the real file system (but access its own virtual mounts) we have to restrict access for the entire JVM which means that the server can no longer function, at least without very specific configuration which is going to be hard for others to do. As such until something changes, we can't actually use the Java stuff, which, to be fair, is made so that Java developers have seamless access to various file systems.
A path in the store is of the formscheme#/a/b/c/d (absolute) scheme#p/q/r (relative)
as such these are almost uris. The problem with using a URI vs this is that we must have a scheme at all times to tell us which store this goes in and relative uris do not have schemes. No scheme (which probably should include#/a/b/c
) means native file.Created by Jeff Gaynor
on 2/29/20 at 7:03 AM
-
-
Field Summary
Fields Modifier and Type Field Description static String
PARENT_COMPONENT
static String
PATH_SEPARATOR
static String
SCHEME_DELIMITER
static String
THIS_COMPONENT
-
Constructor Summary
Constructors Constructor Description VFSPaths()
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description static boolean
checkScheme(String scheme, String path)
Check is a path has this scheme.static int
compareTo(String path, String other)
Lexically compares two paths without schemes.static boolean
endsWith(String path, String other)
Does this path end with the other? E.g.static boolean
equals(String path1, String path2)
Compares two paths.static String
getComponentAt(String path, int index)
Returns the path component at the given index.static String
getFileName(String path)
static String
getParentPath(String path)
int
getPathComponentCount(String path)
The number of components in this path.static String
getScheme(String path)
Returns the scheme for this path or an empty string if there is none.static String
getUnqPath(String fqPath)
Takes a fully qualified path and returns the path without the schemestatic boolean
hasSameScheme(String path1, String path2)
Check if two paths have the same schemestatic boolean
isAbsolute(String path)
Returns if this path is absolute, i.e.static boolean
isUnq(String path)
Is this path unqualified? I.e., there is no schemestatic boolean
isVFSPath(String path)
static void
main(String[] args)
static String
normalize(String path)
Removes redundant path components.static String
relativize(String path, String other)
Attempts to relativize the other path against the path.static String
resolve(String path, String relativePath)
Resolves the relativePath against the path.static String
resolveSibling(String path, String other)
This resolves the other against the parent of the path -- making them siblings, i.e.static boolean
startsWith(String path, String other)
Does the path start with the other path? So if path=A#/a/b/c/d and other=B#/a/b the answer is true.static String
subpath(String path, int beginIndex, int endIndex)
Returns a subpath of components.static String[]
toPathComponents(String path)
Return the un-normalized components of this path.
-
-
-
Method Detail
-
isVFSPath
public static boolean isVFSPath(String path)
-
checkScheme
public static boolean checkScheme(String scheme, String path)
Check is a path has this scheme. True if so, false if not- Parameters:
scheme
-path
-- Returns:
-
hasSameScheme
public static boolean hasSameScheme(String path1, String path2)
Check if two paths have the same scheme- Parameters:
path1
-path2
-- Returns:
-
isUnq
public static boolean isUnq(String path)
Is this path unqualified? I.e., there is no scheme- Parameters:
path
-- Returns:
-
getScheme
public static String getScheme(String path)
Returns the scheme for this path or an empty string if there is none.- Parameters:
path
-- Returns:
-
isAbsolute
public static boolean isAbsolute(String path)
Returns if this path is absolute, i.e. if it starts with the path separator. So A#/a/b/c is absolute, A#b/c is not.
An absolute path contains enough information to find the file. A relative path does not. This will compare them ignoring schemes.- Parameters:
path
-- Returns:
-
getUnqPath
public static String getUnqPath(String fqPath)
Takes a fully qualified path and returns the path without the scheme- Parameters:
fqPath
-- Returns:
-
getPathComponentCount
public int getPathComponentCount(String path)
The number of components in this path. Note that this does not, e.g.normalize(String)
this path first so if that is an issue, normalize first.- Parameters:
path
-- Returns:
-
toPathComponents
public static String[] toPathComponents(String path)
Return the un-normalized components of this path. So A#a/b/c would return the array{"a","b","c"}
, as would the relative path a/b/c.- Parameters:
path
-- Returns:
-
getComponentAt
public static String getComponentAt(String path, int index)
Returns the path component at the given index. SoA#a/b/c
and index = 1 returns "b".- Parameters:
path
-index
-- Returns:
-
subpath
public static String subpath(String path, int beginIndex, int endIndex)
Returns a subpath of components. This is FQ if the argument was/- Parameters:
beginIndex
-endIndex
-- Returns:
-
startsWith
public static boolean startsWith(String path, String other)
Does the path start with the other path? So if path=A#/a/b/c/d and other=B#/a/b the answer is true. Note that the paths are compared here, not the schemes so you can use this when comparing paths in different stores.- Parameters:
path
-other
-- Returns:
-
endsWith
public static boolean endsWith(String path, String other)
Does this path end with the other? E.g. path=A#/a/b/c/d other=B#c/d would return true.- Parameters:
path
-other
-- Returns:
-
normalize
public static String normalize(String path)
Removes redundant path components.- Parameters:
path
-- Returns:
-
resolve
public static String resolve(String path, String relativePath)
Resolves the relativePath against the path. So if path=A#/a/b/c and relativePath=B#q/r then this returns A#/a/b/c/q/r. Note two edge cases. If the relativePath is actually absolute, this will return that. If the relativePath is trivial, the path is returned. In point of fact
relativize(p,resolve(p,q)).equals(q)
as long as they have the same scheme (or the relative path gets the scheme of the path).- Parameters:
path
-relativePath
-- Returns:
-
resolveSibling
public static String resolveSibling(String path, String other)
This resolves the other against the parent of the path -- making them siblings, i.e. in the same directory. So if path=A#/a/b/c/d and other=q the result is A#/a/b/c/q, i.e., d and q are now siblings in the directory A#/a/b/c.- Parameters:
path
-other
-- Returns:
-
relativize
public static String relativize(String path, String other)
Attempts to relativize the other path against the path. So if path=/a/b other=/a/b/c/d then this returns c/d. In point of fact
relativize(p,resolve(p,q)).equals(q)
as long as they have the same scheme (or the relative path gets the scheme of the path).- Parameters:
path
-other
-- Returns:
-
compareTo
public static int compareTo(String path, String other)
Lexically compares two paths without schemes. This returns a 0 (zero) if they are equal. This may not make much sense if they are in different schemes, but it does allow to see when two paths are otherwise equal.- Parameters:
path
-other
-- Returns:
-
equals
public static boolean equals(String path1, String path2)
Compares two paths. These are equal if their schemes are equal and their normalizations are.- Parameters:
path1
-path2
-- Returns:
-
-