platform/core-impl/src/com/intellij/openapi/vfs/impl/jar/JarHandlerBase.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2013 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.openapi.vfs.impl.jar;

 import com.intellij.openapi.diagnostic.LogUtil;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.util.io.BufferExposingByteArrayInputStream;
 import com.intellij.openapi.util.io.FileAttributes;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.JarFile;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.reference.SoftReference;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.TimedReference;
 import gnu.trove.THashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.ref.Reference;
 import java.util.*;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;

 public class JarHandlerBase {
   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vfs.impl.jar.JarHandlerBase");

   private static final long DEFAULT_LENGTH = 0L;
   private static final long DEFAULT_TIMESTAMP = -1L;

   private final TimedReference<JarFile> myJarFile = new TimedReference<JarFile>(null);
   private Reference<Map<String, EntryInfo>> myRelPathsToEntries = new SoftReference<Map<String, EntryInfo>>(null);
   private final Object lock = new Object();

   protected final String myBasePath;

   protected static class EntryInfo {
     protected final boolean isDirectory;
     protected final String shortName;
     protected final EntryInfo parent;

     public EntryInfo(@NotNull String shortName, final EntryInfo parent, final boolean directory) {
       this.shortName = shortName;
       this.parent = parent;
       isDirectory = directory;
     }
   }

   public JarHandlerBase(@NotNull String path) {
     myBasePath = path;
   }

   protected void clear() {
     synchronized (lock) {
       myRelPathsToEntries = null;
       myJarFile.set(null);
     }
   }

   public File getMirrorFile(@NotNull File originalFile) {
     return originalFile;
   }

   @Nullable
   public JarFile getJar() {
     JarFile jar = myJarFile.get();
     if (jar == null) {
       synchronized (lock) {
         jar = myJarFile.get();
         if (jar == null) {
           jar = createJarFile();
           if (jar != null) {
             myJarFile.set(jar);
           }
         }
       }
     }
     return jar;
   }

   @Nullable
   protected JarFile createJarFile() {
     final File originalFile = getOriginalFile();
     try {
       @SuppressWarnings("IOResourceOpenedButNotSafelyClosed") final ZipFile zipFile = new ZipFile(getMirrorFile(originalFile));

       class MyJarEntry implements JarFile.JarEntry {
         private final ZipEntry myEntry;

         MyJarEntry(ZipEntry entry) {
           myEntry = entry;
         }

         public ZipEntry getEntry() {
           return myEntry;
         }

         @Override
         public String getName() {
           return myEntry.getName();
         }

         @Override
         public long getSize() {
           return myEntry.getSize();
         }

         @Override
         public long getTime() {
           return myEntry.getTime();
         }

         @Override
         public boolean isDirectory() {
           return myEntry.isDirectory();
         }
       }

       return new JarFile() {
         @Override
         public JarFile.JarEntry getEntry(String name) {
           try {
             ZipEntry entry = zipFile.getEntry(name);
             if (entry != null) {
               return new MyJarEntry(entry);
             }
           }
           catch (IllegalArgumentException e) {
             LOG.warn(e);
           }
           return null;
         }

         @Override
         public InputStream getInputStream(JarFile.JarEntry entry) throws IOException {
           return zipFile.getInputStream(((MyJarEntry)entry).myEntry);
         }

         @Override
         public Enumeration<? extends JarFile.JarEntry> entries() {
           return new Enumeration<JarEntry>() {
             private final Enumeration<? extends ZipEntry> entries = zipFile.entries();

             @Override
             public boolean hasMoreElements() {
               return entries.hasMoreElements();
             }

             @Override
             public JarEntry nextElement() {
               try {
                 ZipEntry entry = entries.nextElement();
                 if (entry != null) {
                   return new MyJarEntry(entry);
                 }
               }
               catch (IllegalArgumentException e) {
                 LOG.warn(e);
               }
               return null;
             }
           };
         }

         @Override
         public ZipFile getZipFile() {
           return zipFile;
         }
       };
     }
     catch (IOException e) {
       LOG.warn(e.getMessage() + ": " + originalFile.getPath(), e);
       return null;
     }
   }

   @NotNull
   protected File getOriginalFile() {
     return new File(myBasePath);
   }

   @NotNull
   private static EntryInfo getOrCreate(@NotNull String entryName, boolean isDirectory, @NotNull Map<String, EntryInfo> map) {
     EntryInfo info = map.get(entryName);
     if (info == null) {
       int idx = entryName.lastIndexOf('/');
       final String parentEntryName = idx > 0 ? entryName.substring(0, idx) : "";
       String shortName = idx > 0 ? entryName.substring(idx + 1) : entryName;
       if (".".equals(shortName)) return getOrCreate(parentEntryName, true, map);

       info = new EntryInfo(shortName, getOrCreate(parentEntryName, true, map), isDirectory);
       map.put(entryName, info);
     }

     return info;
   }

   @NotNull
   public String[] list(@NotNull final VirtualFile file) {
     synchronized (lock) {
       EntryInfo parentEntry = getEntryInfo(file);

       Set<String> names = new HashSet<String>();
       for (EntryInfo info : getEntriesMap().values()) {
         if (info.parent == parentEntry) {
           names.add(info.shortName);
         }
       }

       return ArrayUtil.toStringArray(names);
     }
   }

   protected EntryInfo getEntryInfo(@NotNull VirtualFile file) {
     synchronized (lock) {
       String parentPath = getRelativePath(file);
       return getEntryInfo(parentPath);
     }
   }

   public EntryInfo getEntryInfo(@NotNull String parentPath) {
     return getEntriesMap().get(parentPath);
   }

   @NotNull
   protected Map<String, EntryInfo> getEntriesMap() {
     synchronized (lock) {
       Map<String, EntryInfo> map = SoftReference.dereference(myRelPathsToEntries);

       if (map == null) {
         final JarFile zip = getJar();
         if (zip != null) {
           LogUtil.debug(LOG, "mapping %s", myBasePath);

           map = new THashMap<String, EntryInfo>();
           map.put("", new EntryInfo("", null, true));
           final Enumeration<? extends JarFile.JarEntry> entries = zip.entries();
           while (entries.hasMoreElements()) {
             final JarFile.JarEntry entry = entries.nextElement();
             final String name = entry.getName();
             final boolean isDirectory = StringUtil.endsWithChar(name, '/');
             getOrCreate(isDirectory ? name.substring(0, name.length() - 1) : name, isDirectory, map);
           }

           myRelPathsToEntries = new SoftReference<Map<String, EntryInfo>>(map);
         }
         else {
           map = Collections.emptyMap();
         }
       }

       return map;
     }
   }

   @NotNull
   private String getRelativePath(@NotNull VirtualFile file) {
     final String path = file.getPath().substring(myBasePath.length() + 1);
     return StringUtil.startsWithChar(path, '/') ? path.substring(1) : path;
   }

   @Nullable
   private JarFile.JarEntry convertToEntry(@NotNull VirtualFile file) {
     String path = getRelativePath(file);
     final JarFile jar = getJar();
     return jar == null ? null : jar.getEntry(path);
   }

   public long getLength(@NotNull final VirtualFile file) {
     final JarFile.JarEntry entry = convertToEntry(file);
     synchronized (lock) {
       return entry == null ? DEFAULT_LENGTH : entry.getSize();
     }
   }

   @NotNull
   public InputStream getInputStream(@NotNull final VirtualFile file) throws IOException {
     return new BufferExposingByteArrayInputStream(contentsToByteArray(file));
   }

   @NotNull
   public byte[] contentsToByteArray(@NotNull final VirtualFile file) throws IOException {
     final JarFile.JarEntry entry = convertToEntry(file);
     if (entry == null) {
       return ArrayUtil.EMPTY_BYTE_ARRAY;
     }
     synchronized (lock) {
       final JarFile jar = getJar();
       assert jar != null : file;

       final InputStream stream = jar.getInputStream(entry);
       assert stream != null : file;

       try {
         return FileUtil.loadBytes(stream, (int)entry.getSize());
       }
       finally {
         stream.close();
       }
     }
   }

   public long getTimeStamp(@NotNull final VirtualFile file) {
     if (file.getParent() == null) return getOriginalFile().lastModified(); // Optimization
     final JarFile.JarEntry entry = convertToEntry(file);
     synchronized (lock) {
       return entry == null ? DEFAULT_TIMESTAMP : entry.getTime();
     }
   }

   public boolean isDirectory(@NotNull final VirtualFile file) {
     if (file.getParent() == null) return true; // Optimization
     synchronized (lock) {
       final String path = getRelativePath(file);
       final EntryInfo info = getEntryInfo(path);
       return info == null || info.isDirectory;
     }
   }

   public boolean exists(@NotNull final VirtualFile fileOrDirectory) {
     if (fileOrDirectory.getParent() == null) {
       // Optimization. Do not build entries if asked for jar root existence.
       return myJarFile.get() != null || getOriginalFile().exists();
     }

     return getEntryInfo(fileOrDirectory) != null;
   }

   @Nullable
   public FileAttributes getAttributes(@NotNull final VirtualFile file) {
     final JarFile.JarEntry entry = convertToEntry(file);
     synchronized (lock) {
       final EntryInfo entryInfo = getEntryInfo(getRelativePath(file));
       if (entryInfo == null) return null;
       final long length = entry != null ? entry.getSize() : DEFAULT_LENGTH;
       final long timeStamp = entry != null ? entry.getTime() : DEFAULT_TIMESTAMP;
       return new FileAttributes(entryInfo.isDirectory, false, false, false, length, timeStamp, false);
     }
   }
 }
	/*
	* Copyright 2000-2013 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.openapi.vfs.impl.jar;

	import com.intellij.openapi.diagnostic.LogUtil;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.openapi.util.io.BufferExposingByteArrayInputStream;
	import com.intellij.openapi.util.io.FileAttributes;
	import com.intellij.openapi.util.io.FileUtil;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.openapi.vfs.JarFile;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.reference.SoftReference;
	import com.intellij.util.ArrayUtil;
	import com.intellij.util.TimedReference;
	import gnu.trove.THashMap;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.lang.ref.Reference;
	import java.util.*;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipFile;

	public class JarHandlerBase {
	private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vfs.impl.jar.JarHandlerBase");

	private static final long DEFAULT_LENGTH = 0L;
	private static final long DEFAULT_TIMESTAMP = -1L;

	private final TimedReference<JarFile> myJarFile = new TimedReference<JarFile>(null);
	private Reference<Map<String, EntryInfo>> myRelPathsToEntries = new SoftReference<Map<String, EntryInfo>>(null);
	private final Object lock = new Object();

	protected final String myBasePath;

	protected static class EntryInfo {
	protected final boolean isDirectory;
	protected final String shortName;
	protected final EntryInfo parent;

	public EntryInfo(@NotNull String shortName, final EntryInfo parent, final boolean directory) {
	this.shortName = shortName;
	this.parent = parent;
	isDirectory = directory;
	}
	}

	public JarHandlerBase(@NotNull String path) {
	myBasePath = path;
	}

	protected void clear() {
	synchronized (lock) {
	myRelPathsToEntries = null;
	myJarFile.set(null);
	}
	}

	public File getMirrorFile(@NotNull File originalFile) {
	return originalFile;
	}

	@Nullable
	public JarFile getJar() {
	JarFile jar = myJarFile.get();
	if (jar == null) {
	synchronized (lock) {
	jar = myJarFile.get();
	if (jar == null) {
	jar = createJarFile();
	if (jar != null) {
	myJarFile.set(jar);
	}
	}
	}
	}
	return jar;
	}

	@Nullable
	protected JarFile createJarFile() {
	final File originalFile = getOriginalFile();
	try {
	@SuppressWarnings("IOResourceOpenedButNotSafelyClosed") final ZipFile zipFile = new ZipFile(getMirrorFile(originalFile));

	class MyJarEntry implements JarFile.JarEntry {
	private final ZipEntry myEntry;

	MyJarEntry(ZipEntry entry) {
	myEntry = entry;
	}

	public ZipEntry getEntry() {
	return myEntry;
	}

	@Override
	public String getName() {
	return myEntry.getName();
	}

	@Override
	public long getSize() {
	return myEntry.getSize();
	}

	@Override
	public long getTime() {
	return myEntry.getTime();
	}

	@Override
	public boolean isDirectory() {
	return myEntry.isDirectory();
	}
	}

	return new JarFile() {
	@Override
	public JarFile.JarEntry getEntry(String name) {
	try {
	ZipEntry entry = zipFile.getEntry(name);
	if (entry != null) {
	return new MyJarEntry(entry);
	}
	}
	catch (IllegalArgumentException e) {
	LOG.warn(e);
	}
	return null;
	}

	@Override
	public InputStream getInputStream(JarFile.JarEntry entry) throws IOException {
	return zipFile.getInputStream(((MyJarEntry)entry).myEntry);
	}

	@Override
	public Enumeration<? extends JarFile.JarEntry> entries() {
	return new Enumeration<JarEntry>() {
	private final Enumeration<? extends ZipEntry> entries = zipFile.entries();

	@Override
	public boolean hasMoreElements() {
	return entries.hasMoreElements();
	}

	@Override
	public JarEntry nextElement() {
	try {
	ZipEntry entry = entries.nextElement();
	if (entry != null) {
	return new MyJarEntry(entry);
	}
	}
	catch (IllegalArgumentException e) {
	LOG.warn(e);
	}
	return null;
	}
	};
	}

	@Override
	public ZipFile getZipFile() {
	return zipFile;
	}
	};
	}
	catch (IOException e) {
	LOG.warn(e.getMessage() + ": " + originalFile.getPath(), e);
	return null;
	}
	}

	@NotNull
	protected File getOriginalFile() {
	return new File(myBasePath);
	}

	@NotNull
	private static EntryInfo getOrCreate(@NotNull String entryName, boolean isDirectory, @NotNull Map<String, EntryInfo> map) {
	EntryInfo info = map.get(entryName);
	if (info == null) {
	int idx = entryName.lastIndexOf('/');
	final String parentEntryName = idx > 0 ? entryName.substring(0, idx) : "";
	String shortName = idx > 0 ? entryName.substring(idx + 1) : entryName;
	if (".".equals(shortName)) return getOrCreate(parentEntryName, true, map);

	info = new EntryInfo(shortName, getOrCreate(parentEntryName, true, map), isDirectory);
	map.put(entryName, info);
	}

	return info;
	}

	@NotNull
	public String[] list(@NotNull final VirtualFile file) {
	synchronized (lock) {
	EntryInfo parentEntry = getEntryInfo(file);

	Set<String> names = new HashSet<String>();
	for (EntryInfo info : getEntriesMap().values()) {
	if (info.parent == parentEntry) {
	names.add(info.shortName);
	}
	}

	return ArrayUtil.toStringArray(names);
	}
	}

	protected EntryInfo getEntryInfo(@NotNull VirtualFile file) {
	synchronized (lock) {
	String parentPath = getRelativePath(file);
	return getEntryInfo(parentPath);
	}
	}

	public EntryInfo getEntryInfo(@NotNull String parentPath) {
	return getEntriesMap().get(parentPath);
	}

	@NotNull
	protected Map<String, EntryInfo> getEntriesMap() {
	synchronized (lock) {
	Map<String, EntryInfo> map = SoftReference.dereference(myRelPathsToEntries);

	if (map == null) {
	final JarFile zip = getJar();
	if (zip != null) {
	LogUtil.debug(LOG, "mapping %s", myBasePath);

	map = new THashMap<String, EntryInfo>();
	map.put("", new EntryInfo("", null, true));
	final Enumeration<? extends JarFile.JarEntry> entries = zip.entries();
	while (entries.hasMoreElements()) {
	final JarFile.JarEntry entry = entries.nextElement();
	final String name = entry.getName();
	final boolean isDirectory = StringUtil.endsWithChar(name, '/');
	getOrCreate(isDirectory ? name.substring(0, name.length() - 1) : name, isDirectory, map);
	}

	myRelPathsToEntries = new SoftReference<Map<String, EntryInfo>>(map);
	}
	else {
	map = Collections.emptyMap();
	}
	}

	return map;
	}
	}

	@NotNull
	private String getRelativePath(@NotNull VirtualFile file) {
	final String path = file.getPath().substring(myBasePath.length() + 1);
	return StringUtil.startsWithChar(path, '/') ? path.substring(1) : path;
	}

	@Nullable
	private JarFile.JarEntry convertToEntry(@NotNull VirtualFile file) {
	String path = getRelativePath(file);
	final JarFile jar = getJar();
	return jar == null ? null : jar.getEntry(path);
	}

	public long getLength(@NotNull final VirtualFile file) {
	final JarFile.JarEntry entry = convertToEntry(file);
	synchronized (lock) {
	return entry == null ? DEFAULT_LENGTH : entry.getSize();
	}
	}

	@NotNull
	public InputStream getInputStream(@NotNull final VirtualFile file) throws IOException {
	return new BufferExposingByteArrayInputStream(contentsToByteArray(file));
	}

	@NotNull
	public byte[] contentsToByteArray(@NotNull final VirtualFile file) throws IOException {
	final JarFile.JarEntry entry = convertToEntry(file);
	if (entry == null) {
	return ArrayUtil.EMPTY_BYTE_ARRAY;
	}
	synchronized (lock) {
	final JarFile jar = getJar();
	assert jar != null : file;

	final InputStream stream = jar.getInputStream(entry);
	assert stream != null : file;

	try {
	return FileUtil.loadBytes(stream, (int)entry.getSize());
	}
	finally {
	stream.close();
	}
	}
	}

	public long getTimeStamp(@NotNull final VirtualFile file) {
	if (file.getParent() == null) return getOriginalFile().lastModified(); // Optimization
	final JarFile.JarEntry entry = convertToEntry(file);
	synchronized (lock) {
	return entry == null ? DEFAULT_TIMESTAMP : entry.getTime();
	}
	}

	public boolean isDirectory(@NotNull final VirtualFile file) {
	if (file.getParent() == null) return true; // Optimization
	synchronized (lock) {
	final String path = getRelativePath(file);
	final EntryInfo info = getEntryInfo(path);
	return info == null \|\| info.isDirectory;
	}
	}

	public boolean exists(@NotNull final VirtualFile fileOrDirectory) {
	if (fileOrDirectory.getParent() == null) {
	// Optimization. Do not build entries if asked for jar root existence.
	return myJarFile.get() != null \|\| getOriginalFile().exists();
	}

	return getEntryInfo(fileOrDirectory) != null;
	}

	@Nullable
	public FileAttributes getAttributes(@NotNull final VirtualFile file) {
	final JarFile.JarEntry entry = convertToEntry(file);
	synchronized (lock) {
	final EntryInfo entryInfo = getEntryInfo(getRelativePath(file));
	if (entryInfo == null) return null;
	final long length = entry != null ? entry.getSize() : DEFAULT_LENGTH;
	final long timeStamp = entry != null ? entry.getTime() : DEFAULT_TIMESTAMP;
	return new FileAttributes(entryInfo.isDirectory, false, false, false, length, timeStamp, false);
	}
	}
	}