871202e1f258ac495d976644b8bc63b8a6262c9b
[idea/community.git] / 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 }