platform/platform-api/src/com/intellij/openapi/vfs/LocalFileSystem.java

   1 /*
   2  * Copyright 2000-2015 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.openapi.vfs;
  17
  18 import com.intellij.openapi.util.SystemInfo;
  19 import com.intellij.openapi.vfs.newvfs.ManagingFS;
  20 import com.intellij.openapi.vfs.newvfs.NewVirtualFileSystem;
  21 import com.intellij.util.Processor;
  22 import com.intellij.util.io.fs.IFile;
  23 import org.jetbrains.annotations.NonNls;
  24 import org.jetbrains.annotations.NotNull;
  25 import org.jetbrains.annotations.Nullable;
  26
  27 import java.io.File;
  28 import java.util.Collection;
  29 import java.util.Collections;
  30 import java.util.Set;
  31
  32 import static java.util.Collections.singleton;
  33
  34 public abstract class LocalFileSystem extends NewVirtualFileSystem {
  35   @NonNls public static final String PROTOCOL = StandardFileSystems.FILE_PROTOCOL;
  36   @NonNls public static final String PROTOCOL_PREFIX = StandardFileSystems.FILE_PROTOCOL_PREFIX;
  37
  38   @SuppressWarnings("UtilityClassWithoutPrivateConstructor")
  39   private static class LocalFileSystemHolder {
  40     private static final LocalFileSystem ourInstance = (LocalFileSystem)VirtualFileManager.getInstance().getFileSystem(PROTOCOL);
  41   }
  42
  43   public static LocalFileSystem getInstance() {
  44     return LocalFileSystemHolder.ourInstance;
  45   }
  46
  47   @Nullable
  48   public abstract VirtualFile findFileByIoFile(@NotNull File file);
  49
  50   @Nullable
  51   public abstract VirtualFile findFileByIoFile(@NotNull IFile file);
  52
  53   @Nullable
  54   public abstract VirtualFile refreshAndFindFileByIoFile(@NotNull File file);
  55
  56   @Nullable
  57   public abstract VirtualFile refreshAndFindFileByIoFile(@NotNull IFile ioFile);
  58
  59   /**
  60    * Performs a non-recursive synchronous refresh of specified files.
  61    *
  62    * @param files files to refresh.
  63    * @since 6.0
  64    */
  65   public abstract void refreshIoFiles(@NotNull Iterable<File> files);
  66
  67   public abstract void refreshIoFiles(@NotNull Iterable<File> files, boolean async, boolean recursive, @Nullable Runnable onFinish);
  68
  69   /**
  70    * Performs a non-recursive synchronous refresh of specified files.
  71    *
  72    * @param files files to refresh.
  73    * @since 6.0
  74    */
  75   public abstract void refreshFiles(@NotNull Iterable<VirtualFile> files);
  76
  77   public abstract void refreshFiles(@NotNull Iterable<VirtualFile> files, boolean async, boolean recursive, @Nullable Runnable onFinish);
  78
  79   /** @deprecated fake root considered harmful (to remove in IDEA 14) */
  80   public final VirtualFile getRoot() {
  81     VirtualFile[] roots = ManagingFS.getInstance().getLocalRoots();
  82     assert roots.length > 0 : SystemInfo.OS_NAME;
  83     return roots[0];
  84   }
  85
  86   public interface WatchRequest {
  87     @NotNull
  88     String getRootPath();
  89
  90     boolean isToWatchRecursively();
  91   }
  92
  93   @Nullable
  94   public WatchRequest addRootToWatch(@NotNull final String rootPath, final boolean watchRecursively) {
  95     final Set<WatchRequest> result = addRootsToWatch(singleton(rootPath), watchRecursively);
  96     return result.size() == 1 ? result.iterator().next() : null;
  97   }
  98
  99   @NotNull
 100   public abstract Set<WatchRequest> addRootsToWatch(@NotNull final Collection<String> rootPaths, final boolean watchRecursively);
 101
 102   public void removeWatchedRoot(@Nullable final WatchRequest watchRequest) {
 103     if (watchRequest != null) {
 104       removeWatchedRoots(singleton(watchRequest));
 105     }
 106   }
 107
 108   public abstract void removeWatchedRoots(@NotNull final Collection<WatchRequest> watchRequests);
 109
 110   @Nullable
 111   public WatchRequest replaceWatchedRoot(@Nullable final WatchRequest watchRequest,
 112                                          @NotNull final String rootPath,
 113                                          final boolean watchRecursively) {
 114     final Set<WatchRequest> requests = watchRequest != null ? singleton(watchRequest) : Collections.<WatchRequest>emptySet();
 115     final Set<WatchRequest> result = watchRecursively ? replaceWatchedRoots(requests, singleton(rootPath), null)
 116                                                       : replaceWatchedRoots(requests, null, singleton(rootPath));
 117     return result.size() == 1 ? result.iterator().next() : null;
 118   }
 119
 120   @NotNull
 121   public abstract Set<WatchRequest> replaceWatchedRoots(@NotNull final Collection<WatchRequest> watchRequests,
 122                                                         @Nullable final Collection<String> recursiveRoots,
 123                                                         @Nullable final Collection<String> flatRoots);
 124
 125   /**
 126    * Registers a handler that allows a version control system plugin to intercept file operations in the local file system
 127    * and to perform them through the VCS tool.
 128    *
 129    * @param handler the handler instance.
 130    */
 131   public abstract void registerAuxiliaryFileOperationsHandler(@NotNull LocalFileOperationsHandler handler);
 132
 133   /**
 134    * Unregisters a handler that allows a version control system plugin to intercept file operations in the local file system
 135    * and to perform them through the VCS tool.
 136    *
 137    * @param handler the handler instance.
 138    */
 139   public abstract void unregisterAuxiliaryFileOperationsHandler(@NotNull LocalFileOperationsHandler handler);
 140
 141   public abstract boolean processCachedFilesInSubtree(@NotNull VirtualFile file, @NotNull Processor<VirtualFile> processor);
 142 }