Attachment #208084 for bug #356620




        }
    }
}

/**
 * Zips the given files into the given jar. All the files are kept at the root of the zip. 
 */
public static void zipFiles(File[] files, String zipPath) throws IOException {
	File zipFile = new File(zipPath);
	if (zipFile.exists()) {
		if (!delete(zipFile))
			throw new IOException("Could not delete " + zipPath);
		// ensure the new zip file has a different timestamp than the previous one
		int timeToWait = 1000; // some platform (like Linux) have a 1s granularity)
		waitAtLeast(timeToWait);
	} else {
		zipFile.getParentFile().mkdirs();
	}
	ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(zipFile));
	try {
		for (int i = 0, length = files.length; i < length; i++) {
			File file = files[i];
			ZipEntry entry = new ZipEntry(file.getName());
			zip.putNextEntry(entry);
			zip.write(org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(file));
			zip.closeEntry();
		}
	} finally {
		zip.close();
	}
}
/**
 * Returns the compilation errors / warnings for the given CompilationResult.
 *





import java.io.File;
import java.io.IOException;
import java.net.URL;

import junit.framework.Test;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.index.*;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.tests.util.Util;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.UserLibraryClasspathContainer;
import org.osgi.service.prefs.BackingStoreException;

		System.arraycopy(entries, 0, entries = new IClasspathEntry[length+1], 0, length);
		entries[length] = JavaCore.newContainerEntry(containerSuggestion.getPath());
		p.setRawClasspath(entries, null);

	}
	
	public void testUserLibraryIndex() throws IOException, CoreException, BackingStoreException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");

			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}		
	}
	
	// Test that it works if the index file is in the jar file
	public void testIndexInJar() throws IOException, CoreException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		String indexZipPath =  getExternalResourcePath("TestIndex.zip");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			Util.zipFiles(new File[]{new File(indexFilePath)}, indexZipPath);
			
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			String url = "jar:file:/"+indexZipPath+"!/Test.index";
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, url);
			IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			
			assertEquals(url,JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexLocation().getUrl().toString());
			
			search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
			
			simulateExitRestart();
			getJavaModel().refreshExternalArchives(null,null);
			waitUntilIndexesReady();
			
			this.resultCollector = new JavaSearchResultCollector();
			assertEquals(url,JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexLocation().getUrl().toString());
			search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
		} finally {
			deleteProject("P");
			new File(indexZipPath).delete();
			new File(jarFilePath).delete();
		}
	}

	// Test index file in platform
	public void testPlatformJarIndexFile() throws CoreException, IOException {
		String indexFilePath = null;
		String jarFilePath = getExternalResourcePath("Test.jar");
		String indexUrl = "platform:/resource/ForIndex/Test.index.zip!/Test.index";
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			
			IProject indexProj = createProject("ForIndex");
			indexFilePath = indexProj.getProject().getLocation().append("Test.index").toFile().getAbsolutePath();
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			Util.zipFiles(new File[]{new File(indexFilePath)}, indexFilePath+".zip");
			
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, indexUrl);
			IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			
			search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
			
			URL url = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexLocation().getUrl();
			assertEquals(indexUrl, url.toString());
			
			simulateExitRestart();
			getJavaModel().refreshExternalArchives(null,null);
			waitUntilIndexesReady();
			
			this.resultCollector = new JavaSearchResultCollector();
			search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
			
			url = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexLocation().getUrl();
			assertEquals(indexUrl, url.toString());
		} finally {
			deleteProject("P");
			if (indexFilePath != null) {
				new File(indexFilePath).delete();
				new File(indexFilePath+".zip").delete();
			}
			new File(jarFilePath).delete();
			deleteProject("ForIndex");
		}
	}
}

Lines 14-19 Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/core/search/SearchParticipant.java (-5 / +9 lines)
14	import org.eclipse.core.runtime.*;	14	import org.eclipse.core.runtime.*;
15	import org.eclipse.jdt.internal.core.JavaModel;	15	import org.eclipse.jdt.internal.core.JavaModel;
16	import org.eclipse.jdt.internal.core.JavaModelManager;	16	import org.eclipse.jdt.internal.core.JavaModelManager;
		17	import org.eclipse.jdt.internal.core.index.FileIndexLocation;
		18	import org.eclipse.jdt.internal.core.index.IndexLocation;
17	import org.eclipse.jdt.internal.core.search.indexing.IndexManager;	19	import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
18		20
19	/**	21	/**
Lines 192-200 Link Here
192	* </p>	194	* </p>
193	*	195	*
194	* @param document the document to index	196	* @param document the document to index
195	* @param indexLocation the location on the file system of the index	197	* @param indexPath the location on the file system of the index
196	*/	198	*/
197	public final void scheduleDocumentIndexing(SearchDocument document, IPath indexLocation) {	199	public final void scheduleDocumentIndexing(SearchDocument document, IPath indexPath) {
198	IPath documentPath = new Path(document.getPath());	200	IPath documentPath = new Path(document.getPath());
199	Object file = JavaModel.getTarget(documentPath, true);	201	Object file = JavaModel.getTarget(documentPath, true);
200	IPath containerPath = documentPath;	202	IPath containerPath = documentPath;
Lines 205-215 Link Here
205	}	207	}
206	IndexManager manager = JavaModelManager.getIndexManager();	208	IndexManager manager = JavaModelManager.getIndexManager();
207	// TODO (frederic) should not have to create index manually, should expose API that recreates index instead	209	// TODO (frederic) should not have to create index manually, should expose API that recreates index instead
		210	IndexLocation indexLocation;
		211	indexLocation = new FileIndexLocation(indexPath.toFile(), true);
208	manager.ensureIndexExists(indexLocation, containerPath);	212	manager.ensureIndexExists(indexLocation, containerPath);
209	manager.scheduleDocumentIndexing(document, containerPath, indexLocation, this);	213	manager.scheduleDocumentIndexing(document, containerPath, indexLocation, this);
210	if (!indexLocation.equals(this.lastIndexLocation)) {	214	if (!indexPath.equals(this.lastIndexLocation)) {
211	manager.updateParticipant(indexLocation, containerPath);	215	manager.updateParticipant(indexPath, containerPath);
212	this.lastIndexLocation = indexLocation;	216	this.lastIndexLocation = indexPath;
213	}	217	}
214	}	218	}
215		219





public class DiskIndex {

IndexLocation indexLocation;

private int headerInfoOffset;
private int numberOfChunks;

}


DiskIndex() {
	if (fileName == null)
		throw new java.lang.IllegalArgumentException();
	this.indexFile = new File(fileName);

	// clear cached items
	this.headerInfoOffset = -1;
	this.numberOfChunks = -1;
	this.sizeOfLastChunk = -1;

	this.cachedCategoryName = null;
	this.categoryOffsets = null;
	this.categoryEnds = null;
}
DiskIndex(IndexLocation location) throws IOException {
	this();
	if (location == null) {
		throw new IllegalArgumentException();
	}
	this.indexLocation = location;
}
SimpleSet addDocumentNames(String substring, MemoryIndex memoryIndex) throws IOException {
	// must skip over documents which have been added/changed/deleted in the memory index

private void cacheDocumentNames() throws IOException {
	// will need all document names so get them now
	this.cachedChunks = new String[this.numberOfChunks][];
	InputStream stream = this.indexLocation.getInputStream();
	try {
		if (this.numberOfChunks > 5) BUFFER_READ_SIZE <<= 1;
		int offset = this.chunkOffsets[0];

	}
}
void initialize(boolean reuseExistingFile) throws IOException {
	if (this.indexLocation.exists()) {
		if (reuseExistingFile) {
			InputStream stream = this.indexLocation.getInputStream();
			this.streamBuffer = new byte[BUFFER_READ_SIZE];
			this.bufferIndex = 0;
			this.bufferEnd = stream.read(this.streamBuffer, 0, 128);

			}
			return;
		}
		if (!this.indexLocation.delete()) {
			if (DEBUG)
				System.out.println("initialize - Failed to delete index " + this.indexLocation); //$NON-NLS-1$
			throw new IOException("Failed to delete index " + this.indexLocation); //$NON-NLS-1$
		}
	}
	if (this.indexLocation.createNewFile()) {
		FileOutputStream stream = new FileOutputStream(this.indexLocation.getIndexFile(), false);
		try {
			this.streamBuffer = new byte[BUFFER_READ_SIZE];
			this.bufferIndex = 0;

		}
	} else {
		if (DEBUG)
			System.out.println("initialize - Failed to create new index " + this.indexLocation); //$NON-NLS-1$
		throw new IOException("Failed to create new index " + this.indexLocation); //$NON-NLS-1$
	}
}
private void initializeFrom(DiskIndex diskIndex, File newIndexFile) throws IOException {
	if (newIndexFile.exists() && !newIndexFile.delete()) { // delete the temporary index file
		if (DEBUG)
			System.out.println("initializeFrom - Failed to delete temp index " + this.indexLocation); //$NON-NLS-1$
	} else if (!newIndexFile.createNewFile()) {
		if (DEBUG)
			System.out.println("initializeFrom - Failed to create temp index " + this.indexLocation); //$NON-NLS-1$
		throw new IOException("Failed to create temp index " + this.indexLocation); //$NON-NLS-1$
	}

	int size = diskIndex.categoryOffsets == null ? 8 : diskIndex.categoryOffsets.elementSize;

DiskIndex mergeWith(MemoryIndex memoryIndex) throws IOException {
 	// assume write lock is held
	// compute & write out new docNames
	if (this.indexLocation == null) {
		throw new IOException("Pre-built index file not writeable");  //$NON-NLS-1$
	}
	String[] docNames = readAllDocumentNames();
	int previousLength = docNames.length;
	int[] positions = new int[previousLength]; // keeps track of the position of each document in the new sorted docNames

		if (previousLength == 0) return this; // nothing to do... memory index contained deleted documents that had never been saved

		// index is now empty since all the saved documents were removed
		DiskIndex newDiskIndex = new DiskIndex(this.indexLocation);
		newDiskIndex.initialize(false);
		return newDiskIndex;
	}
	File oldIndexFile = this.indexLocation.getIndexFile();
	DiskIndex newDiskIndex = new DiskIndex(new FileIndexLocation(new File(oldIndexFile.getPath() + ".tmp"))); //$NON-NLS-1$
	File newIndexFile = newDiskIndex.indexLocation.getIndexFile();
	try {
		newDiskIndex.initializeFrom(this, newIndexFile);
		FileOutputStream stream = new FileOutputStream(newIndexFile, false);
		int offsetToHeader = -1;
		try {
			newDiskIndex.writeAllDocumentNames(docNames, stream);

		newDiskIndex.writeOffsetToHeader(offsetToHeader);

		// rename file by deleting previous index file & renaming temp one
		if (oldIndexFile.exists() && !oldIndexFile.delete()) {
			if (DEBUG)
				System.out.println("mergeWith - Failed to delete " + this.indexLocation); //$NON-NLS-1$
			throw new IOException("Failed to delete index file " + this.indexLocation); //$NON-NLS-1$
		}
		if (!newIndexFile.renameTo(oldIndexFile)) {
			if (DEBUG)
				System.out.println("mergeWith - Failed to rename " + this.indexLocation); //$NON-NLS-1$
			throw new IOException("Failed to rename index file " + this.indexLocation); //$NON-NLS-1$
		}
	} catch (IOException e) {
		if (newIndexFile.exists() && !newIndexFile.delete())
			if (DEBUG)
				System.out.println("mergeWith - Failed to delete temp index " + newDiskIndex.indexLocation); //$NON-NLS-1$
		throw e;
	}

	newDiskIndex.indexLocation = this.indexLocation;
	return newDiskIndex;
}
private synchronized String[] readAllDocumentNames() throws IOException {
	if (this.numberOfChunks <= 0)
		return CharOperation.NO_STRINGS;

	InputStream stream = this.indexLocation.getInputStream();
	try {
		int offset = this.chunkOffsets[0];
		stream.skip(offset);

		}
	}

	InputStream stream = this.indexLocation.getInputStream();
	HashtableOfObject categoryTable = null;
	char[][] matchingWords = null;
	int count = 0;

		try {
			if (size < 0) { // DEBUG
				System.err.println("-------------------- DEBUG --------------------"); //$NON-NLS-1$
				System.err.println("file = "+this.indexLocation); //$NON-NLS-1$
				System.err.println("offset = "+offset); //$NON-NLS-1$
				System.err.println("size = "+size); //$NON-NLS-1$
				System.err.println("--------------------   END   --------------------"); //$NON-NLS-1$

			// DEBUG
			oom.printStackTrace();
			System.err.println("-------------------- DEBUG --------------------"); //$NON-NLS-1$
			System.err.println("file = "+this.indexLocation); //$NON-NLS-1$
			System.err.println("offset = "+offset); //$NON-NLS-1$
			System.err.println("size = "+size); //$NON-NLS-1$
			System.err.println("--------------------   END   --------------------"); //$NON-NLS-1$

	}

	if (matchingWords != null && count > 0) {
		stream = this.indexLocation.getInputStream();
		try {
			stream.skip(firstOffset);
			this.bufferIndex = 0;

	this.streamBuffer = null;
	return categoryTable;
}
private void readChunk(String[] docNames, InputStream stream, int index, int size) throws IOException {
	String current = new String(readStreamChars(stream));
	docNames[index++] = current;
	for (int i = 1; i < size; i++) {

			throw new IllegalArgumentException();
		this.streamBuffer = new byte[numberOfBytes];
		this.bufferIndex = 0;
		InputStream file = this.indexLocation.getInputStream();
		try {
			file.skip(start);
			if (file.read(this.streamBuffer, 0, numberOfBytes) != numberOfBytes)

	if (arrayOffset instanceof int[])
		return (int[]) arrayOffset;

	InputStream stream = this.indexLocation.getInputStream();
	try {
		int offset = ((Integer) arrayOffset).intValue();
		stream.skip(offset);

		this.streamBuffer = null;
	}
}
private void readHeaderInfo(InputStream stream) throws IOException {

	// must be same order as writeHeaderInfo()
	this.numberOfChunks = readStreamInt(stream);
	this.sizeOfLastChunk = this.streamBuffer[this.bufferIndex++] & 0xFF;
	this.documentReferenceSize = this.streamBuffer[this.bufferIndex++] & 0xFF;
	this.separator = (char) (this.streamBuffer[this.bufferIndex++] & 0xFF);
	long length = this.indexLocation.length();
	if (length != -1 && this.numberOfChunks > length) {
		// not an accurate check, but good enough https://bugs.eclipse.org/bugs/show_bug.cgi?id=350612
		if (DEBUG)
			System.out.println("Index file is corrupted " + this.indexLocation); //$NON-NLS-1$
		throw new IOException("Index file is corrupted " + this.indexLocation); //$NON-NLS-1$
	}
	this.chunkOffsets = new int[this.numberOfChunks];
	for (int i = 0; i < this.numberOfChunks; i++)

	int size = readStreamInt(stream);
	this.categoryOffsets = new HashtableOfIntValues(size);
	this.categoryEnds = new HashtableOfIntValues(size);
	if (length != -1 && size > length) {
		//  not an accurate check, but good enough  https://bugs.eclipse.org/bugs/show_bug.cgi?id=350612
		if (DEBUG)
			System.out.println("Index file is corrupted " + this.indexLocation); //$NON-NLS-1$
		throw new IOException("Index file is corrupted " + this.indexLocation); //$NON-NLS-1$
	}
	char[] previousCategory = null;
	int offset = -1;

		}
	}
}
private void readStreamBuffer(InputStream stream) throws IOException {
	// if we're about to read a known amount at the end of the existing buffer, but it does not completely fit
	// so we need to shift the remaining bytes to be read, and fill the buffer from the stream
	if (this.bufferEnd < this.streamBuffer.length) {
		if (stream.available() == 0)
			return; // we're at the end of the stream - nothing left to read
	}

	int bytesInBuffer = this.bufferEnd - this.bufferIndex;
	if (bytesInBuffer > 0)

 * @exception  UTFDataFormatException  if the bytes do not represent a
 *               valid UTF-8 encoding of a Unicode string.
 */
private char[] readStreamChars(InputStream stream) throws IOException {
	// read chars array length
	if (stream != null && this.bufferIndex + 2 >= this.bufferEnd)
		readStreamBuffer(stream);

		// how many characters can be decoded without refilling the buffer?
		int charsInBuffer = i + ((this.bufferEnd - this.bufferIndex) / 3);
		// all the characters must already be in the buffer if we're at the end of the stream
		if (charsInBuffer > length || stream == null  || (this.bufferEnd != this.streamBuffer.length && stream.available() == 0))
			charsInBuffer = length;
		while (i < charsInBuffer) {
			byte b = this.streamBuffer[this.bufferIndex++];

	}
	return word;
}
private int[] readStreamDocumentArray(InputStream stream, int arraySize) throws IOException {
	int[] indexes = new int[arraySize];
	if (arraySize == 0) return indexes;


	}
	return indexes;
}
private int readStreamInt(InputStream stream) throws IOException {
	if (this.bufferIndex + 4 >= this.bufferEnd) {
		readStreamBuffer(stream);
	}

}
private void writeOffsetToHeader(int offsetToHeader) throws IOException {
	if (offsetToHeader > 0) {
		RandomAccessFile file = new RandomAccessFile(this.indexLocation.getIndexFile(), "rw"); //$NON-NLS-1$
		try {
			file.seek(this.headerInfoOffset); // offset to position in header
			file.writeInt(offsetToHeader);




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.core.index;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

public class FileIndexLocation extends IndexLocation {
	File indexFile;

	public FileIndexLocation(File file) {
		super(file);
		this.indexFile = file;
	}

	public FileIndexLocation(URL url, File file) {
		super(url);
		this.indexFile = file;
	}

	public FileIndexLocation(File file, boolean participantIndex) {
		this(file);
		this.participantIndex = true;
	}

	public boolean createNewFile() throws IOException {
		return this.indexFile.createNewFile();
	}

	public boolean delete() {
		return this.indexFile.delete();
	}

	public boolean equals(Object other) {
		if (!(other instanceof FileIndexLocation)) return false;
		return this.indexFile.equals(((FileIndexLocation) other).indexFile);
	}

	public boolean exists() {
		return this.indexFile.exists();
	}

	public String fileName() {
		return this.indexFile.getName();
	}
	
	public File getIndexFile() {
		return this.indexFile;
	}

	InputStream getInputStream() throws IOException {
		return new FileInputStream(this.indexFile);
	}

	public String getCanonicalFilePath() {
		try {
			return this.indexFile.getCanonicalPath();
		} catch (IOException e) {
			// ignore
		}
		return null;
	}

	public int hashCode() {
		return this.indexFile.hashCode();
	}

	public long lastModified() {
		return this.indexFile.lastModified();
	}

	public long length() {
		return this.indexFile.length();
	}

	public boolean startsWith(IPath path) {
		try {
			return path.isPrefixOf(new Path(this.indexFile.getCanonicalPath()));
		} catch (IOException e) {
			return false;
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

}


public Index(IndexLocation location, String containerPath, boolean reuseExistingFile) throws IOException {
	this.containerPath = containerPath;
	this.monitor = new ReadWriteMonitor();

	this.memoryIndex = new MemoryIndex();
	this.diskIndex = new DiskIndex(location);
	this.diskIndex.initialize(reuseExistingFile);
	if (reuseExistingFile) this.separator = this.diskIndex.separator;
}

	return documentPath.substring(index + 1);
}
public File getIndexFile() {
	return this.diskIndex == null ? null : this.diskIndex.indexLocation.getIndexFile();
}
public IndexLocation getIndexLocation() {
	return this.diskIndex == null ? null : this.diskIndex.indexLocation;
}
public long getIndexLastModified() {
	return this.diskIndex == null? -1 : this.diskIndex.indexLocation.lastModified();
}
public boolean hasChanged() {
	return this.memoryIndex.hasChanged();

 */
public void reset() throws IOException {
	this.memoryIndex = new MemoryIndex();
	this.diskIndex = new DiskIndex(this.diskIndex.indexLocation);
	this.diskIndex.initialize(false/*do not reuse the index file*/);
}
public void save() throws IOException {




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.core.index;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;

import java.net.MalformedURLException;
import java.net.URL;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;

/**
 * The location of the index files are represented as {@link IndexLocation}
 * 
 * This is an abstract class to allow different implementation for a jar entry and a file
 * on the disk. Some of these functions could mean different for a jar entry or a file
 * 
 */
public abstract class IndexLocation {
	
	public static IndexLocation createIndexLocation(URL url) {
		URL localUrl;
		try {
			localUrl = FileLocator.resolve(url);
		} catch (IOException e) {
			return null;
		}
		if (localUrl.getProtocol().equals("file")) { //$NON-NLS-1$
			return new FileIndexLocation(url, new File(localUrl.getPath()));
		}
		return new JarIndexLocation(url, localUrl);
	}
	
	private final URL url; // url of the given index location

	/**
	 * Set to true if this index location is of an index file specified
	 * by a participant through 
	 * {@link org.eclipse.jdt.core.search.SearchParticipant#scheduleDocumentIndexing}
	 */
	protected boolean participantIndex;
	
	protected IndexLocation(File file) {
		URL tempUrl = null;
		try {
			tempUrl = file.toURI().toURL();
		} catch (MalformedURLException e) {
			// should not happen
		}
		this.url = tempUrl;
	}
	
	public IndexLocation(URL url) {
		this.url = url;
	}

	/**
	 * Closes any open streams.
	 */
	public void close() {
		// default nothing to do
	}

	/**
	 * Creates a new file for the given index location
	 * @return true if the file is created
	 * @throws IOException
	 */
	public abstract boolean createNewFile() throws IOException;

	public abstract boolean delete();

	public abstract boolean exists();
	
	public abstract String fileName();

	/**
	 * @return the canonical file path if the location is a file or null otherwise
	 */
	public abstract String getCanonicalFilePath();

	public abstract File getIndexFile();

	abstract InputStream getInputStream() throws IOException;

	public URL getUrl() {
		return this.url;
	}

	public int hashCode() {
		return this.url.hashCode();
	}

	public boolean isParticipantIndex() {
		return this.participantIndex;
	}

	/**
	 * @return the last modified time if the location is a file or -1 otherwise
	 */
	public abstract long lastModified();

	/**
	 * @return the length of the file if the location is a file or -1 otherwise
	 */
	public abstract long length();

	public abstract boolean startsWith(IPath path);

	public String toString() {
		return this.url.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.core.index;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

public class JarIndexLocation extends IndexLocation {
	private JarFile jarFile = null;
	private JarEntry jarEntry = null;
	private URL localUrl;

	public JarIndexLocation(URL url, URL localUrl2) {
		super(url);
		this.localUrl = localUrl2;
	}

	public boolean createNewFile() throws IOException {
		return false;
	}

	public void close() {
		if (this.jarFile != null) {
			try {
				this.jarFile.close();
			} catch (IOException e) {
				// ignore
			}
			this.jarFile = null;
		}
	}

	public boolean delete() {
		return false;
	}

	public boolean equals(Object other) {
		if (!(other instanceof JarIndexLocation)) return false;
		return this.localUrl.equals(((JarIndexLocation) other).localUrl);
	}

	public boolean exists() {
		try {
			if (this.jarFile == null) {
				JarURLConnection connection = (JarURLConnection) this.localUrl.openConnection();
				JarFile file = connection.getJarFile();
				if (file == null)
					return false;
				file.close();
			}
		} catch (IOException e) {
			return false;
		}
		return true;
	}

	public String fileName() {
		return null;
	}

	public File getIndexFile() {
		return null;
	}

	InputStream getInputStream() throws IOException {
		if (this.jarFile == null) {
			JarURLConnection connection = (JarURLConnection) this.localUrl.openConnection();
			this.jarFile = connection.getJarFile();
			this.jarEntry = connection.getJarEntry();
		}
		if (this.jarFile == null || this.jarEntry == null)
			return null;
		return this.jarFile.getInputStream(this.jarEntry);
	}

	public String getCanonicalFilePath() {
		return null;
	}

	public long lastModified() {
		return -1;
	}

	public long length() {
		return -1;
	}

	public boolean startsWith(IPath path) {
		return (path.isPrefixOf(new Path(this.localUrl.getPath())));
	}

}




import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.core.builder.ReferenceCollection;
import org.eclipse.jdt.internal.core.builder.State;
import org.eclipse.jdt.internal.core.index.IndexLocation;
import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
import org.eclipse.jdt.internal.core.search.matching.MatchLocator;
import org.eclipse.jdt.internal.core.search.matching.MethodPattern;

public class IndexSelector {
	IJavaSearchScope searchScope;
	SearchPattern pattern;
	IndexLocation[] indexLocations; // cache of the keys for looking index up

public IndexSelector(
		IJavaSearchScope searchScope,

	}

	locations.remove(null); // Ensure no nulls
	this.indexLocations = (IndexLocation[]) locations.toArray(new IndexLocation[locations.size()]);
}

public IndexLocation[] getIndexLocations() {
	if (this.indexLocations == null) {
		initializeIndexLocations();
	}




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.core.runtime.*;
import org.eclipse.jdt.core.search.*;
import org.eclipse.jdt.internal.core.index.IndexLocation;
import org.eclipse.jdt.internal.core.search.indexing.BinaryIndexer;
import org.eclipse.jdt.internal.core.search.indexing.SourceIndexer;
import org.eclipse.jdt.internal.core.search.matching.MatchLocator;

	 * @see org.eclipse.jdt.core.search.SearchParticipant#selectIndexes(org.eclipse.jdt.core.search.SearchQuery, org.eclipse.jdt.core.search.SearchContext)
	 */
	public IPath[] selectIndexes(SearchPattern pattern, IJavaSearchScope scope) {
		IndexSelector selector = (IndexSelector) this.indexSelector.get();
		if (selector == null) {
			selector = new IndexSelector(scope, pattern);
			this.indexSelector.set(selector);
		}
		IndexLocation[] urls = selector.getIndexLocations();
		IPath[] paths = new IPath[urls.length];
		for (int i = 0; i < urls.length; i++) {
			paths[i] = new Path(urls[i].getIndexFile().getPath());
		}
		return paths;
	}

	public IndexLocation[] selectIndexURLs(SearchPattern pattern, IJavaSearchScope scope) {
		IndexSelector selector = (IndexSelector) this.indexSelector.get();
		if (selector == null) {
			selector = new IndexSelector(scope, pattern);




import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jdt.core.search.*;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.index.FileIndexLocation;
import org.eclipse.jdt.internal.core.index.Index;
import org.eclipse.jdt.internal.core.index.IndexLocation;
import org.eclipse.jdt.internal.core.search.indexing.ReadWriteMonitor;
import org.eclipse.jdt.internal.core.search.matching.MatchLocator;
import org.eclipse.jdt.internal.core.search.processing.IJob;

}
public Index[] getIndexes(IProgressMonitor progressMonitor) {
	// acquire the in-memory indexes on the fly
	IndexLocation[] indexLocations;
	int length;
	if (this.participant instanceof JavaSearchParticipant) {
		indexLocations = ((JavaSearchParticipant)this.participant).selectIndexURLs(this.pattern, this.scope);
		length = indexLocations.length;
	} else {
		IPath[] paths = this.participant.selectIndexes(this.pattern, this.scope);
		length = paths.length;
		indexLocations = new IndexLocation[paths.length];
		for (int i = 0, len = paths.length; i < len; i++) {
			indexLocations[i] = new FileIndexLocation(paths[i].toFile(), true);
		}
	}
	Index[] indexes = JavaModelManager.getIndexManager().getIndexes(indexLocations, progressMonitor);
	this.areIndexesReady = indexes.length == length;
	return indexes;




import org.eclipse.jdt.internal.compiler.util.Util;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.index.Index;
import org.eclipse.jdt.internal.core.index.IndexLocation;
import org.eclipse.jdt.internal.core.search.JavaSearchDocument;
import org.eclipse.jdt.internal.core.search.processing.JobManager;


	private static final char JAR_SEPARATOR = IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR.charAt(0);
	IFile resource;
	Scanner scanner;
	private IndexLocation indexFileURL;

	public AddJarFileToIndex(IFile resource, IndexLocation indexFile, IndexManager manager) {
		super(resource.getFullPath(), manager);
		this.resource = resource;
		this.indexFileURL = indexFile;
	}
	public AddJarFileToIndex(IPath jarPath, IndexLocation indexFile, IndexManager manager) {
		// external JAR scenario - no resource
		super(jarPath, manager);
		this.indexFileURL = indexFile;

					return false;
				}
				index.separator = JAR_SEPARATOR;
				IPath indexPath = null;
				IndexLocation indexLocation;
				if ((indexLocation = index.getIndexLocation()) != null) {
					indexPath = new Path(indexLocation.getCanonicalFilePath());
				}
				for (Enumeration e = zip.entries(); e.hasMoreElements();) {
					if (this.isCancelled) {
						if (JobManager.VERBOSE)




import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchParticipant;
import org.eclipse.jdt.internal.compiler.util.Util;
import org.eclipse.jdt.internal.core.index.FileIndexLocation;
import org.eclipse.jdt.internal.core.index.Index;
import org.eclipse.jdt.internal.core.index.IndexLocation;
import org.eclipse.jdt.internal.core.search.JavaSearchDocument;

public class DefaultJavaIndexer {

		if (!f.exists()) {
			throw new FileNotFoundException(pathToJar + " not found"); //$NON-NLS-1$
		}
		IndexLocation indexLocation = new FileIndexLocation(new File(pathToIndexFile));
		Index index = new Index(indexLocation, pathToJar, false /*reuse index file*/);
		SearchParticipant participant = SearchEngine.getDefaultSearchParticipant();
		index.separator = JAR_SEPARATOR;
		ZipFile zip = new ZipFile(pathToJar);

Lines 107-113 Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/indexing/IndexAllProject.java (-1 / +1 lines)
107	for (int i = 0; i < max; i++)	107	for (int i = 0; i < max; i++)
108	indexedFileNames.put(paths[i], DELETED);	108	indexedFileNames.put(paths[i], DELETED);
109	}	109	}
110	final long indexLastModified = max == 0 ? 0L : index.getIndexFile().lastModified();	110	final long indexLastModified = max == 0 ? 0L : index.getIndexLastModified();
111		111
112	IWorkspaceRoot root = this.project.getWorkspace().getRoot();	112	IWorkspaceRoot root = this.project.getWorkspace().getRoot();
113	for (int i = 0; i < sourceEntriesNumber; i++) {	113	for (int i = 0; i < sourceEntriesNumber; i++) {

Lines 80-86 Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/indexing/IndexBinaryFolder.java (-1 / +1 lines)
80	for (int i = 0; i < max; i++) {	80	for (int i = 0; i < max; i++) {
81	indexedFileNames.put(paths[i], DELETED);	81	indexedFileNames.put(paths[i], DELETED);
82	}	82	}
83	final long indexLastModified = index.getIndexFile().lastModified();	83	final long indexLastModified = index.getIndexLastModified();
84	this.folder.accept(	84	this.folder.accept(
85	new IResourceProxyVisitor() {	85	new IResourceProxyVisitor() {
86	public boolean visit(IResourceProxy proxy) throws CoreException {	86	public boolean visit(IResourceProxy proxy) throws CoreException {




import java.util.zip.CRC32;

import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;

	public synchronized void aboutToUpdateIndex(IPath containerPath, Integer newIndexState) {
	// newIndexState is either UPDATING_STATE or REBUILDING_STATE
	// must tag the index as inconsistent, in case we exit before the update job is started
	IndexLocation indexLocation = computeIndexLocation(containerPath);
	Object state = getIndexStates().get(indexLocation);
	Integer currentIndexState = state == null ? UNKNOWN_STATE : (Integer) state;
	if (currentIndexState.compareTo(REBUILDING_STATE) >= 0) return; // already rebuilding the index

	if (JavaCore.getPlugin() == null) return;
	SearchParticipant participant = SearchEngine.getDefaultSearchParticipant();
	SearchDocument document = participant.getDocument(resource.getFullPath().toString());
	IndexLocation indexLocation = computeIndexLocation(containerPath);
	scheduleDocumentIndexing(document, containerPath, indexLocation, participant);
}
/**

	SearchParticipant participant = SearchEngine.getDefaultSearchParticipant();
	SearchDocument document = participant.getDocument(resource.getFullPath().toString());
	document.setParser(parser);
	IndexLocation indexLocation = computeIndexLocation(containerPath);
	scheduleDocumentIndexing(document, containerPath, indexLocation, participant);
}
/*

	PatternSearchJob job = new PatternSearchJob(null, SearchEngine.getDefaultSearchParticipant(), scope, null);
	Index[] selectedIndexes = job.getIndexes(null);
	for (int i = 0, l = selectedIndexes.length; i < l; i++) {
		IndexLocation IndexLocation = selectedIndexes[i].getIndexLocation();
		knownPaths.add(IndexLocation);
	}

	if (this.indexStates != null) {
		Object[] keys = this.indexStates.keyTable;
		IndexLocation[] locations = new IndexLocation[this.indexStates.elementSize];
		int count = 0;
		for (int i = 0, l = keys.length; i < l; i++) {
			IndexLocation key = (IndexLocation) keys[i];
			if (key != null && !knownPaths.includes(key))
				locations[count++] = key;
		}
		if (count > 0)

	}
	deleteIndexFiles(knownPaths);
}
public synchronized IndexLocation computeIndexLocation(IPath containerPath) {
	IndexLocation indexLocation = (IndexLocation) this.indexLocations.get(containerPath);
	if (indexLocation == null) {
		String pathString = containerPath.toOSString();
		CRC32 checksumCalculator = new CRC32();

		if (VERBOSE)
			Util.verbose("-> index name for " + pathString + " is " + fileName); //$NON-NLS-1$ //$NON-NLS-2$
		// to share the indexLocation between the indexLocations and indexStates tables, get the key from the indexStates table
		indexLocation = (IndexLocation) getIndexStates().getKey(new FileIndexLocation(new File(getSavedIndexesDirectory(), fileName)));
		this.indexLocations.put(containerPath, indexLocation);
	}
	return indexLocation;


	for (int i = 0, l = indexesFiles.length; i < l; i++) {
		String fileName = indexesFiles[i].getAbsolutePath();
		if (pathsToKeep != null && pathsToKeep.includes(new FileIndexLocation(indexesFiles[i]))) continue;
		String suffix = ".index"; //$NON-NLS-1$
		if (fileName.regionMatches(true, fileName.length() - suffix.length(), suffix, 0, suffix.length())) {
			if (VERBOSE || DEBUG)

/*
 * Creates an empty index at the given location, for the given container path, if none exist.
 */
public synchronized void ensureIndexExists(IndexLocation indexLocation, IPath containerPath) {
	SimpleLookupTable states = getIndexStates();
	Object state = states.get(indexLocation);
	if (state == null) {

 * @param indexLocation The path of the index file
 * @return The corresponding index or <code>null</code> if not found
 */
public synchronized Index getIndex(IndexLocation indexLocation) {
	return (Index) this.indexes.get(indexLocation); // is null if unknown, call if the containerPath must be computed
}
/**

 * Warning: Does not check whether index is consistent (not being used)
 */
public synchronized Index getIndex(IPath containerPath, boolean reuseExistingFile, boolean createIfMissing) {
	IndexLocation indexLocation = computeIndexLocation(containerPath);
	return getIndex(containerPath, indexLocation, reuseExistingFile, createIfMissing);
}
/**

 *
 * Warning: Does not check whether index is consistent (not being used)
 */
public synchronized Index getIndex(IPath containerPath, IndexLocation indexLocation, boolean reuseExistingFile, boolean createIfMissing) {
	// Path is already canonical per construction
	Index index = getIndex(indexLocation);
	if (index == null) {


		// index isn't cached, consider reusing an existing index file
		String containerPathString = containerPath.getDevice() == null ? containerPath.toString() : containerPath.toOSString();
		String indexLocationString = indexLocation.toOSString();
		if (reuseExistingFile) {
			if (indexLocation.exists()) { // check before creating index so as to avoid creating a new empty index if file is missing
			if (indexFile.exists()) { // check before creating index so as to avoid creating a new empty index if file is missing
				try {
					index = new Index(indexLocation, containerPathString, true /*reuse index file*/);
					this.indexes.put(indexLocation, index);
					return index;
				} catch (IOException e) {
					// failed to read the existing file or its no longer compatible
					if (currentIndexState != REBUILDING_STATE && currentIndexState != REUSE_STATE) { // rebuild index if existing file is corrupt, unless the index is already being rebuilt
						if (VERBOSE)
							Util.verbose("-> cannot reuse existing index: "+indexLocation+" path: "+containerPathString); //$NON-NLS-1$ //$NON-NLS-2$
						rebuildIndex(indexLocation, containerPath);
						return null;
					}

		if (createIfMissing) {
			try {
				if (VERBOSE)
					Util.verbose("-> create empty index: "+indexLocation+" path: "+containerPathString); //$NON-NLS-1$ //$NON-NLS-2$
				index = new Index(indexLocation, containerPathString, false /*do not reuse index file*/);
				this.indexes.put(indexLocation, index);
				return index;
			} catch (IOException e) {
				if (VERBOSE)
					Util.verbose("-> unable to create empty index: "+indexLocation+" path: "+containerPathString); //$NON-NLS-1$ //$NON-NLS-2$
				// The file could not be created. Possible reason: the project has been deleted.
				return null;
			}

 * @param locations The list of of the index files path
 * @return The corresponding indexes list.
 */
public Index[] getIndexes(IndexLocation[] locations, IProgressMonitor progressMonitor) {
	// acquire the in-memory indexes on the fly
	int length = locations.length;
	Index[] locatedIndexes = new Index[length];

			throw new OperationCanceledException();
		}
		// may trigger some index recreation work
		IndexLocation indexLocation = locations[i];
		Index index = getIndex(indexLocation);
		if (index == null) {
			// only need containerPath if the index must be built

					index = null;
				}
			} else {
				if (indexLocation.isParticipantIndex() && indexLocation.exists()) { // the index belongs to non-jdt search participant
					try {
						IPath container = getParticipantsContainer(indexLocation);
						if (container != null) {
							index = new Index(indexLocation, container.toOSString(), true /*reuse index file*/);
							this.indexes.put(indexLocation, index);
								this.indexes.put(indexLocation, index);
							}
						} catch (IOException e) {
							// ignore
						}
					} catch (IOException e) {
						// ignore
					}
				}
			}
		}

	return locatedIndexes;
}
public synchronized Index getIndexForUpdate(IPath containerPath, boolean reuseExistingFile, boolean createIfMissing) {
	IndexLocation indexLocation = computeIndexLocation(containerPath);
	if (getIndexStates().get(indexLocation) == REBUILDING_STATE)
		return getIndex(containerPath, indexLocation, reuseExistingFile, createIfMissing);


	if (this.indexStates != null) return this.indexStates;

	this.indexStates = new SimpleLookupTable();
	File indexesDirectoryPath = getSavedIndexesDirectory();
	char[][] savedNames = readIndexState(getJavaPluginWorkingLocation().toOSString());
	if (savedNames != null) {
		for (int i = 1, l = savedNames.length; i < l; i++) { // first name is saved signature, see readIndexState()
			char[] savedName = savedNames[i];
			if (savedName.length > 0) {
				IndexLocation indexLocation = new FileIndexLocation(new File(indexesDirectoryPath, String.valueOf(savedName))); // shares indexesDirectoryPath's segments
				if (VERBOSE)
					Util.verbose("Reading saved index file " + indexLocation); //$NON-NLS-1$
				this.indexStates.put(indexLocation, SAVED_STATE);

	}
	return this.indexStates;
}
private IPath getParticipantsContainer(IndexLocation indexLocation) {
	if (this.participantsContainers == null) {
		readParticipantsIndexNamesFile();
	}

 */
public void indexLibrary(IPath path, IProject requestingProject, URL indexURL) {
	// requestingProject is no longer used to cancel jobs but leave it here just in case
	IndexLocation indexFile = indexURL != null ? IndexLocation.createIndexLocation(indexURL): null;
	if (indexURL != null)  {
		try {
			indexFile = new Path(FileLocator.resolve(indexURL).getPath());
		} catch (IOException e) {
			if (VERBOSE)
				Util.verbose("-> cannot resolve the url : "+ indexURL + " specified for " + path); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}
	if (JavaCore.getPlugin() == null) return;
	IndexRequest request = null;
	Object target = JavaModel.getTarget(path, true);

		request(request);
}

synchronized boolean addIndex(IPath containerPath, IndexLocation indexFile) {
	this.indexStates.put(indexFile, REUSE_STATE);
	this.indexLocations.put(containerPath, indexFile);
	Index index = getIndex(containerPath, indexFile, true, false);
	if (index == null) {
		indexFile.close();
		this.indexLocations.put(containerPath, null);
		return false;
	}

	request(new AddFolderToIndex(sourceFolder, project, inclusionPatterns, exclusionPatterns, this));
}
public synchronized void jobWasCancelled(IPath containerPath) {
	IndexLocation indexLocation = computeIndexLocation(containerPath);
	Index index = getIndex(indexLocation);
	if (index != null) {
		index.monitor = null;

	}
	return null;
}
private void rebuildIndex(IndexLocation indexLocation, IPath containerPath) {
	Object target = JavaModel.getTarget(containerPath, true);
	if (target == null) return;


	String containerPathString = containerPath.getDevice() == null ? containerPath.toString() : containerPath.toOSString();
	try {
		// Path is already canonical
		IndexLocation indexLocation = computeIndexLocation(containerPath);
		Index index = getIndex(indexLocation);
		ReadWriteMonitor monitor = index == null ? null : index.monitor;

		if (VERBOSE)
			Util.verbose("-> recreating index: "+indexLocation+" for path: "+containerPathString); //$NON-NLS-1$ //$NON-NLS-2$
		index = new Index(indexLocation, containerPathString, false /*do not reuse index file*/);
		this.indexes.put(indexLocation, index);
		index.monitor = monitor;
		return index;

public synchronized void removeIndex(IPath containerPath) {
	if (VERBOSE || DEBUG)
		Util.verbose("removing index " + containerPath); //$NON-NLS-1$
	IndexLocation indexLocation = computeIndexLocation(containerPath);
	Index index = getIndex(indexLocation);
	File indexFile = null;
	if (index != null) {

		indexFile = index.getIndexFile();
	}
	if (indexFile == null)
		indexFile = indexLocation.getIndexFile(); // index is not cached yet, but still want to delete the file
	if (this.indexStates.get(indexLocation) == REUSE_STATE) {
		indexLocation.close();
		this.indexLocations.put(containerPath, null);
	} else if (indexFile != null && indexFile.exists()) {
		if (DEBUG)
			Util.verbose("removing index file " + indexFile); //$NON-NLS-1$
		indexFile.delete();

		Util.verbose("removing index path " + path); //$NON-NLS-1$
	Object[] keyTable = this.indexes.keyTable;
	Object[] valueTable = this.indexes.valueTable;
	IndexLocation[] locations = null;
	int max = this.indexes.elementSize;
	int count = 0;
	for (int i = 0, l = keyTable.length; i < l; i++) {
		IndexLocation indexLocation = (IndexLocation) keyTable[i];
		if (indexLocation == null)
			continue;
		if (indexLocation.startsWith(path)) {
			Index index = (Index) valueTable[i];
			index.monitor = null;
			if (locations == null)
				locations = new IndexLocation[max];
			locations[count++] = indexLocation;
			if (this.indexStates.get(indexLocation) == REUSE_STATE) {
				indexLocation.close();
			} else {
				if (DEBUG)
					Util.verbose("removing index file " + indexLocation); //$NON-NLS-1$
				indexLocation.delete();
			}
		} else {
			max--;

	String containerPathString = containerPath.getDevice() == null ? containerPath.toString() : containerPath.toOSString();
	try {
		// Path is already canonical
		IndexLocation indexLocation = computeIndexLocation(containerPath);
		Index index = getIndex(indexLocation);
		if (VERBOSE) {
			Util.verbose("-> reseting index: "+indexLocation+" for path: "+containerPathString); //$NON-NLS-1$ //$NON-NLS-2$

	// must have permission to write from the write monitor
	if (index.hasChanged()) {
		if (VERBOSE)
			Util.verbose("-> saving index " + index.getIndexLocation()); //$NON-NLS-1$
		index.save();
	}
	synchronized (this) {

					if (((IndexRequest) job).containerPath.equals(containerPath)) return;
			}
		}
		IndexLocation indexLocation = computeIndexLocation(containerPath);
		updateIndexState(indexLocation, SAVED_STATE);
	}
}

	}
	this.needToSave = !allSaved;
}
public void scheduleDocumentIndexing(final SearchDocument searchDocument, IPath container, final IndexLocation indexLocation, final SearchParticipant searchParticipant) {
	request(new IndexRequest(container, this) {
		public boolean execute(IProgressMonitor progressMonitor) {
			if (this.isCancelled || progressMonitor != null && progressMonitor.isCanceled()) return true;


			try {
				monitor.enterWrite(); // ask permission to write
				indexDocument(searchDocument, searchParticipant, index, new Path(indexLocation.getCanonicalFilePath()));
			} finally {
				monitor.exitWrite(); // free write lock
			}

				// First line is DiskIndex signature  (see writeParticipantsIndexNamesFile())
				if (DiskIndex.SIGNATURE.equals(new String(names[0]))) {					
					for (int i = 1, l = names.length-1 ; i < l ; i+=2) {
						IndexLocation indexLocation = new FileIndexLocation(new File(new String(names[i])), true);
						containers.put(indexLocation, new Path(new String(names[i+1])));
					}
				}				
			}

	this.participantsContainers = containers;
	return;
}
private synchronized void removeIndexesState(IndexLocation[] locations) {
	getIndexStates(); // ensure the states are initialized
	int length = locations.length;
	boolean changed = false;


	writeSavedIndexNamesFile();
}
private synchronized void updateIndexState(IndexLocation indexLocation, Integer indexState) {
	if (indexLocation == null)
		throw new IllegalArgumentException();

	getIndexStates(); // ensure the states are initialized

	}

}
public void updateParticipant(IPath indexPath, IPath containerPath) {
	if (this.participantsContainers == null) {
		readParticipantsIndexNamesFile();
	}
	IndexLocation indexLocation = new FileIndexLocation(indexPath.toFile(), true);
	if (this.participantsContainers.get(indexLocation) == null) {
		this.participantsContainers.put(indexLocation, containerPath);
		this.participantUpdated  = true;

		Object[] indexFiles = this.participantsContainers.keyTable;
		Object[] containers = this.participantsContainers.valueTable;
		for (int i = 0, l = indexFiles.length; i < l; i++) {
			IndexLocation indexFile = (IndexLocation)indexFiles[i];
			if (indexFile != null) {
				writer.write(indexFile.getIndexFile().getPath());
				writer.write('\n');
				writer.write(((IPath)containers[i]).toOSString());
				writer.write('\n');

		Object[] keys = this.indexStates.keyTable;
		Object[] states = this.indexStates.valueTable;
		for (int i = 0, l = states.length; i < l; i++) {
			IndexLocation key = (IndexLocation) keys[i];
			if (key != null && states[i] == SAVED_STATE) {
				writer.write(key.fileName());
				writer.write('\n');
			}
		}

Return to bug 356620

Lines 1348-1353 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/util/Util.java (+28 lines)
1348	}	1348	}
1349	}	1349	}
1350	}	1350	}
		1351
		1352	/**
		1353	* Zips the given files into the given jar. All the files are kept at the root of the zip.
		1354	*/
		1355	public static void zipFiles(File[] files, String zipPath) throws IOException {
		1356	File zipFile = new File(zipPath);
		1357	if (zipFile.exists()) {
		1358	if (!delete(zipFile))
		1359	throw new IOException("Could not delete " + zipPath);
		1360	// ensure the new zip file has a different timestamp than the previous one
		1361	int timeToWait = 1000; // some platform (like Linux) have a 1s granularity)
		1362	waitAtLeast(timeToWait);
		1363	} else {
		1364	zipFile.getParentFile().mkdirs();
		1365	}
		1366	ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(zipFile));
		1367	try {
		1368	for (int i = 0, length = files.length; i < length; i++) {
		1369	File file = files[i];
		1370	ZipEntry entry = new ZipEntry(file.getName());
		1371	zip.putNextEntry(entry);
		1372	zip.write(org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(file));
		1373	zip.closeEntry();
		1374	}
		1375	} finally {
		1376	zip.close();
		1377	}
		1378	}
1351	/**	1379	/**
1352	* Returns the compilation errors / warnings for the given CompilationResult.	1380	* Returns the compilation errors / warnings for the given CompilationResult.
1353	*	1381	*

Lines 27-32 Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/IndexSelector.java (-3 / +4 lines)
27	import org.eclipse.jdt.internal.core.JavaProject;	27	import org.eclipse.jdt.internal.core.JavaProject;
28	import org.eclipse.jdt.internal.core.builder.ReferenceCollection;	28	import org.eclipse.jdt.internal.core.builder.ReferenceCollection;
29	import org.eclipse.jdt.internal.core.builder.State;	29	import org.eclipse.jdt.internal.core.builder.State;
		30	import org.eclipse.jdt.internal.core.index.IndexLocation;
30	import org.eclipse.jdt.internal.core.search.indexing.IndexManager;	31	import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
31	import org.eclipse.jdt.internal.core.search.matching.MatchLocator;	32	import org.eclipse.jdt.internal.core.search.matching.MatchLocator;
32	import org.eclipse.jdt.internal.core.search.matching.MethodPattern;	33	import org.eclipse.jdt.internal.core.search.matching.MethodPattern;
Lines 38-44 Link Here
38	public class IndexSelector {	39	public class IndexSelector {
39	IJavaSearchScope searchScope;	40	IJavaSearchScope searchScope;
40	SearchPattern pattern;	41	SearchPattern pattern;
41	IPath[] indexLocations; // cache of the keys for looking index up	42	IndexLocation[] indexLocations; // cache of the keys for looking index up
42		43
43	public IndexSelector(	44	public IndexSelector(
44	IJavaSearchScope searchScope,	45	IJavaSearchScope searchScope,
Lines 267-276 Link Here
267	}	268	}
268		269
269	locations.remove(null); // Ensure no nulls	270	locations.remove(null); // Ensure no nulls
270	this.indexLocations = (IPath[]) locations.toArray(new IPath[locations.size()]);	271	this.indexLocations = (IndexLocation[]) locations.toArray(new IndexLocation[locations.size()]);
271	}	272	}
272		273
273	public IPath[] getIndexLocations() {	274	public IndexLocation[] getIndexLocations() {
274	if (this.indexLocations == null) {	275	if (this.indexLocations == null) {
275	initializeIndexLocations();	276	initializeIndexLocations();
276	}	277	}

Lines 22-28 Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/indexing/DefaultJavaIndexer.java (-1 / +4 lines)
22	import org.eclipse.jdt.core.search.SearchEngine;	22	import org.eclipse.jdt.core.search.SearchEngine;
23	import org.eclipse.jdt.core.search.SearchParticipant;	23	import org.eclipse.jdt.core.search.SearchParticipant;
24	import org.eclipse.jdt.internal.compiler.util.Util;	24	import org.eclipse.jdt.internal.compiler.util.Util;
		25	import org.eclipse.jdt.internal.core.index.FileIndexLocation;
25	import org.eclipse.jdt.internal.core.index.Index;	26	import org.eclipse.jdt.internal.core.index.Index;
		27	import org.eclipse.jdt.internal.core.index.IndexLocation;
26	import org.eclipse.jdt.internal.core.search.JavaSearchDocument;	28	import org.eclipse.jdt.internal.core.search.JavaSearchDocument;
27		29
28	public class DefaultJavaIndexer {	30	public class DefaultJavaIndexer {
Lines 33-39 Link Here
33	if (!f.exists()) {	35	if (!f.exists()) {
34	throw new FileNotFoundException(pathToJar + " not found"); //$NON-NLS-1$	36	throw new FileNotFoundException(pathToJar + " not found"); //$NON-NLS-1$
35	}	37	}
36	Index index = new Index(pathToIndexFile, pathToJar, false /reuse index file/);	38	IndexLocation indexLocation = new FileIndexLocation(new File(pathToIndexFile));
		39	Index index = new Index(indexLocation, pathToJar, false /reuse index file/);
37	SearchParticipant participant = SearchEngine.getDefaultSearchParticipant();	40	SearchParticipant participant = SearchEngine.getDefaultSearchParticipant();
38	index.separator = JAR_SEPARATOR;	41	index.separator = JAR_SEPARATOR;
39	ZipFile zip = new ZipFile(pathToJar);	42	ZipFile zip = new ZipFile(pathToJar);

Lines 12-20 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaIndexTests.java (-2 / +100 lines)
12		12
13	import java.io.File;	13	import java.io.File;
14	import java.io.IOException;	14	import java.io.IOException;
		15	import java.net.URL;
15		16
16	import junit.framework.Test;	17	import junit.framework.Test;
17		18
		19	import org.eclipse.core.resources.IProject;
18	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
19	import org.eclipse.core.runtime.IPath;	21	import org.eclipse.core.runtime.IPath;
20	import org.eclipse.core.runtime.Path;	22	import org.eclipse.core.runtime.Path;
Lines 28-33 Link Here
28	import org.eclipse.jdt.core.JavaCore;	30	import org.eclipse.jdt.core.JavaCore;
29	import org.eclipse.jdt.core.index.*;	31	import org.eclipse.jdt.core.index.*;
30	import org.eclipse.jdt.core.search.SearchEngine;	32	import org.eclipse.jdt.core.search.SearchEngine;
		33	import org.eclipse.jdt.core.tests.util.Util;
31	import org.eclipse.jdt.internal.core.JavaModelManager;	34	import org.eclipse.jdt.internal.core.JavaModelManager;
32	import org.eclipse.jdt.internal.core.UserLibraryClasspathContainer;	35	import org.eclipse.jdt.internal.core.UserLibraryClasspathContainer;
33	import org.osgi.service.prefs.BackingStoreException;	36	import org.osgi.service.prefs.BackingStoreException;
Lines 709-716 Link Here
709	System.arraycopy(entries, 0, entries = new IClasspathEntry[length+1], 0, length);	712	System.arraycopy(entries, 0, entries = new IClasspathEntry[length+1], 0, length);
710	entries[length] = JavaCore.newContainerEntry(containerSuggestion.getPath());	713	entries[length] = JavaCore.newContainerEntry(containerSuggestion.getPath());
711	p.setRawClasspath(entries, null);	714	p.setRawClasspath(entries, null);
712
713	}	715	}
		716
714	public void testUserLibraryIndex() throws IOException, CoreException, BackingStoreException {	717	public void testUserLibraryIndex() throws IOException, CoreException, BackingStoreException {
715	String indexFilePath = getExternalResourcePath("Test.index");	718	String indexFilePath = getExternalResourcePath("Test.index");
716	String jarFilePath = getExternalResourcePath("Test.jar");	719	String jarFilePath = getExternalResourcePath("Test.jar");
Lines 759-765 Link Here
759	deleteProject("P");	762	deleteProject("P");
760	new File(indexFilePath).delete();	763	new File(indexFilePath).delete();
761	new File(jarFilePath).delete();	764	new File(jarFilePath).delete();
		765	}
		766	}
		767
		768	// Test that it works if the index file is in the jar file
		769	public void testIndexInJar() throws IOException, CoreException {
		770	String indexFilePath = getExternalResourcePath("Test.index");
		771	String jarFilePath = getExternalResourcePath("Test.jar");
		772	String indexZipPath = getExternalResourcePath("TestIndex.zip");
		773	try {
		774	createJar(new String[] {
		775	"pkg/Test.java",
		776	"package pkg;\n" +
		777	"public class Test {\n" +
		778	" protected Test(int i) {}\n" +
		779	"}"}, jarFilePath);
		780
		781	JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
		782	Util.zipFiles(new File[]{new File(indexFilePath)}, indexZipPath);
		783
		784	IJavaProject p = createJavaProject("P");
		785	Path libPath = new Path(jarFilePath);
		786	String url = "jar:file:/"+indexZipPath+"!/Test.index";
		787	IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, url);
		788	IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
		789	setClasspath(p, new IClasspathEntry[] {entry});
		790	waitUntilIndexesReady();
		791
		792	assertEquals(url,JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexLocation().getUrl().toString());
		793
		794	search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
		795	assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
		796
		797	simulateExitRestart();
		798	getJavaModel().refreshExternalArchives(null,null);
		799	waitUntilIndexesReady();
		800
		801	this.resultCollector = new JavaSearchResultCollector();
		802	assertEquals(url,JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexLocation().getUrl().toString());
		803	search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
		804	assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
		805	} finally {
		806	deleteProject("P");
		807	new File(indexZipPath).delete();
		808	new File(jarFilePath).delete();
762	}	809	}
763		810	}
		811
		812	// Test index file in platform
		813	public void testPlatformJarIndexFile() throws CoreException, IOException {
		814	String indexFilePath = null;
		815	String jarFilePath = getExternalResourcePath("Test.jar");
		816	String indexUrl = "platform:/resource/ForIndex/Test.index.zip!/Test.index";
		817	try {
		818	createJar(new String[] {
		819	"pkg/Test.java",
		820	"package pkg;\n" +
		821	"public class Test {\n" +
		822	" protected Test(int i) {}\n" +
		823	"}"}, jarFilePath);
		824
		825	IProject indexProj = createProject("ForIndex");
		826	indexFilePath = indexProj.getProject().getLocation().append("Test.index").toFile().getAbsolutePath();
		827	JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
		828	Util.zipFiles(new File[]{new File(indexFilePath)}, indexFilePath+".zip");
		829
		830	IJavaProject p = createJavaProject("P");
		831	Path libPath = new Path(jarFilePath);
		832	IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, indexUrl);
		833	IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
		834	setClasspath(p, new IClasspathEntry[] {entry});
		835	waitUntilIndexesReady();
		836
		837	search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
		838	assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
		839
		840	URL url = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexLocation().getUrl();
		841	assertEquals(indexUrl, url.toString());
		842
		843	simulateExitRestart();
		844	getJavaModel().refreshExternalArchives(null,null);
		845	waitUntilIndexesReady();
		846
		847	this.resultCollector = new JavaSearchResultCollector();
		848	search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
		849	assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
		850
		851	url = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexLocation().getUrl();
		852	assertEquals(indexUrl, url.toString());
		853	} finally {
		854	deleteProject("P");
		855	if (indexFilePath != null) {
		856	new File(indexFilePath).delete();
		857	new File(indexFilePath+".zip").delete();
		858	}
		859	new File(jarFilePath).delete();
		860	deleteProject("ForIndex");
		861	}
764	}	862	}
765	}	863	}

Added Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/index/FileIndexLocation.java (+98 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.core.index;
12
13	import java.io.File;
14	import java.io.FileInputStream;
15	import java.io.IOException;
16	import java.io.InputStream;
17	import java.net.URL;
18
19	import org.eclipse.core.runtime.IPath;
20	import org.eclipse.core.runtime.Path;
21
22	public class FileIndexLocation extends IndexLocation {
23	File indexFile;
24
25	public FileIndexLocation(File file) {
26	super(file);
27	this.indexFile = file;
28	}
29
30	public FileIndexLocation(URL url, File file) {
31	super(url);
32	this.indexFile = file;
33	}
34
35	public FileIndexLocation(File file, boolean participantIndex) {
36	this(file);
37	this.participantIndex = true;
38	}
39
40	public boolean createNewFile() throws IOException {
41	return this.indexFile.createNewFile();
42	}
43
44	public boolean delete() {
45	return this.indexFile.delete();
46	}
47
48	public boolean equals(Object other) {
49	if (!(other instanceof FileIndexLocation)) return false;
50	return this.indexFile.equals(((FileIndexLocation) other).indexFile);
51	}
52
53	public boolean exists() {
54	return this.indexFile.exists();
55	}
56
57	public String fileName() {
58	return this.indexFile.getName();
59	}
60
61	public File getIndexFile() {
62	return this.indexFile;
63	}
64
65	InputStream getInputStream() throws IOException {
66	return new FileInputStream(this.indexFile);
67	}
68
69	public String getCanonicalFilePath() {
70	try {
71	return this.indexFile.getCanonicalPath();
72	} catch (IOException e) {
73	// ignore
74	}
75	return null;
76	}
77
78	public int hashCode() {
79	return this.indexFile.hashCode();
80	}
81
82	public long lastModified() {
83	return this.indexFile.lastModified();
84	}
85
86	public long length() {
87	return this.indexFile.length();
88	}
89
90	public boolean startsWith(IPath path) {
91	try {
92	return path.isPrefixOf(new Path(this.indexFile.getCanonicalPath()));
93	} catch (IOException e) {
94	return false;
95	}
96	}
97
98	}

Lines 17-23 Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/PatternSearchJob.java (-2 / +15 lines)
17	import org.eclipse.core.runtime.OperationCanceledException;	17	import org.eclipse.core.runtime.OperationCanceledException;
18	import org.eclipse.jdt.core.search.*;	18	import org.eclipse.jdt.core.search.*;
19	import org.eclipse.jdt.internal.core.JavaModelManager;	19	import org.eclipse.jdt.internal.core.JavaModelManager;
		20	import org.eclipse.jdt.internal.core.index.FileIndexLocation;
20	import org.eclipse.jdt.internal.core.index.Index;	21	import org.eclipse.jdt.internal.core.index.Index;
		22	import org.eclipse.jdt.internal.core.index.IndexLocation;
21	import org.eclipse.jdt.internal.core.search.indexing.ReadWriteMonitor;	23	import org.eclipse.jdt.internal.core.search.indexing.ReadWriteMonitor;
22	import org.eclipse.jdt.internal.core.search.matching.MatchLocator;	24	import org.eclipse.jdt.internal.core.search.matching.MatchLocator;
23	import org.eclipse.jdt.internal.core.search.processing.IJob;	25	import org.eclipse.jdt.internal.core.search.processing.IJob;
Lines 76-83 Link Here
76	}	78	}
77	public Index[] getIndexes(IProgressMonitor progressMonitor) {	79	public Index[] getIndexes(IProgressMonitor progressMonitor) {
78	// acquire the in-memory indexes on the fly	80	// acquire the in-memory indexes on the fly
79	IPath[] indexLocations = this.participant.selectIndexes(this.pattern, this.scope);	81	IndexLocation[] indexLocations;
80	int length = indexLocations.length;	82	int length;
		83	if (this.participant instanceof JavaSearchParticipant) {
		84	indexLocations = ((JavaSearchParticipant)this.participant).selectIndexURLs(this.pattern, this.scope);
		85	length = indexLocations.length;
		86	} else {
		87	IPath[] paths = this.participant.selectIndexes(this.pattern, this.scope);
		88	length = paths.length;
		89	indexLocations = new IndexLocation[paths.length];
		90	for (int i = 0, len = paths.length; i < len; i++) {
		91	indexLocations[i] = new FileIndexLocation(paths[i].toFile(), true);
		92	}
		93	}
81	Index[] indexes = JavaModelManager.getIndexManager().getIndexes(indexLocations, progressMonitor);	94	Index[] indexes = JavaModelManager.getIndexManager().getIndexes(indexLocations, progressMonitor);
82	this.areIndexesReady = indexes.length == length;	95	this.areIndexesReady = indexes.length == length;
83	return indexes;	96	return indexes;