unused IFile interface deprecated
[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   /**
51    * @deprecated use {@link #findFileByIoFile(File)} instead
52    */
53   @Deprecated
54   @Nullable
55   public abstract VirtualFile findFileByIoFile(@NotNull IFile file);
56
57   @Nullable
58   public abstract VirtualFile refreshAndFindFileByIoFile(@NotNull File file);
59
60   /**
61    * @deprecated use {@link #refreshAndFindFileByIoFile(File)} instead
62    */
63   @Deprecated
64   @Nullable
65   public abstract VirtualFile refreshAndFindFileByIoFile(@NotNull IFile ioFile);
66
67   /**
68    * Performs a non-recursive synchronous refresh of specified files.
69    *
70    * @param files files to refresh.
71    * @since 6.0
72    */
73   public abstract void refreshIoFiles(@NotNull Iterable<File> files);
74
75   public abstract void refreshIoFiles(@NotNull Iterable<File> files, boolean async, boolean recursive, @Nullable Runnable onFinish);
76
77   /**
78    * Performs a non-recursive synchronous refresh of specified files.
79    *
80    * @param files files to refresh.
81    * @since 6.0
82    */
83   public abstract void refreshFiles(@NotNull Iterable<VirtualFile> files);
84
85   public abstract void refreshFiles(@NotNull Iterable<VirtualFile> files, boolean async, boolean recursive, @Nullable Runnable onFinish);
86
87   /** @deprecated fake root considered harmful (to remove in IDEA 14) */
88   public final VirtualFile getRoot() {
89     VirtualFile[] roots = ManagingFS.getInstance().getLocalRoots();
90     assert roots.length > 0 : SystemInfo.OS_NAME;
91     return roots[0];
92   }
93
94   public interface WatchRequest {
95     @NotNull
96     String getRootPath();
97
98     boolean isToWatchRecursively();
99   }
100
101   @Nullable
102   public WatchRequest addRootToWatch(@NotNull final String rootPath, final boolean watchRecursively) {
103     final Set<WatchRequest> result = addRootsToWatch(singleton(rootPath), watchRecursively);
104     return result.size() == 1 ? result.iterator().next() : null;
105   }
106
107   @NotNull
108   public abstract Set<WatchRequest> addRootsToWatch(@NotNull final Collection<String> rootPaths, final boolean watchRecursively);
109
110   public void removeWatchedRoot(@Nullable final WatchRequest watchRequest) {
111     if (watchRequest != null) {
112       removeWatchedRoots(singleton(watchRequest));
113     }
114   }
115
116   public abstract void removeWatchedRoots(@NotNull final Collection<WatchRequest> watchRequests);
117
118   @Nullable
119   public WatchRequest replaceWatchedRoot(@Nullable final WatchRequest watchRequest,
120                                          @NotNull final String rootPath,
121                                          final boolean watchRecursively) {
122     final Set<WatchRequest> requests = watchRequest != null ? singleton(watchRequest) : Collections.<WatchRequest>emptySet();
123     final Set<WatchRequest> result = watchRecursively ? replaceWatchedRoots(requests, singleton(rootPath), null)
124                                                       : replaceWatchedRoots(requests, null, singleton(rootPath));
125     return result.size() == 1 ? result.iterator().next() : null;
126   }
127
128   @NotNull
129   public abstract Set<WatchRequest> replaceWatchedRoots(@NotNull final Collection<WatchRequest> watchRequests,
130                                                         @Nullable final Collection<String> recursiveRoots,
131                                                         @Nullable final Collection<String> flatRoots);
132
133   /**
134    * Registers 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 registerAuxiliaryFileOperationsHandler(@NotNull LocalFileOperationsHandler handler);
140
141   /**
142    * Unregisters a handler that allows a version control system plugin to intercept file operations in the local file system
143    * and to perform them through the VCS tool.
144    *
145    * @param handler the handler instance.
146    */
147   public abstract void unregisterAuxiliaryFileOperationsHandler(@NotNull LocalFileOperationsHandler handler);
148
149   public abstract boolean processCachedFilesInSubtree(@NotNull VirtualFile file, @NotNull Processor<VirtualFile> processor);
150 }