platform-impl/src/com/intellij/openapi/vfs/newvfs/impl/VirtualDirectoryImpl.java

   1 /*
   2  * @author max
   3  */
   4 package com.intellij.openapi.vfs.newvfs.impl;
   5
   6 import com.intellij.openapi.vfs.VirtualFile;
   7 import com.intellij.openapi.vfs.newvfs.NewVirtualFile;
   8 import com.intellij.openapi.vfs.newvfs.NewVirtualFileSystem;
   9 import com.intellij.openapi.vfs.newvfs.RefreshQueue;
  10 import com.intellij.openapi.vfs.newvfs.events.VFileCreateEvent;
  11 import com.intellij.util.ArrayUtil;
  12 import com.intellij.util.text.CaseInsensitiveStringHashingStrategy;
  13 import gnu.trove.THashMap;
  14 import gnu.trove.THashSet;
  15 import org.jetbrains.annotations.NotNull;
  16 import org.jetbrains.annotations.Nullable;
  17
  18 import java.io.IOException;
  19 import java.io.InputStream;
  20 import java.io.OutputStream;
  21 import java.util.*;
  22
  23 public class VirtualDirectoryImpl extends VirtualFileSystemEntry {
  24   private final NewVirtualFileSystem myFS;
  25   private Object myChildren; // Either HashMap<String, VFile> or VFile[]
  26
  27   public VirtualDirectoryImpl(final String name, final VirtualDirectoryImpl parent, final NewVirtualFileSystem fs, final int id) {
  28     super(name, parent, id);
  29     myFS = fs;
  30   }
  31
  32   @NotNull
  33   public NewVirtualFileSystem getFileSystem() {
  34     return myFS;
  35   }
  36
  37   @Nullable
  38   private NewVirtualFile findChild(final String name, final boolean createIfNotFound) {
  39     if (name.length() == 0) {
  40       return null;
  41     }
  42
  43     final VirtualFile[] a = asArray();
  44     if (a != null) {
  45       for (VirtualFile file : a) {
  46         if (namesEqual(name, file.getName())) return (NewVirtualFile)file;
  47       }
  48
  49       return createIfNotFound ? createAndFindChildWithEventFire(name) : null;
  50     }
  51
  52     final Map<String, VirtualFile> map;
  53     final VirtualFile file;
  54     synchronized (this) {
  55       map = ensureAsMap();
  56       file = map.get(name);
  57     }
  58
  59     if (file == NullVirtualFile.INSTANCE) {
  60       return createIfNotFound ? createAndFindChildWithEventFire(name) : null;
  61     }
  62
  63     if (file != null) return (NewVirtualFile)file;
  64
  65     final NewVirtualFileSystem delegate = getFileSystem();
  66     VirtualFile fake = new FakeVirtualFile(name, this);
  67     String name1 = delegate.getCanonicallyCasedName(fake);
  68
  69     int id = ourPersistence.getId(this, name1);
  70     if (id > 0) {
  71       synchronized (this) {
  72         VirtualFile alreadyCreated = map.get(name1);
  73         if (alreadyCreated != null) {
  74           if (alreadyCreated == NullVirtualFile.INSTANCE) {
  75             return createIfNotFound ? createAndFindChildWithEventFire(name) : null;
  76           }
  77           return (NewVirtualFile)alreadyCreated;
  78         }
  79         NewVirtualFile child = createChild(name1, id);
  80         map.put(name1, child);
  81         return child;
  82       }
  83     }
  84
  85     synchronized (this) {
  86       if (myChildren instanceof Map) {
  87         ensureAsMap().put(name1, NullVirtualFile.INSTANCE);
  88       }
  89     }
  90
  91     return null;
  92   }
  93
  94   public VirtualFileSystemEntry createChild(String name, int id) {
  95     final NewVirtualFileSystem fs = getFileSystem();
  96     final VirtualFileSystemEntry child = ourPersistence.isDirectory(id) ?
  97                                          new VirtualDirectoryImpl(name, this, fs, id) :
  98                                          new VirtualFileImpl(name, this, id);
  99     if (fs.markNewFilesAsDirty()) {
 100       child.markDirty();
 101     }
 102
 103     return child;
 104   }
 105
 106   @Nullable
 107   private NewVirtualFile createAndFindChildWithEventFire(final String name) {
 108     final NewVirtualFileSystem delegate = getFileSystem();
 109     VirtualFile fake = new FakeVirtualFile(name, this);
 110     if (delegate.exists(fake)) {
 111       final String realName = delegate.getCanonicallyCasedName(fake);
 112       VFileCreateEvent event = new VFileCreateEvent(null, this, realName, delegate.isDirectory(fake), true);
 113       RefreshQueue.getInstance().processSingleEvent(event);
 114       return findChild(realName);
 115     }
 116     else {
 117       return null;
 118     }
 119   }
 120
 121   @Nullable
 122   public NewVirtualFile refreshAndFindChild(final String name) {
 123     return findChild(name, true);
 124   }
 125
 126   @Nullable
 127   public synchronized NewVirtualFile findChildIfCached(final String name) {
 128     final VirtualFile[] a = asArray();
 129     if (a != null) {
 130       for (VirtualFile file : a) {
 131         if (namesEqual(name, file.getName())) return (NewVirtualFile)file;
 132       }
 133
 134       return null;
 135     }
 136
 137     final Map<String, VirtualFile> map = asMap();
 138     if (map != null) {
 139       final VirtualFile file = map.get(name);
 140       return file instanceof NewVirtualFile ? (NewVirtualFile)file : null;
 141     }
 142
 143     return null;
 144   }
 145
 146   @NotNull
 147   public synchronized Collection<VirtualFile> getInDbChildren() {
 148     if (myChildren instanceof VirtualFile[]) {
 149       return Arrays.asList((VirtualFile[])myChildren);
 150     }
 151
 152     if (!ourPersistence.wereChildrenAccessed(this)) {
 153       return Collections.emptyList();
 154     }
 155
 156     if (ourPersistence.areChildrenLoaded(this)) {
 157       return Arrays.asList(getChildren());
 158     }
 159
 160     final String[] names = ourPersistence.listPersisted(this);
 161     for (String name : names) {
 162       findChild(name, false);
 163     }
 164
 165     return ensureAsMap().values();
 166   }
 167
 168   @NotNull
 169   public synchronized VirtualFile[] getChildren() {
 170     if (myChildren instanceof VirtualFile[]) {
 171       return (VirtualFile[])myChildren;
 172     }
 173
 174     final int[] childrenIds = ourPersistence.listIds(this);
 175     VirtualFile[] children;
 176     if (childrenIds.length == 0) {
 177       children = EMPTY_ARRAY;
 178     }
 179     else {
 180       children = new VirtualFile[childrenIds.length];
 181       final Map<String, VirtualFile> map = asMap();
 182       for (int i = 0; i < children.length; i++) {
 183         final int childId = childrenIds[i];
 184         final String name = ourPersistence.getName(childId);
 185         VirtualFile child = map != null ? map.get(name) : null;
 186
 187         children[i] = child != null && child != NullVirtualFile.INSTANCE ? child : createChild(name, childId);
 188       }
 189     }
 190
 191     if (getId() > 0) {
 192       myChildren = children;
 193     }
 194
 195     return children;
 196   }
 197
 198   @Nullable
 199   public NewVirtualFile findChild(@NotNull final String name) {
 200     return findChild(name, false);
 201   }
 202
 203   @Nullable
 204   private synchronized VirtualFile[] asArray() {
 205     if (myChildren instanceof VirtualFile[]) return (VirtualFile[])myChildren;
 206     return null;
 207   }
 208
 209   @Nullable
 210   @SuppressWarnings({"unchecked"})
 211   private synchronized Map<String, VirtualFile> asMap() {
 212     if (myChildren instanceof Map) return (Map<String, VirtualFile>)myChildren;
 213     return null;
 214   }
 215
 216   @NotNull
 217   @SuppressWarnings({"unchecked"})
 218   private synchronized Map<String, VirtualFile> ensureAsMap() {
 219     assert !(myChildren instanceof VirtualFile[]);
 220
 221     if (myChildren == null) {
 222       myChildren = createMap();
 223     }
 224
 225     return (Map<String, VirtualFile>)myChildren;
 226   }
 227
 228   public synchronized void addChild(VirtualFile file) {
 229     final VirtualFile[] a = asArray();
 230     if (a != null) {
 231       myChildren = ArrayUtil.append(a, file);
 232     }
 233     else {
 234       final Map<String, VirtualFile> m = ensureAsMap();
 235       m.put(file.getName(), file);
 236     }
 237   }
 238
 239   public synchronized void removeChild(VirtualFile file) {
 240     final VirtualFile[] a = asArray();
 241     if (a != null) {
 242       myChildren = ArrayUtil.remove(a, file);
 243     }
 244     else {
 245       final Map<String, VirtualFile> m = ensureAsMap();
 246       m.put(file.getName(), NullVirtualFile.INSTANCE);
 247     }
 248   }
 249
 250   public synchronized boolean allChildrenLoaded() {
 251     return myChildren instanceof VirtualFile[];
 252   }
 253
 254   public synchronized List<String> getSuspicousNames() {
 255     final Map<String, VirtualFile> map = asMap();
 256     if (map == null) return Collections.emptyList();
 257
 258     List<String> names = new ArrayList<String>();
 259     for (Map.Entry<String, VirtualFile> entry : map.entrySet()) {
 260       if (entry.getValue() == NullVirtualFile.INSTANCE) {
 261         names.add(entry.getKey());
 262       }
 263     }
 264
 265     return names;
 266   }
 267
 268   public boolean isDirectory() {
 269     return true;
 270   }
 271
 272   @NotNull
 273   public synchronized Collection<VirtualFile> getCachedChildren() {
 274     final Map<String, VirtualFile> map = asMap();
 275     if (map != null) {
 276       Set<VirtualFile> files = new THashSet<VirtualFile>(map.values());
 277       files.remove(NullVirtualFile.INSTANCE);
 278       return files;
 279     }
 280
 281     final VirtualFile[] a = asArray();
 282     if (a != null) return Arrays.asList(a);
 283
 284     return Collections.emptyList();
 285   }
 286
 287   private boolean namesEqual(final String name1, final String name2) {
 288     return getFileSystem().isCaseSensitive() ? name1.equals(name2) : name1.equalsIgnoreCase(name2);
 289   }
 290
 291   private Map<String, VirtualFile> createMap() {
 292     return getFileSystem().isCaseSensitive()
 293            ? new THashMap<String, VirtualFile>()
 294            : new THashMap<String, VirtualFile>(CaseInsensitiveStringHashingStrategy.INSTANCE);
 295   }
 296
 297   public synchronized void cleanupCachedChildren() {
 298     // For tests only!!!
 299     myChildren = null;
 300   }
 301
 302   public InputStream getInputStream() throws IOException {
 303     throw new IOException("getInputStream() must not be called against a directory: " + getUrl());
 304   }
 305
 306   @NotNull
 307   public OutputStream getOutputStream(final Object requestor, final long newModificationStamp, final long newTimeStamp) throws IOException {
 308     throw new IOException("getOutputStream() must not be called against a directory: " + getUrl());
 309   }
 310 }