Merge branch 'master' of git@git.labs.intellij.net:idea/community
[idea/community.git] / platform / platform-impl / src / com / intellij / openapi / vfs / impl / win32 / Win32LocalFileSystem.java
1 /*
2  * Copyright 2000-2009 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.impl.win32;
17
18 import com.intellij.openapi.diagnostic.Logger;
19 import com.intellij.openapi.vfs.VirtualFile;
20 import com.intellij.openapi.vfs.impl.local.LocalFileSystemBase;
21 import org.jetbrains.annotations.NotNull;
22
23 import java.io.FileNotFoundException;
24 import java.util.Arrays;
25 import java.util.Collection;
26 import java.util.Set;
27
28 /**
29  * @author Dmitry Avdeev
30  */
31 public class Win32LocalFileSystem extends LocalFileSystemBase {
32
33   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vfs.impl.win32.Win32LocalFileSystem");
34
35   private static boolean ourIsAvailable;
36
37   static {
38     try {
39       System.loadLibrary("IdeaWin32");
40       ourIsAvailable = true;
41     }
42     catch (Throwable e) {
43       ourIsAvailable = false;
44     }
45   }
46
47   public static boolean isAvailable() {
48     return ourIsAvailable;
49   }
50
51   private static final ThreadLocal<Win32LocalFileSystem> THREAD_LOCAL = new ThreadLocal<Win32LocalFileSystem>() {
52     @Override
53     protected Win32LocalFileSystem initialValue() {
54       return new Win32LocalFileSystem();
55     }
56   };
57
58   public static Win32LocalFileSystem getWin32Instance() {
59     if (!isAvailable()) throw new RuntimeException("dll is not loaded");
60     Win32LocalFileSystem fileSystem = THREAD_LOCAL.get();
61     fileSystem.myKernel.clearCache();
62     return fileSystem;
63   }
64
65   private final Win32Kernel myKernel = new Win32Kernel();
66   public static boolean checkMe = false;
67
68   private Win32LocalFileSystem() {
69   }
70
71   @Override
72   public String[] list(VirtualFile file) {
73     try {
74       String[] strings = myKernel.list(file.getPath());
75       if (checkMe && !Arrays.asList(strings).equals(Arrays.asList(super.list(file)))) {
76         LOG.error(file.getPath());
77       }
78       return strings;
79     }
80     catch (Exception e) {
81       if (checkMe) {
82         assert false;
83       }
84       return super.list(file);
85     }
86   }
87
88   @Override
89   public boolean exists(VirtualFile fileOrDirectory) {
90     if (fileOrDirectory.getParent() == null) return true;
91     boolean b = myKernel.exists(fileOrDirectory.getPath());
92     if (checkMe && b != super.exists(fileOrDirectory)) {
93       LOG.error(fileOrDirectory.getPath());
94     }
95     return b;
96   }
97
98   @Override
99   public boolean isDirectory(VirtualFile file) {
100     try {
101       boolean b = myKernel.isDirectory(file.getPath());
102       if (checkMe && b != super.isDirectory(file)) {
103         LOG.error(file.getPath());
104       }
105       return b;
106     }
107     catch (FileNotFoundException e) {
108       return super.isDirectory(file);
109     }
110   }
111
112   @Override
113   public boolean isWritable(VirtualFile file) {
114     try {
115       boolean b = myKernel.isWritable(file.getPath());
116       if (checkMe && b != super.isWritable(file)) {
117         LOG.error(file.getPath());
118       }
119       return b;
120     }
121     catch (FileNotFoundException e) {
122       return super.isWritable(file);
123     }
124   }
125
126   @Override
127   public long getTimeStamp(VirtualFile file) {
128     try {
129       long timeStamp = myKernel.getTimeStamp(file.getPath());
130       if (checkMe && timeStamp != super.getTimeStamp(file)) {
131         timeStamp = myKernel.getTimeStamp(file.getPath());
132         LOG.error(file.getPath());
133       }
134       return timeStamp;
135     }
136     catch (FileNotFoundException e) {
137       return super.getTimeStamp(file);
138     }
139   }
140
141   @Override
142   public WatchRequest addRootToWatch(@NotNull String rootPath, boolean toWatchRecursively) {
143     throw new UnsupportedOperationException();
144   }
145
146   @NotNull
147   @Override
148   public Set<WatchRequest> addRootsToWatch(@NotNull Collection<String> rootPaths, boolean toWatchRecursively) {
149     throw new UnsupportedOperationException();
150   }
151
152   @Override
153   public void removeWatchedRoots(@NotNull Collection<WatchRequest> rootsToWatch) {
154     throw new UnsupportedOperationException();
155   }
156
157   @Override
158   public void removeWatchedRoot(@NotNull WatchRequest watchRequest) {
159     throw new UnsupportedOperationException();
160   }
161 }