Examples of java.nio.file.FileSystem

java.nio.file.FileSystem
Provides an interface to a file system and is the factory for objects to access files and other objects in the file system.
The default file system, obtained by invoking the {@link FileSystems#getDefault FileSystems.getDefault} method, provides access to the file system that isaccessible to the Java virtual machine. The {@link FileSystems} class definesmethods to create file systems that provide access to other types of (custom) file systems.
A file system is the factory for several types of objects:
- The {@link #getPath getPath} method converts a system dependentpath string, returning a {@link Path} object that may be usedto locate and access a file.
- The {@link #getPathMatcher getPathMatcher} method is usedto create a {@link PathMatcher} that performs match operations onpaths.
- The {@link #getFileStores getFileStores} method returns an iteratorover the underlying {@link FileStore file-stores}.
- The {@link #getUserPrincipalLookupService getUserPrincipalLookupService}method returns the {@link UserPrincipalLookupService} to lookup users orgroups by name.
- The {@link #newWatchService newWatchService} method creates a{@link WatchService} that may be used to watch objects for changes andevents.
File systems vary greatly. In some cases the file system is a single hierarchy of files with one top-level root directory. In other cases it may have several distinct file hierarchies, each with its own top-level root directory. The {@link #getRootDirectories getRootDirectories} method may beused to iterate over the root directories in the file system. A file system is typically composed of one or more underlying {@link FileStore file-stores}that provide the storage for the files. Theses file stores can also vary in the features they support, and the file attributes or meta-data that they associate with files.
A file system is open upon creation and can be closed by invoking its {@link #close() close} method. Once closed, any further attempt to accessobjects in the file system cause {@link ClosedFileSystemException} to bethrown. File systems created by the default {@link FileSystemProvider provider}cannot be closed.
A {@code FileSystem} can provide read-only or read-write access to thefile system. Whether or not a file system provides read-only access is established when the {@code FileSystem} is created and can be tested by invokingits {@link #isReadOnly() isReadOnly} method. Attempts to write to file storesby means of an object associated with a read-only file system throws {@link ReadOnlyFileSystemException}.
File systems are safe for use by multiple concurrent threads. The {@link #close close} method may be invoked at any time to close a file system butwhether a file system is asynchronously closeable is provider specific and therefore unspecified. In other words, if a thread is accessing an object in a file system, and another thread invokes the {@code close} methodthen it may require to block until the first operation is complete. Closing a file system causes all open channels, watch services, and other {@link Closeable closeable} objects associated with the file system to be closed. @since 1.7

        return new File(test).toPath();
    }


    public static PathMatcher getMatcher(final String rawpattern)
    {
        FileSystem fs = FileSystems.getDefault();
        
        String pattern = rawpattern;
        
        // Strip trailing slash (if present)
        int lastchar = pattern.charAt(pattern.length() - 1);
        if (lastchar == '/' || lastchar == '\\')
        {
            pattern = pattern.substring(0,pattern.length() - 1);
        }


        // If using FileSystem.getPathMatcher() with "glob:" or "regex:"
        // use FileSystem default pattern behavior
        if (pattern.startsWith("glob:") || pattern.startsWith("regex:"))
        {
            StartLog.debug("Using Standard " + fs.getClass().getName() + " pattern: " + pattern);
            return fs.getPathMatcher(pattern);
        }


        // If the pattern starts with a root path then its assumed to
        // be a full system path
        if (isAbsolute(pattern))
        {
            String pat = "glob:" + pattern;
            StartLog.debug("Using absolute path pattern: " + pat);
            return fs.getPathMatcher(pat);
        }


        // Doesn't start with filesystem root, then assume the pattern
        // is a relative file path pattern.
        String pat = "glob:**/" + pattern;
        StartLog.debug("Using relative path pattern: " + pat);
        return fs.getPathMatcher(pat);
    }

View Full Code Here

     * Returns true if any of the files appear to be stored in NFS (or we
     * can't tell).
     */
    private boolean mightUseNFS(File... files) {
        try {
            FileSystem fileSystem = FileSystems.getDefault();
            for (File file: files) {
                Path path = fileSystem.getPath(file.getAbsolutePath());
                String fileStoreType = Files.getFileStore(path).type();
                if (fileStoreType.toLowerCase().contains("nfs")) {
                    return true;
                }
            }

View Full Code Here


    public static void initialize() {
        getEnvVars();
        // set the standard vars defined by R
        String rHome = rHome();
        FileSystem fileSystem = FileSystems.getDefault();
        envVars.put("R_DOC_DIR", fileSystem.getPath(rHome, "doc").toString());
        envVars.put("R_INCLUDE_DIR", fileSystem.getPath(rHome, "include").toString());
        envVars.put("R_SHARE_DIR", fileSystem.getPath(rHome, "share").toString());


        if (!RCmdOptions.NO_ENVIRON.getValue()) {
            String siteFile = envVars.get("R_ENVIRON");
            if (siteFile == null) {
                siteFile = fileSystem.getPath(rHome, "etc", "Renviron.site").toString();
            }
            if (new File(siteFile).exists()) {
                safeReadEnvironFile(siteFile);
            }
            String userFile = envVars.get("R_ENVIRON_USER");
            if (userFile == null) {
                String dotRenviron = ".Renviron";
                userFile = fileSystem.getPath(RFFIFactory.getRFFI().getBaseRFFI().getwd(), dotRenviron).toString();
                if (!new File(userFile).exists()) {
                    userFile = fileSystem.getPath(System.getProperty("user.home"), dotRenviron).toString();
                }
            }
            if (userFile != null && new File(userFile).exists()) {
                safeReadEnvironFile(userFile);
            }

View Full Code Here

            }
            if (lenTo < 1) {
                return RDataFactory.createLogicalVector(0);
            }
            int len = lenFrom > lenTo ? lenFrom : lenTo;
            FileSystem fileSystem = FileSystems.getDefault();
            byte[] status = new byte[len];
            for (int i = 0; i < len; i++) {
                String from = vecFrom.getDataAt(i % lenFrom);
                String to = vecTo.getDataAt(i % lenTo);
                if (RRuntime.isNA(from) || RRuntime.isNA(to)) {
                    status[i] = RRuntime.LOGICAL_FALSE;
                } else {
                    Path fromPath = fileSystem.getPath(Utils.tildeExpand(from));
                    Path toPath = fileSystem.getPath(Utils.tildeExpand(to));
                    status[i] = RRuntime.LOGICAL_TRUE;
                    try {
                        if (symbolic) {
                            Files.createSymbolicLink(toPath, fromPath);
                        } else {

View Full Code Here

        public abstract static class PathFunction {
            protected abstract String invoke(FileSystem fileSystem, String name);
        }


        protected RStringVector doXyzName(RAbstractStringVector vec, PathFunction fun) {
            FileSystem fileSystem = FileSystems.getDefault();
            boolean complete = RDataFactory.COMPLETE_VECTOR;
            String[] data = new String[vec.getLength()];
            for (int i = 0; i < data.length; i++) {
                String name = vec.getDataAt(i);
                if (RRuntime.isNA(name)) {

View Full Code Here


    @Specialization
    protected RStringVector doNormalizePath(RAbstractStringVector pathVec, @SuppressWarnings("unused") String winslash, byte mustWork) {
        controlVisibility();
        String[] results = new String[pathVec.getLength()];
        FileSystem fileSystem = FileSystems.getDefault();
        for (int i = 0; i < results.length; i++) {
            String path = pathVec.getDataAt(i);
            String expandPath = Utils.tildeExpand(path);
            String normPath = expandPath;
            try {
                normPath = fileSystem.getPath(path).toRealPath().toString();
            } catch (IOException e) {
                if (doesNotNeedToWork.profile(mustWork == RRuntime.LOGICAL_FALSE)) {
                    // no error or warning
                } else {
                    Object[] errorArgs;

View Full Code Here

  private static final Logger logger = LoggerFactory.getLogger(StaticFilesDevConfig.class);


  @Override
  public void addResourceHandlers(ResourceHandlerRegistry registry) {
    try {
      FileSystem fs = FileSystems.getDefault();
      registry.addResourceHandler("/**")
          .addResourceLocations("file:" + fs.getPath(this.relativePath).toFile().getCanonicalPath() + "/")
          .setCachePeriod(0);
    } catch (IOException e) {
      logger.error("Error while adding static files handler", e);
    }
  }

View Full Code Here

    return PathMatchers.getPathMatcher("glob:" + pattern, "/", ImmutableSet.<PathNormalization>of());
  }


  @Override
  protected PathMatcher realMatcher(String pattern) {
    FileSystem defaultFileSystem = FileSystems.getDefault();
    if ("/".equals(defaultFileSystem.getSeparator())) {
      return defaultFileSystem.getPathMatcher("glob:" + pattern);
    }
    return null;
  }

View Full Code Here

    tester.assertModifiedTimeDidNotChange();
  }


  @Test
  public void testUnsupportedFeatures() throws IOException {
    FileSystem fileSystem = Jimfs.newFileSystem(Configuration.unix().toBuilder()
        .setSupportedFeatures() // none
        .build());


    Path foo = fileSystem.getPath("foo");
    Path bar = foo.resolveSibling("bar");


    try {
      Files.createLink(foo, bar);
      fail();

View Full Code Here

    assertThat(config.defaultAttributeValues).isEmpty();
  }


  @Test
  public void testFileSystemForDefaultUnixConfiguration() throws IOException {
    FileSystem fs = Jimfs.newFileSystem(Configuration.unix());


    assertThat(fs.getRootDirectories())
        .containsExactlyElementsIn(ImmutableList.of(fs.getPath("/")))
        .inOrder();
    assertThatPath(fs.getPath("").toRealPath()).isEqualTo(fs.getPath("/work"));
    assertThat(Iterables.getOnlyElement(fs.getFileStores()).getTotalSpace()).isEqualTo(
        4L * 1024 * 1024 * 1024);
    assertThat(fs.supportedFileAttributeViews()).containsExactly("basic");


    Files.createFile(fs.getPath("/foo"));
    Files.createFile(fs.getPath("/FOO"));
  }

View Full Code Here

0 1 2 3 4

TOP

Related Classes of java.nio.file.FileSystem

au.net.causal.projo.prefs.transform.PathToStringTransformer

br.com.mystudies.niotwo.FilesFilter

ch.inftec.ju.util.libs.NioTest

com.bluelotussoftware.service.LogService

com.github.mustachejava.inverter.InvertUtils

com.google.common.jimfs.ConfigurationTest

com.google.common.jimfs.JimfsUnixLikeFileSystemTest

com.google.common.jimfs.RegexGlobMatcherTest

com.google.javascript.jscomp.CommandLineRunner$Flags

com.oracle.truffle.r.nodes.builtin.base.DotLibpaths

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.