Attachment #207155 for bug #356620




        }
    }
}
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));
	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();
    }
	zip.close();
}
/**
 * Returns the compilation errors / warnings for the given CompilationResult.
 *




/*******************************************************************************
 * 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.core.tests.model;

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.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
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;

public class JavaIndexTests extends AbstractJavaSearchTests  {

	static {
		// TESTS_NAMES = new String[] {"testMultipleProjects"};
	}
	public JavaIndexTests(String name) {
		super(name);
	}

	public static Test suite() {
		return buildModelTestSuite(JavaIndexTests.class);
	}
	// Test that the index file is really generated.
	public void testGenerateIndex() throws IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			assertTrue(new File(indexFilePath).exists());
		} finally {
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// Test that the index file and the jar in held after the index is created
	public void testDeleteIndexedFile() {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			assertTrue("Could not delete the index file", new File(indexFilePath).delete());
			assertTrue("Could not delete the jar file", new File(jarFilePath).delete());
		} catch (IOException e) {
			assertFalse("Test failed", true);
		}
	}
	
	// Test that search works fine with the index file
	public void testUseIndex() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			long modified = new File(indexFilePath).lastModified();
			
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			
			waitUntilIndexesReady();
			
			// Test that specified index file is really used
			java.io.File indexFile = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexFile();
			assertEquals("Specified index file is not being used", indexFilePath,indexFile.toString());
			
			// Test that search works properly 
			search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
			
			// Ensure that the index file is not modified
			assertEquals(modified, new File(indexFilePath).lastModified());
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// Test that the same index file is used even after restarting
	public void testUseIndexAfterRestart() throws IOException, CoreException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			long modified = new File(indexFilePath).lastModified();
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			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");
			
			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");
			
			java.io.File indexFile = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexFile();
			assertEquals(indexFilePath,indexFile.toString());
			// Ensure that the file is not modified
			assertEquals(modified, new File(indexFilePath).lastModified());
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// Test that the same index file is used even after restarting
	public void testUseIndexInternalJarAfterRestart() throws IOException, CoreException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = "/P/Test.jar";
		try {
			IJavaProject p = createJavaProject("P");
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			long modified = new File(indexFilePath).lastModified();
			IPath libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			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("\\P\\Test.jar pkg.Test");
			
			simulateExitRestart();
			getJavaModel().refreshExternalArchives(null, null);
			waitUntilIndexesReady();
			
			this.resultCollector = new JavaSearchResultCollector();
			search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults("\\P\\Test.jar pkg.Test");
			
			java.io.File indexFile = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexFile();
			assertEquals(indexFilePath,indexFile.toString());
			// Ensure that the file is not modified
			assertEquals(modified, new File(indexFilePath).lastModified());
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
		}
	}
	
	// Test that a jar file that gets modified after the index is created doesn't return new changes. 
	// This behavior might have to be modified but.. 
	public void testModifyJarAfterIndex() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}", 
					"pkg/NewTest.java",
					"package pkg;\n" +
					"public class NewTest {\n" +
					"  protected NewTest(int i) {}\n" +
					"}"}, jarFilePath);
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			search("NewTest", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults("");
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}

	// test a non-existent index
	public void testNonExistentIndex() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			new File(indexFilePath).delete();
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			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");
			
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// test a non-existent index
	public void testNonExistentIndexRestart() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			
			new File(indexFilePath).delete();
			
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			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");
			
			java.io.File indexFile = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexFile();
			long modified = indexFile.lastModified();
			assertEquals(modified, indexFile.lastModified());
			
			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");
			
			indexFile = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexFile();
			assertEquals("Index File should not have got modified",modified, indexFile.lastModified());
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// test that if the index is not existent after restart, it should build up a new index
	public void testNonExistentIndexAfterRestart() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" + 
					"public class Test {\n" +
					"protected Test(int i) {}\n" + "}" 
					},jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			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");
			
			simulateExitRestart();
			File indexFile = new File(indexFilePath);
			indexFile.delete();
			assertTrue(!indexFile.exists());
			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");
			
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// test a non-existent index which becomes existent after restart
	public void testExistentIndexAfterRestart() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			
			File indexFile = new File(indexFilePath);
			indexFile.delete();
			assertTrue(!indexFile.exists());
			
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			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");
			
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			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");
			
			indexFile = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexFile();
			assertEquals(indexFilePath,indexFile.toString());
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// Test that the index file is not deletes when the project is deleted
	public void testDeleteProject() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			IJavaProject p = createJavaProject("P");
			createExternalFolder("externalLib");
			Path libPath = new Path(jarFilePath);
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			deleteProject("P");
			File f = new File(indexFilePath);
			assertTrue(f.exists());
		} finally {
			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 testPlatformIndexFile() throws CoreException, IOException {
		String indexFilePath = null;
		String jarFilePath = getExternalResourcePath("Test.jar");
		String indexUrl = "platform:/resource/P/Test.index";
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			
			IJavaProject p = createJavaProject("P");
			indexFilePath = p.getProject().getLocation().append("Test.index").toFile().getAbsolutePath();
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			long modified = new File(indexFilePath).lastModified();
			
			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());

			assertEquals(modified, new File(indexFilePath).lastModified());
		} finally {
			deleteProject("P");
			if (indexFilePath != null) new File(indexFilePath).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");
		}
	}
	
	public void testEditClasspath() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			File f = new File(indexFilePath);
			long modified = f.lastModified();
			IJavaProject p = this.createJavaProject("P", new String[] {}, "bin");

			String content = new String(
					"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
					+ "<classpath>\n"
					+ "<classpathentry kind=\"src\" path=\"src a\"/>\n"
					+ "<classpathentry kind=\"src\" path=\"src x\"/>\n"
					+ "<classpathentry kind=\"lib\" path=\""
					+ getExternalJCLPath()
					+ "\"/>\n"
					+ "<classpathentry kind=\"lib\" path=\""
					+ jarFilePath
					+ "\">"
					+ "<attributes>\n" 
					+ "	<attribute name=\"index_location\" value=\"file:///"
					+ indexFilePath
					+"\"/>\n" 
					+ "</attributes>\n"
					+ "</classpathentry>\n"
					+ "<classpathentry kind=\"output\" path=\"bin\"/>\n"
					+ "</classpath>\n");

			editFile("/P/.classpath", content);
			p.open(null);
			waitUntilIndexesReady();
			search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
			java.io.File indexFile = JavaModelManager.getIndexManager().getIndex(new Path(jarFilePath), false, false).getIndexFile();
			assertEquals(indexFilePath,indexFile.toString());
			f = new File(indexFilePath);
			assertEquals(modified, f.lastModified());
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// Test changing the classpath	
	public void testChangeClasspath() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}", 
					"pkg/NewTest.java",
					"package pkg;\n" +
					"public class NewTest {\n" +
					"  protected NewTest(int i) {}\n" +
					"}"}, jarFilePath);
			IJavaProject p = createJavaProject("P");
			Path libPath = new Path(jarFilePath);
			
			IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, null, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			search("NewTest", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.NewTest");
			
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			this.resultCollector = new JavaSearchResultCollector();
			search("NewTest", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults("");
			
			entry = JavaCore.newLibraryEntry(libPath, null, null, null, null, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			this.resultCollector = new JavaSearchResultCollector();
			search("NewTest", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.NewTest");
			
			
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// Test changing the classpath	
	public void testChangeClasspathForInternalJar() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = "/P/Test.jar";
		try {
			IJavaProject p = createJavaProject("P");
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}", 
					"pkg/NewTest.java",
					"package pkg;\n" +
					"public class NewTest {\n" +
					"  protected NewTest(int i) {}\n" +
					"}"}, jarFilePath);
			Path libPath = new Path(jarFilePath);
			
			IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, null, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			search("NewTest", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults("\\P\\Test.jar pkg.NewTest");
			
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			this.resultCollector = new JavaSearchResultCollector();
			search("NewTest", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults("");
			
			entry = JavaCore.newLibraryEntry(libPath, null, null, null, null, false);
			setClasspath(p, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			this.resultCollector = new JavaSearchResultCollector();
			search("NewTest", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p}));
			assertSearchResults("\\P\\Test.jar pkg.NewTest");
			
			
		} finally {
			deleteProject("P");
			new File(indexFilePath).delete();
		}
	}
		
	public void testMultipleProjects() throws CoreException, IOException {
		String indexFilePath = getExternalResourcePath("Test.index");
		String jarFilePath = getExternalResourcePath("Test.jar");
		try {
			createJar(new String[] {
					"pkg/Test.java",
					"package pkg;\n" +
					"public class Test {\n" +
					"  protected Test(int i) {}\n" +
					"}"}, jarFilePath);
			JavaIndexer.generateIndexForJar(jarFilePath, indexFilePath);
			
			IJavaProject p1 = createJavaProject("P1");
			Path libPath = new Path(jarFilePath);
			IClasspathEntry entry = JavaCore.newLibraryEntry(libPath, null, null, null, null, false);
			setClasspath(p1, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			
			IJavaProject p2 = createJavaProject("P2");
			IClasspathAttribute attribute = JavaCore.newClasspathAttribute(IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME, "file:///"+indexFilePath);
			entry = JavaCore.newLibraryEntry(libPath, null, null, null, new IClasspathAttribute[]{attribute}, false);
			setClasspath(p2, new IClasspathEntry[] {entry});
			waitUntilIndexesReady();
			
			search("Test", TYPE, DECLARATIONS, EXACT_RULE, SearchEngine.createJavaSearchScope(new IJavaElement[]{p1}));
			assertSearchResults(getExternalPath() + "Test.jar pkg.Test");
			
			File indexFile = JavaModelManager.getIndexManager().getIndex(libPath, false, false).getIndexFile();
			assertEquals(indexFilePath,indexFile.toString());
			
		} finally {
			deleteProject("P1");
			deleteProject("P2");
			new File(indexFilePath).delete();
			new File(jarFilePath).delete();
		}
	}
	
	// TODO SATYAM: Add test for containers
}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchScopeTests.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1025-1031 Link Here
1025		1025
1026	// Index the output location as it is a library for the project	1026	// Index the output location as it is a library for the project
1027	IndexManager indexManager = JavaModelManager.getIndexManager();	1027	IndexManager indexManager = JavaModelManager.getIndexManager();
1028	indexManager.indexLibrary(new Path("/P1/bin"), project.getProject());	1028	indexManager.indexLibrary(new Path("/P1/bin"), project.getProject(), null);
1029	waitUntilIndexesReady();	1029	waitUntilIndexesReady();
1030		1030
1031	// Search for all types	1031	// Search for all types

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/RunJavaSearchTests.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 62-67 Link Here
62	allClasses.add(SearchTests.class);	62	allClasses.add(SearchTests.class);
63	allClasses.add(JavaSearchScopeTests.class);	63	allClasses.add(JavaSearchScopeTests.class);
64	allClasses.add(MatchingRegionsTest.class);	64	allClasses.add(MatchingRegionsTest.class);
		65	allClasses.add(JavaIndexTests.class);
65		66
66	// Reset forgotten subsets of tests	67	// Reset forgotten subsets of tests
67	TestCase.TESTS_PREFIX = null;	68	TestCase.TESTS_PREFIX = null;

Lines 17-22 Link Here

(-)a/org.eclipse.jdt.core/META-INF/MANIFEST.MF (+1 lines)
17	org.eclipse.jdt.core.jdom,	17	org.eclipse.jdt.core.jdom,
18	org.eclipse.jdt.core.search,	18	org.eclipse.jdt.core.search,
19	org.eclipse.jdt.core.util,	19	org.eclipse.jdt.core.util,
		20	org.eclipse.jdt.core.index,
20	org.eclipse.jdt.internal.codeassist;x-internal:=true,	21	org.eclipse.jdt.internal.codeassist;x-internal:=true,
21	org.eclipse.jdt.internal.codeassist.complete;x-internal:=true,	22	org.eclipse.jdt.internal.codeassist.complete;x-internal:=true,
22	org.eclipse.jdt.internal.codeassist.impl;x-internal:=true,	23	org.eclipse.jdt.internal.codeassist.impl;x-internal:=true,




/*******************************************************************************
 * 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.core;

import java.io.IOException;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;
import org.eclipse.jdt.core.index.JavaIndexer;
import org.eclipse.jdt.internal.antadapter.AntAdapterMessages;

/**
 * <p>
 * An Ant task to generate the index file for the given jar path.
 * </p>
 * <p>
 * <code>&lt;eclipse.buildJarIndex jarPath="Test.jar" indexPath="Test.index"/&gt;</code>
 * </p>
 * <p>
 * For more information on Ant check out the website at http://jakarta.apache.org/ant/ .
 * </p>
 * 
 * This is not intended to be subclassed by users.
 * 
 * @since 3.8
 */
public class BuildJarIndex extends Task {

	private String jarPath;
	private String indexPath;

	public void execute() throws BuildException {
		if (this.jarPath == null) {
			throw new BuildException(AntAdapterMessages.getString("buildJarIndex.jarFile.cannot.be.null")); //$NON-NLS-1$
		}
		if (this.indexPath == null) {
			throw new BuildException(AntAdapterMessages.getString("buildJarIndex.indexFile.cannot.be.null")); //$NON-NLS-1$
		}

		try {
			JavaIndexer.generateIndexForJar(this.jarPath, this.indexPath);
		} catch (IOException e) {
			throw new BuildException(AntAdapterMessages.getString("buildJarIndex.ioexception.occured", e.getLocalizedMessage())); //$NON-NLS-1$
		}
		setProject(getProject());
	}

	public void setJarPath(String path) {
		this.jarPath = path;
	}

	public void setIndexPath(String path) {
		this.indexPath = path;
	}
}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/internal/antadapter/messages.properties (-1 / +5 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2000, 2006 IBM Corporation and others.	2	# Copyright (c) 2000, 2011 IBM Corporation and others.
3	# All rights reserved. This program and the accompanying materials	3	# All rights reserved. This program and the accompanying materials
4	# are made available under the terms of the Eclipse Public License v1.0	4	# are made available under the terms of the Eclipse Public License v1.0
5	# which accompanies this distribution, and is available at	5	# which accompanies this distribution, and is available at
Lines 19-21 Link Here
19	checkDebugAttributes.property.argument.cannot.be.null=The property argument cannot be null	19	checkDebugAttributes.property.argument.cannot.be.null=The property argument cannot be null
20	checkDebugAttributes.ioexception.occured=IOException occurred while reading	20	checkDebugAttributes.ioexception.occured=IOException occurred while reading
21	checkDebugAttributes.file.argument.must.be.a.classfile.or.a.jarfile=The file argument must be a .class or a .jar file	21	checkDebugAttributes.file.argument.must.be.a.classfile.or.a.jarfile=The file argument must be a .class or a .jar file
		22
		23	buildJarIndex.jarFile.cannot.be.null=The jar file argument cannot be null
		24	buildJarIndex.indexFile.cannot.be.null=The index file argument cannot be null
		25	buildJarIndex.ioexception.occured=IOException - {0}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/build.properties (-2 / +3 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2000, 2010 IBM Corporation and others.	2	# Copyright (c) 2000, 2011 IBM Corporation and others.
3	# All rights reserved. This program and the accompanying materials	3	# All rights reserved. This program and the accompanying materials
4	# are made available under the terms of the Eclipse Public License v1.0	4	# are made available under the terms of the Eclipse Public License v1.0
5	# which accompanies this distribution, and is available at	5	# which accompanies this distribution, and is available at
Lines 24-30 Link Here
24	org.eclipse.jdt.core.jdom.*,\	24	org.eclipse.jdt.core.jdom.*,\
25	org.eclipse.jdt.core.dom.*,\	25	org.eclipse.jdt.core.dom.*,\
26	org.eclipse.jdt.core.dom.rewrite.*,\	26	org.eclipse.jdt.core.dom.rewrite.*,\
27	org.eclipse.jdt.core.search.*	27	org.eclipse.jdt.core.search.*,\
		28	org.eclipse.jdt.core.index.*
28	source.. = batch/,\	29	source.. = batch/,\
29	codeassist/,\	30	codeassist/,\
30	compiler/,\	31	compiler/,\




/*******************************************************************************
 * Copyright (c) 2005, 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

	 * @since 3.1
	 */
	String JAVADOC_LOCATION_ATTRIBUTE_NAME = "javadoc_location"; //$NON-NLS-1$
	
	/**
	 * Constant for the name of the index location attribute.
	 * 
	 * <p>The value for this attribute has to be the string representation of a URL.
	 * It should point to an existing index file in a folder or a jar. The URL also supports the platform protocol.</p>
	 * 
	 * @since 3.8
	 */
	String INDEX_LOCATION_ATTRIBUTE_NAME = "index_location"; //$NON-NLS-1$

	/**
	 * Constant for the name of the optional attribute. The possible values

Lines 57-62 Link Here

(-)a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/IJavaElementDelta.java (+26 lines)
57	* <li>{@link #F_SOURCEDETACHED} - The source attachment path or the source attachment root path	57	* <li>{@link #F_SOURCEDETACHED} - The source attachment path or the source attachment root path
58	* of a classpath entry corresponding to the element was removed. This flag is only valid if the element is an	58	* of a classpath entry corresponding to the element was removed. This flag is only valid if the element is an
59	* {@link IPackageFragmentRoot}.</li>	59	* {@link IPackageFragmentRoot}.</li>
		60	* <li>{@link #F_INDEXATTACHED} - The index path or the index root path
		61	* of a classpath entry corresponding to the element was added. This flag is only valid if the element is an
		62	* {@link IPackageFragmentRoot}.</li>
		63	* <li>{@link #F_INDEXDETACHED} - The index path or the index root path
		64	* of a classpath entry corresponding to the element was removed. This flag is only valid if the element is an
		65	* {@link IPackageFragmentRoot}.</li>
60	* <li>{@link #F_SUPER_TYPES} - One of the supertypes of an {@link IType} has changed</li>.	66	* <li>{@link #F_SUPER_TYPES} - One of the supertypes of an {@link IType} has changed</li>.
61	* </ul>	67	* </ul>
62	* </li>	68	* </li>
Lines 312-317 Link Here
312	* @since 3.4	318	* @since 3.4
313	*/	319	*/
314	public int F_ANNOTATIONS = 0x400000;	320	public int F_ANNOTATIONS = 0x400000;
		321
		322	/**
		323	* TODO SATYAM: We probably don't need this delta..
		324	*
		325	* Change flag indicating that the index file of a classpath entry
		326	* corresponding to the element was added. This flag is only valid if the element is an
		327	* {@link IPackageFragmentRoot}.
		328	*
		329	* @since 3.8
		330	*/
		331	public int F_INDEXATTACHED = 0x800000;
		332
		333	/**
		334	* Change flag indicating that the index file of a classpath entry
		335	* corresponding to the element was removed. This flag is only valid if the element is an
		336	* {@link IPackageFragmentRoot}.
		337	*
		338	* @since 3.8
		339	*/
		340	public int F_INDEXDETACHED = 0x1000000;
315		341
316	/**	342	/**
317	* Returns deltas for the children that have been added.	343	* Returns deltas for the children that have been added.




/*******************************************************************************
 * 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

 *******************************************************************************/
package org.eclipse.jdt.core;

import java.net.URL;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;


	 */
	void delete(int updateResourceFlags, int updateModelFlags, IProgressMonitor monitor) throws JavaModelException;
	/**
	 * Returns the URL to the index file attached to this package fragment root's binary archive.
	 *
	 * @return the URL to the corresponding index file,
	 *   or <code>null</code> if this package fragment root's binary archive
	 *   has no corresponding index file, or if this package fragment root
	 *   is not a binary archive
	 * @exception JavaModelException if this operation fails
	 * 
	 * @since 3.8
	 */
	URL getIndexPath() throws JavaModelException;
	/**
	 * Returns this package fragment root's kind encoded as an integer.
	 * A package fragment root can contain source files (i.e. files with one
	 * of the {@link JavaCore#getJavaLikeExtensions() Java-like extensions},




 *******************************************************************************/
package org.eclipse.jdt.internal.core;

import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

							boolean found = false;
							for (int j = 0; j < accumulatedRoots.size(); j++) {
								IPackageFragmentRoot root = (IPackageFragmentRoot) accumulatedRoots.elementAt(j);
								// TODO SATYAM: Shouldn't the check be opposite?
								if (!root.getPath().equals(oldRoot.getPath())) {
									found = true;
									break;


		for (int i = 0; i < newLength; i++) {
			int index = classpathContains(this.oldResolvedClasspath, newResolvedClasspath[i]);
			if (index == -1 || newResolvedClasspath[i].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
				// remote projects are not indexed in this project
				if (newResolvedClasspath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT){
					continue;

						boolean pathHasChanged = true;
						IPath newPath = newResolvedClasspath[i].getPath();
						for (int j = 0; j < oldLength; j++) {
							//TODO SATYAM: Isn't index == j?
							IClasspathEntry oldEntry = this.oldResolvedClasspath[j];
							if (oldEntry.getPath().equals(newPath)) {
								URL oldurl = ((ClasspathEntry)oldEntry).getLibraryIndexLocation();
								URL newurl = ((ClasspathEntry)newResolvedClasspath[i]).getLibraryIndexLocation();
								if (oldurl == null && newurl == null) {
									pathHasChanged = false;
								} else if (oldurl != null && newurl != null) {
									pathHasChanged = !(newurl.equals(oldurl));
								} else if (oldurl != null) {
									indexManager.removeIndex(newPath);
								}
								break;
							}
						}
						if (pathHasChanged) {
							indexManager.indexLibrary(newPath, this.project.getProject(),((ClasspathEntry)newResolvedClasspath[i]).getLibraryIndexLocation());
						}
						break;
					case IClasspathEntry.CPE_SOURCE:

Lines 17-22 Link Here

(-)a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/ClasspathEntry.java (-1 / +30 lines)
17	import java.io.InputStream;	17	import java.io.InputStream;
18	import java.io.OutputStreamWriter;	18	import java.io.OutputStreamWriter;
19	import java.io.UnsupportedEncodingException;	19	import java.io.UnsupportedEncodingException;
		20	import java.net.MalformedURLException;
		21	import java.net.URL;
20	import java.util.ArrayList;	22	import java.util.ArrayList;
21	import java.util.HashMap;	23	import java.util.HashMap;
22	import java.util.HashSet;	24	import java.util.HashSet;
Lines 1524-1529 Link Here
1524		1526
1525	return JavaCore.getResolvedClasspathEntry(this);	1527	return JavaCore.getResolvedClasspathEntry(this);
1526	}	1528	}
		1529
		1530	/**
		1531	* This function computes the URL of the index location for this classpath entry. It returns null if the URL is
		1532	* invalid.
		1533	*/
		1534	public URL getLibraryIndexLocation() {
		1535	switch(getEntryKind()) {
		1536	case IClasspathEntry.CPE_LIBRARY :
		1537	case IClasspathEntry.CPE_VARIABLE :
		1538	break;
		1539	default :
		1540	return null;
		1541	}
		1542
		1543	for (int i= 0; i < this.extraAttributes.length; i++) {
		1544	IClasspathAttribute attrib= this.extraAttributes[i];
		1545	if (IClasspathAttribute.INDEX_LOCATION_ATTRIBUTE_NAME.equals(attrib.getName())) {
		1546	String value = attrib.getValue();
		1547	try {
		1548	return new URL(value);
		1549	} catch (MalformedURLException e) {
		1550	return null;
		1551	}
		1552	}
		1553	}
		1554	return null;
		1555	}
1527		1556
1528	/**	1557	/**
1529	* Validate a given classpath and output location for a project, using the following rules:	1558	* Validate a given classpath and output location for a project, using the following rules:
Lines 2191-2195 Link Here
2191	}	2220	}
2192	}	2221	}
2193	return JavaModelStatus.VERIFIED_OK;	2222	return JavaModelStatus.VERIFIED_OK;
2194	}	2223	}
2195	}	2224	}

Lines 13-18 Link Here

(-)a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/DeltaProcessor.java (-4 / +9 lines)
13	package org.eclipse.jdt.internal.core;	13	package org.eclipse.jdt.internal.core;
14		14
15	import java.io.File;	15	import java.io.File;
		16	import java.net.URL;
16	import java.util.*;	17	import java.util.*;
17		18
18	import org.eclipse.core.resources.IContainer;	19	import org.eclipse.core.resources.IContainer;
Lines 997-1004 Link Here
997	// first remove the index so that it is forced to be re-indexed	998	// first remove the index so that it is forced to be re-indexed
998	this.manager.indexManager.removeIndex(entryPath);	999	this.manager.indexManager.removeIndex(entryPath);
999	// then index the jar	1000	// then index the jar
1000	this.manager.indexManager.indexLibrary(entryPath, project.getProject());	1001	this.manager.indexManager.indexLibrary(entryPath, project.getProject(), ((ClasspathEntry)entries[j]).getLibraryIndexLocation());
1001	} else {	1002	} else {
		1003	URL indexLocation = ((ClasspathEntry)entries[j]).getLibraryIndexLocation();
		1004	if (indexLocation != null) { // force reindexing, this could be faster rather than maintaining the list
		1005	this.manager.indexManager.indexLibrary(entryPath, project.getProject(), ((ClasspathEntry)entries[j]).getLibraryIndexLocation());
		1006	}
1002	externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);	1007	externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);
1003	}	1008	}
1004	} else {	1009	} else {
Lines 1009-1015 Link Here
1009	this.state.getExternalLibTimeStamps().put(entryPath, new Long(newTimeStamp));	1014	this.state.getExternalLibTimeStamps().put(entryPath, new Long(newTimeStamp));
1010	// index the new jar	1015	// index the new jar
1011	this.manager.indexManager.removeIndex(entryPath);	1016	this.manager.indexManager.removeIndex(entryPath);
1012	this.manager.indexManager.indexLibrary(entryPath, project.getProject());	1017	this.manager.indexManager.indexLibrary(entryPath, project.getProject(), ((ClasspathEntry)entries[j]).getLibraryIndexLocation());
1013	}	1018	}
1014	}	1019	}
1015	} else { // internal JAR	1020	} else { // internal JAR
Lines 2629-2641 Link Here
2629	switch (delta.getKind()) {	2634	switch (delta.getKind()) {
2630	case IResourceDelta.ADDED:	2635	case IResourceDelta.ADDED:
2631	// index the new jar	2636	// index the new jar
2632	indexManager.indexLibrary(jarPath, root.getJavaProject().getProject());	2637	indexManager.indexLibrary(jarPath, root.getJavaProject().getProject(), root.getIndexPath() );
2633	break;	2638	break;
2634	case IResourceDelta.CHANGED:	2639	case IResourceDelta.CHANGED:
2635	// first remove the index so that it is forced to be re-indexed	2640	// first remove the index so that it is forced to be re-indexed
2636	indexManager.removeIndex(jarPath);	2641	indexManager.removeIndex(jarPath);
2637	// then index the jar	2642	// then index the jar
2638	indexManager.indexLibrary(jarPath, root.getJavaProject().getProject());	2643	indexManager.indexLibrary(jarPath, root.getJavaProject().getProject(), root.getIndexPath());
2639	break;	2644	break;
2640	case IResourceDelta.REMOVED:	2645	case IResourceDelta.REMOVED:
2641	// the jar was physically removed: remove the index	2646	// the jar was physically removed: remove the index




/*******************************************************************************
 * 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

	detachedDelta.changed(F_SOURCEDETACHED);
	insertDeltaTree(element, detachedDelta);
}

/**
 * Creates the nested deltas resulting from a change operation.
 * Convenience method for creating change deltas.
 * The constructor should be used to create the root delta
 * and then a change operation should call this method.
 */
public void indexAttached(IJavaElement element) {
	JavaElementDelta attachedDelta = new JavaElementDelta(element);
	attachedDelta.changed(F_INDEXATTACHED);
	insertDeltaTree(element, attachedDelta);
}
/**
 * Creates the nested deltas resulting from a change operation.
 * Convenience method for creating change deltas.
 * The constructor should be used to create the root delta
 * and then a change operation should call this method.
 */
public void indexDetached(IJavaElement element) {
	JavaElementDelta detachedDelta = new JavaElementDelta(element);
	detachedDelta.changed(F_INDEXDETACHED);
	insertDeltaTree(element, detachedDelta);
}
/**
 * Returns a string representation of this delta's
 * structure suitable for debug purposes.




/*******************************************************************************
 * 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

 *******************************************************************************/
package org.eclipse.jdt.internal.core;

import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Map;

	}
}

public URL getIndexPath() {
	try {
		if (getKind() != K_BINARY) return null;

		IClasspathEntry entry = ((JavaProject) getParent()).getClasspathEntryFor(getPath());
		if (entry != null) return ((ClasspathEntry)entry).getLibraryIndexLocation();	
	} catch (JavaModelException e) {
		// ignore exception
	}
	return null;
}

}

Lines 1-7 Link Here

(-)a/org.eclipse.jdt.core/plugin.xml (-1 / +17 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.0"?>	2	<?eclipse version="3.0"?>
3	<!--	3	<!--
4	Copyright (c) 2004, 2010 IBM Corporation and others.	4	Copyright (c) 2004, 2011 IBM Corporation and others.
5	All rights reserved. This program and the accompanying materials	5	All rights reserved. This program and the accompanying materials
6	are made available under the terms of the Eclipse Public License v1.0	6	are made available under the terms of the Eclipse Public License v1.0
7	which accompanies this distribution, and is available at	7	which accompanies this distribution, and is available at
Lines 158-163 Link Here
158	class="org.eclipse.jdt.core.CheckDebugAttributes"	158	class="org.eclipse.jdt.core.CheckDebugAttributes"
159	library="jdtCompilerAdapter.jar">	159	library="jdtCompilerAdapter.jar">
160	</antTask>	160	</antTask>
		161	<antTask
		162	name="eclipse.buildJarIndex"
		163	class="org.eclipse.jdt.core.BuildJarIndex"
		164	library="jdtCompilerAdapter.jar">
		165	</antTask>
161	</extension>	166	</extension>
162		167
163	<!-- =================================================================================== -->	168	<!-- =================================================================================== -->
Lines 196-201 Link Here
196	</extension>	201	</extension>
197		202
198	<!-- =================================================================================== -->	203	<!-- =================================================================================== -->
		204	<!-- Extension: Java Generate Indexer -->
		205	<!-- =================================================================================== -->
		206	<extension
		207	id="JavaIndexer"
		208	point="org.eclipse.core.runtime.applications">
		209	<application>
		210	<run class="org.eclipse.jdt.core.index.JavaIndexerApplication" />
		211	</application>
		212	</extension>
		213
		214	<!-- =================================================================================== -->
199	<!-- Extension: Java Content Types -->	215	<!-- Extension: Java Content Types -->
200	<!-- =================================================================================== -->	216	<!-- =================================================================================== -->
201	<extension point="org.eclipse.core.contenttype.contentTypes">	217	<extension point="org.eclipse.core.contenttype.contentTypes">




/*******************************************************************************
 * 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.core.index;

import java.io.IOException;
import org.eclipse.jdt.internal.core.search.indexing.DefaultJavaIndexer;

/**
 * TODO SATYAM: Write a proper javadoc
 * @since 3.8
 */
public class JavaIndexer {

	/**
	 * TODO SATYAM: Write a javadoc
	 * @param pathToJar
	 * @param pathToIndexFile
	 * @throws IOException
	 */
	public static void generateIndexForJar(String pathToJar, String pathToIndexFile) throws IOException {
		new DefaultJavaIndexer().generateIndexForJar(pathToJar, pathToIndexFile);
	}

}




/*******************************************************************************
 *  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.core.index;

import java.io.File;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.ArrayList;

import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;
import org.eclipse.osgi.util.NLS;

/**
 * Implements an Eclipse Application for org.eclipse.jdt.core.JavaIndexer.
 * 
 * TODO SATYAM: Improve the javadoc to include the arguments.
 * <p>
 * On MacOS, when invoked using the Eclipse executable, the "user.dir" property is set to the folder in which the
 * eclipse.ini file is located. This makes it harder to use relative paths to point to the files to be formatted or the
 * configuration file to use to set the code formatter's options.
 * </p>
 * 
 * 
 * @since 3.8
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @noextend This class is not intended to be subclassed by clients.
 */
public class JavaIndexerApplication implements IApplication {

	private final static class Messages extends NLS {
		private static final String MESSAGES_NAME = "org.eclipse.jdt.core.index.messages";//$NON-NLS-1$

		public static String CommandLineProcessing;
		public static String CommandLineUsage;
		public static String CommandLineOnlyOutputError;
		public static String CommandLineOnlyOneJarError;
		public static String CommandLineJarNotSpecified;
		public static String CommandLineIndexFileNotSpecified;
		public static String CaughtException;
		public static String CommandLineJarFileNotExist;

		static {
			NLS.initializeMessages(MESSAGES_NAME, Messages.class);
		}

		public static String bind(String message) {
			return bind(message, null);
		}

		public static String bind(String message, Object binding) {
			return bind(message, new Object[] { binding });
		}

		public static String bind(String message, Object binding1, Object binding2) {
			return bind(message, new Object[] { binding1, binding2 });
		}

		public static String bind(String message, Object[] bindings) {
			return MessageFormat.format(message, bindings);
		}
	}

	private String jarToIndex;
	private String indexFile;
	private boolean verbose = false;
	private static final String PDE_LAUNCH = "-pdelaunch"; //$NON-NLS-1$
	private static final String ARG_HELP = "-help"; //$NON-NLS-1$
	private static final String ARG_VERBOSE = "-verbose"; //$NON-NLS-1$
	private static final String ARG_OUTPUT = "-output"; //$NON-NLS-1$

	private void displayHelp() {
		System.out.println(Messages.bind(Messages.CommandLineUsage));
	}

	private void displayError(String message) {
		System.err.println(message);
		System.out.println();
		displayHelp();
	}

	private boolean processCommandLine(String[] argsArray) {
		ArrayList args = new ArrayList();
		for (int i = 0, max = argsArray.length; i < max; i++) {
			args.add(argsArray[i]);
		}
		int index = 0;
		final int argCount = argsArray.length;

		loop: while (index < argCount) {
			String currentArg = argsArray[index++];
			if (PDE_LAUNCH.equals(currentArg)) {
				continue loop;
			} else if (ARG_HELP.equals(currentArg)) {
				displayHelp();
				return false;
			} else if (ARG_VERBOSE.equals(currentArg)) {
				this.verbose = true;
				continue loop;
			} else if (ARG_OUTPUT.equals(currentArg)) {
				if (this.indexFile != null || index == argCount) {
					displayError(Messages.bind(Messages.CommandLineOnlyOutputError));
					return false;
				}
				this.indexFile = argsArray[index++];
			} else {
				if (this.jarToIndex != null) {
					displayError(Messages.bind(Messages.CommandLineOnlyOneJarError));
					return false;
				}
				this.jarToIndex = currentArg;
			}
		}
		return true;
	}

	public Object start(IApplicationContext context) throws Exception {
		boolean execute = processCommandLine((String[]) context.getArguments().get(IApplicationContext.APPLICATION_ARGS));
		if (execute) {
			if (this.jarToIndex != null && this.indexFile != null) {
				File f = new File(this.jarToIndex);
				if (!f.exists()) {
					System.out.println(Messages.bind(Messages.CommandLineJarFileNotExist, this.jarToIndex));
				}
				if (this.verbose) {
					System.out.println(Messages.bind(Messages.CommandLineProcessing, this.jarToIndex, this.indexFile));
				}
				try {
					JavaIndexer.generateIndexForJar(this.jarToIndex, this.indexFile);
				} catch (IOException e) {
					System.out.println(Messages.bind(Messages.CaughtException, "IOException", e.getLocalizedMessage())); //$NON-NLS-1$
				}
			} else if (this.jarToIndex == null) {
				System.out.println(Messages.bind(Messages.CommandLineJarNotSpecified));
			} else if (this.indexFile == null) {
				System.out.println(Messages.bind(Messages.CommandLineIndexFileNotSpecified));
			}
		}
		return IApplication.EXIT_OK;
	}

	public void stop() {
		// do nothing
	}

}




###############################################################################
# Copyright (c) 2000, 2006 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
###############################################################################
CommandLineUsage=Usage: eclipse -application org.eclipse.jdt.core.JavaCodeGenerateIndex [ OPTIONS ] -output <indexFile> <jarfile>\n\
\n\
\   -output <indexFile> The index file to be generated.\n\
\
\   <jarfile>   Jar file for which index needs to be generated.\n\
\
\n\
\ OPTIONS:\n\
\n\
\   -help                Display this message.\n\
\   -verbose             Be verbose about the job.
CommandLineProcessing=Generating index {1} for the jar {0}.
CommandLineOnlyOutputError=Only one output need to be specified.
CommandLineOnlyOneJarError=Only one jar file need to be specified.
CommandLineJarNotSpecified=No jar file is specified.
CommandLineIndexFileNotSpecified=No index file is specified.
CaughtException=Exception {0} - {1}.
CommandLineJarFileNotExist={0} does not exist.

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.FlatFileIndex;
		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 FlatFileIndex(indexPath.toFile());
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 indexFile;

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.indexFile = 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.indexFile.getInputStream();
	try {
		if (this.numberOfChunks > 5) BUFFER_READ_SIZE <<= 1;
		int offset = this.chunkOffsets[0];

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

		}
	}
	if (this.indexFile.createNewFile()) {
		FileOutputStream stream = new FileOutputStream(this.indexFile.getIndexFile(), false);
		try {
			this.streamBuffer = new byte[BUFFER_READ_SIZE];
			this.bufferIndex = 0;

DiskIndex mergeWith(MemoryIndex memoryIndex) throws IOException {
 	// assume write lock is held
	// compute & write out new docNames
	if (this.indexFile == 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.indexFile);
		newDiskIndex.initialize(false);
		return newDiskIndex;
	}
	File oldIndexFile = this.indexFile.getIndexFile();
	DiskIndex newDiskIndex = new DiskIndex(new FlatFileIndex(new File(oldIndexFile.getPath() + ".tmp"))); //$NON-NLS-1$
	File newIndexFile = newDiskIndex.indexFile.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.indexFile); //$NON-NLS-1$
			throw new IOException("Failed to delete index file " + this.indexFile); //$NON-NLS-1$
		}
		if (!newIndexFile.renameTo(oldIndexFile)) {
			if (DEBUG)
				System.out.println("mergeWith - Failed to rename " + this.indexFile); //$NON-NLS-1$
			throw new IOException("Failed to rename index file " + this.indexFile); //$NON-NLS-1$
		}
	} catch (IOException e) {
		if (newIndexFile.exists() && !newIndexFile.delete())
			if (DEBUG)
				System.out.println("mergeWith - Failed to delete temp index " + newDiskIndex.indexFile); //$NON-NLS-1$
		throw e;

	if (this.numberOfChunks <= 0)
		return CharOperation.NO_STRINGS;

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

		}
	}

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

	}

	if (matchingWords != null && count > 0) {
		stream = this.indexFile.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.indexFile.getInputStream();
		try {
			file.skip(start);
			if (file.read(this.streamBuffer, 0, numberOfBytes) != numberOfBytes)

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

	InputStream stream = this.indexFile.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.indexFile.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.indexFile); //$NON-NLS-1$

	int size = readStreamInt(stream);
	this.categoryOffsets = new HashtableOfIntValues(size);
	this.categoryEnds = new HashtableOfIntValues(size);
	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.indexFile); //$NON-NLS-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)

 * @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);

	}
	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.indexFile.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;

public class FlatFileIndex extends IndexLocation {
	File indexFile;

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

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

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

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

	public boolean equals(Object other) {
		if (!(other instanceof FlatFileIndex)) return false;
		return this.indexFile.equals(((FlatFileIndex) 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 getFilePath() {
		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();
	}

}




/*******************************************************************************
 * 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 IndexLocation getIndexLocation() {
	return this.diskIndex == null ? null : this.diskIndex.indexFile;
}
public File getIndexFile() {
	return this.diskIndex == null ? null : this.diskIndex.indexFile.getIndexFile();
}
public long getIndexLastModified() {
	return this.diskIndex == null? -1 : this.diskIndex.indexFile.lastModified();
}
public boolean hasChanged() {
	return this.memoryIndex.hasChanged();

 */
public void reset() throws IOException {
	this.memoryIndex = new MemoryIndex();
	this.diskIndex = new DiskIndex(this.diskIndex.indexFile);
	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;

/**
 * TODO SATYAM: Write a comment about this file
 * 
 */
public abstract class IndexLocation {
	private final URL url;
	private boolean participantIndex;

	public IndexLocation(File file) {
		URL tempUrl = null;
		try {
			tempUrl = file.toURI().toURL();
		} catch (MalformedURLException e) {
			// should not happen
		}
		this.url = tempUrl;
	}
	
	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 FlatFileIndex(url, new File(localUrl.getPath()));
		}
		return new JarEntryIndex(url, localUrl);
	}
	
	public IndexLocation(URL url) {
		this.url = url;
	}

	public abstract boolean createNewFile() throws IOException;

	public void close() {
		// default nothing to do
	}

	public abstract boolean delete();

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

	public abstract File getIndexFile();

	abstract InputStream getInputStream() throws IOException;

	public abstract String getFilePath();

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

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

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

	public void setParticipantIndex() {
		this.participantIndex = true;
	}

	public abstract long lastModified();

	public abstract long length();

	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;

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

	public JarEntryIndex(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 JarEntryIndex)) return false;
		return this.localUrl.equals(((JarEntryIndex) 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 getFilePath() {
		return null;
	}

	public long lastModified() {
		return -1;
	}

	public long length() {
		return -1;
	}

}




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();
	}




 *******************************************************************************/
package org.eclipse.jdt.internal.core.search;


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.FlatFileIndex;
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; i < paths.length; i++) {
			indexLocations[i] = new FlatFileIndex(paths[i].toFile());
			indexLocations[i].setParticipantIndex();
		}
	}
	Index[] indexes = JavaModelManager.getIndexManager().getIndexes(indexLocations, progressMonitor);
	this.areIndexesReady = indexes.length == length;
	return indexes;




/*******************************************************************************
 * 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.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;
	}
	public boolean equals(Object o) {
		if (o instanceof AddJarFileToIndex) {

	public boolean execute(IProgressMonitor progressMonitor) {

		if (this.isCancelled || progressMonitor != null && progressMonitor.isCanceled()) return true;

		if (this.indexFileURL != null) {
			boolean added = this.manager.addIndex(this.containerPath, this.indexFileURL);
			if (added) return true;	
			this.indexFileURL = null;
		}

		try {
			// if index is already cached, then do not perform any check

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

						// index only classes coming from valid packages - https://bugs.eclipse.org/bugs/show_bug.cgi?id=293861
						final byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(ze, zip);
						JavaSearchDocument entryDocument = new JavaSearchDocument(ze, zipFilePath, classFileBytes, participant);
						this.manager.indexDocument(entryDocument, participant, index, indexPath);
					}
				}
				this.manager.saveIndex(index);




package org.eclipse.jdt.internal.core.search.indexing;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.search.IJavaSearchScope;
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.FlatFileIndex;
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 {
	private static final char JAR_SEPARATOR = IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR.charAt(0);
	
	public void generateIndexForJar(String pathToJar, String pathToIndexFile) throws IOException {
		File f = new File(pathToJar); 
		if (!f.exists()) {
			throw new FileNotFoundException(pathToJar + "not found"); //$NON-NLS-1$
		}
		IndexLocation indexLocation = new FlatFileIndex(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);
		for (Enumeration e = zip.entries(); e.hasMoreElements();) {
			// iterate each entry to index it
			ZipEntry ze = (ZipEntry) e.nextElement();
			String zipEntryName = ze.getName();
			if (Util.isClassFileName(zipEntryName)) {
				final byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(ze, zip);
				JavaSearchDocument entryDocument = new JavaSearchDocument(ze, new Path(pathToJar), classFileBytes, participant);
				entryDocument.setIndex(index);
				if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(entryDocument.getPath())) {
					new BinaryIndexer(entryDocument).indexDocument();
				}
			}
		}
		zip.close();
		index.save();
		return;
	}

}

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 {




/*******************************************************************************
 * 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

package org.eclipse.jdt.internal.core.search.indexing;

import java.io.*;
import java.net.URL;
import java.util.*;
import java.util.zip.CRC32;


	public static final Integer UPDATING_STATE = new Integer(1);
	public static final Integer UNKNOWN_STATE = new Integer(2);
	public static final Integer REBUILDING_STATE = new Integer(3);
	public static final Integer REUSE_STATE = new Integer(4);
	
	// search participants who register indexes with the index manager
	private SimpleLookupTable participantsContainers = null;

	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

	int compare = newIndexState.compareTo(currentIndexState);
	if (compare > 0) {

	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 FlatFileIndex(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 FlatFileIndex(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;
					}

				rebuildIndex(indexLocation, containerPath);
				return null;
			}
			if (currentIndexState == REUSE_STATE) {
				// supposed to be in reuse state but error in the index file, so reindex.
				if (VERBOSE)
					Util.verbose("-> cannot reuse given index: "+indexLocation+" path: "+containerPathString); //$NON-NLS-1$ //$NON-NLS-2$
				this.indexLocations.put(containerPath, null);
				indexLocation = computeIndexLocation(containerPath);
				rebuildIndex(indexLocation, containerPath);
				return null;
			}
		}
		// index wasn't found on disk, consider creating an empty new one
		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 FlatFileIndex(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();
	}

		for (int i = 0; i < entries.length; i++) {
			IClasspathEntry entry= entries[i];
			if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY)
				indexLibrary(entry.getPath(), project, ((ClasspathEntry)entry).getLibraryIndexLocation());
		}
	} catch(JavaModelException e){ // cannot retrieve classpath info
	}

 * Trigger addition of a library to an index
 * Note: the actual operation is performed in background
 */
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 (JavaCore.getPlugin() == null) return;

	Object target = JavaModel.getTarget(path, true);
	IndexRequest request = null;
	Object target = JavaModel.getTarget(path, true);
	if (target instanceof IFile) {
		request = new AddJarFileToIndex((IFile) target, indexFile, this);
	} else if (target instanceof File) {
		request = new AddJarFileToIndex(path, indexFile, this);
	} else if (target instanceof IContainer) {
		request = new IndexBinaryFolder((IContainer) target, this);
	} else {

	if (!isJobWaiting(request))
		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;
	}
	return true;
}

/**
 * Index the content of the given source folder.
 */

	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;


	} else if (target instanceof IFolder) {
		request = new IndexBinaryFolder((IFolder) target, this);
	} else if (target instanceof IFile) {
		request = new AddJarFileToIndex((IFile) target, null, this);
	} else if (target instanceof File) {
		request = new AddJarFileToIndex(containerPath, null, this);
	}
	if (request != null)
		request(request);

	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 (path.isPrefixOf(new Path(indexLocation.getFilePath()))) {
			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--;

		for (int i = 0; i < count; i++)
			this.indexes.removeKey(locations[i]);
		removeIndexesState(locations);
		if (this.participantsContainers != null) {
			boolean update = false;
			for (int i = 0; i < count; i++) {
				if (this.participantsContainers.get(locations[i]) != null) {
					update = true;
					this.participantsContainers.removeKey(locations[i]);
				}
			}
			if (update) writeParticipantsIndexNamesFile();
		}
	}
}

	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;

			/* ensure no concurrent write access to index */
			Index index;
			index = getIndex(this.containerPath, indexLocation, true, /*reuse index file*/ true /*create if none*/);
			if (index == null) return true;
			ReadWriteMonitor monitor = index.monitor;
			if (monitor == null) return true; // index got deleted since acquired

			try {
				monitor.enterWrite(); // ask permission to write
				indexDocument(searchDocument, searchParticipant, index, new Path(indexLocation.getFilePath()));
			} 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 FlatFileIndex(new File(new String(names[i])));
						indexLocation.setParticipantIndex();
						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 FlatFileIndex(indexPath.toFile());
	if (this.participantsContainers.get(indexLocation) == null) {
		this.participantsContainers.put(indexLocation, containerPath);
		indexLocation.setParticipantIndex();
		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 (+21 lines)
1348	}	1348	}
1349	}	1349	}
1350	}	1350	}
		1351	public static void zipFiles(File[] files, String zipPath) throws IOException {
		1352	File zipFile = new File(zipPath);
		1353	if (zipFile.exists()) {
		1354	if (!delete(zipFile))
		1355	throw new IOException("Could not delete " + zipPath);
		1356	// ensure the new zip file has a different timestamp than the previous one
		1357	int timeToWait = 1000; // some platform (like Linux) have a 1s granularity)
		1358	waitAtLeast(timeToWait);
		1359	} else {
		1360	zipFile.getParentFile().mkdirs();
		1361	}
		1362	ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(zipFile));
		1363	for (int i = 0, length = files.length; i < length; i++) {
		1364	File file = files[i];
		1365	ZipEntry entry = new ZipEntry(file.getName());
		1366	zip.putNextEntry(entry);
		1367	zip.write(org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(file));
		1368	zip.closeEntry();
		1369	}
		1370	zip.close();
		1371	}
1351	/**	1372	/**
1352	* Returns the compilation errors / warnings for the given CompilationResult.	1373	* Returns the compilation errors / warnings for the given CompilationResult.
1353	*	1374	*

Added Link Here

(-)a/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/BuildJarIndex.java (+63 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.core;
12
13	import java.io.IOException;
14
15	import org.apache.tools.ant.BuildException;
16	import org.apache.tools.ant.Task;
17	import org.eclipse.jdt.core.index.JavaIndexer;
18	import org.eclipse.jdt.internal.antadapter.AntAdapterMessages;
19
20	/**
21	* <p>
22	* An Ant task to generate the index file for the given jar path.
23	* </p>
24	* <p>
25	* <code><eclipse.buildJarIndex jarPath="Test.jar" indexPath="Test.index"/></code>
26	* </p>
27	* <p>
28	* For more information on Ant check out the website at http://jakarta.apache.org/ant/ .
29	* </p>
30	*
31	* This is not intended to be subclassed by users.
32	*
33	* @since 3.8
34	*/
35	public class BuildJarIndex extends Task {
36
37	private String jarPath;
38	private String indexPath;
39
40	public void execute() throws BuildException {
41	if (this.jarPath == null) {
42	throw new BuildException(AntAdapterMessages.getString("buildJarIndex.jarFile.cannot.be.null")); //$NON-NLS-1$
43	}
44	if (this.indexPath == null) {
45	throw new BuildException(AntAdapterMessages.getString("buildJarIndex.indexFile.cannot.be.null")); //$NON-NLS-1$
46	}
47
48	try {
49	JavaIndexer.generateIndexForJar(this.jarPath, this.indexPath);
50	} catch (IOException e) {
51	throw new BuildException(AntAdapterMessages.getString("buildJarIndex.ioexception.occured", e.getLocalizedMessage())); //$NON-NLS-1$
52	}
53	setProject(getProject());
54	}
55
56	public void setJarPath(String path) {
57	this.jarPath = path;
58	}
59
60	public void setIndexPath(String path) {
61	this.indexPath = path;
62	}
63	}

Lines 23-29 Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/index/DiskIndex.java (-33 / +39 lines)
23		23
24	public class DiskIndex {	24	public class DiskIndex {
25		25
26	File indexFile;	26	IndexLocation indexFile;
27		27
28	private int headerInfoOffset;	28	private int headerInfoOffset;
29	private int numberOfChunks;	29	private int numberOfChunks;
Lines 82-93 Link Here
82	}	82	}
83		83
84		84
85	DiskIndex(String fileName) {	85	DiskIndex() {
86	if (fileName == null)
87	throw new java.lang.IllegalArgumentException();
88	this.indexFile = new File(fileName);
89
90	// clear cached items
91	this.headerInfoOffset = -1;	86	this.headerInfoOffset = -1;
92	this.numberOfChunks = -1;	87	this.numberOfChunks = -1;
93	this.sizeOfLastChunk = -1;	88	this.sizeOfLastChunk = -1;
Lines 99-104 Link Here
99	this.cachedCategoryName = null;	94	this.cachedCategoryName = null;
100	this.categoryOffsets = null;	95	this.categoryOffsets = null;
101	this.categoryEnds = null;	96	this.categoryEnds = null;
		97	}
		98	DiskIndex(IndexLocation location) throws IOException {
		99	this();
		100	if (location == null) {
		101	throw new IllegalArgumentException();
		102	}
		103	this.indexFile = location;
102	}	104	}
103	SimpleSet addDocumentNames(String substring, MemoryIndex memoryIndex) throws IOException {	105	SimpleSet addDocumentNames(String substring, MemoryIndex memoryIndex) throws IOException {
104	// must skip over documents which have been added/changed/deleted in the memory index	106	// must skip over documents which have been added/changed/deleted in the memory index
Lines 230-236 Link Here
230	private void cacheDocumentNames() throws IOException {	232	private void cacheDocumentNames() throws IOException {
231	// will need all document names so get them now	233	// will need all document names so get them now
232	this.cachedChunks = new String[this.numberOfChunks][];	234	this.cachedChunks = new String[this.numberOfChunks][];
233	FileInputStream stream = new FileInputStream(this.indexFile);	235	InputStream stream = this.indexFile.getInputStream();
234	try {	236	try {
235	if (this.numberOfChunks > 5) BUFFER_READ_SIZE <<= 1;	237	if (this.numberOfChunks > 5) BUFFER_READ_SIZE <<= 1;
236	int offset = this.chunkOffsets[0];	238	int offset = this.chunkOffsets[0];
Lines 372-378 Link Here
372	void initialize(boolean reuseExistingFile) throws IOException {	374	void initialize(boolean reuseExistingFile) throws IOException {
373	if (this.indexFile.exists()) {	375	if (this.indexFile.exists()) {
374	if (reuseExistingFile) {	376	if (reuseExistingFile) {
375	FileInputStream stream = new FileInputStream(this.indexFile);	377	InputStream stream = this.indexFile.getInputStream();
376	this.streamBuffer = new byte[BUFFER_READ_SIZE];	378	this.streamBuffer = new byte[BUFFER_READ_SIZE];
377	this.bufferIndex = 0;	379	this.bufferIndex = 0;
378	this.bufferEnd = stream.read(this.streamBuffer, 0, 128);	380	this.bufferEnd = stream.read(this.streamBuffer, 0, 128);
Lines 400-406 Link Here
400	}	402	}
401	}	403	}
402	if (this.indexFile.createNewFile()) {	404	if (this.indexFile.createNewFile()) {
403	FileOutputStream stream = new FileOutputStream(this.indexFile, false);	405	FileOutputStream stream = new FileOutputStream(this.indexFile.getIndexFile(), false);
404	try {	406	try {
405	this.streamBuffer = new byte[BUFFER_READ_SIZE];	407	this.streamBuffer = new byte[BUFFER_READ_SIZE];
406	this.bufferIndex = 0;	408	this.bufferIndex = 0;
Lines 500-505 Link Here
500	DiskIndex mergeWith(MemoryIndex memoryIndex) throws IOException {	502	DiskIndex mergeWith(MemoryIndex memoryIndex) throws IOException {
501	// assume write lock is held	503	// assume write lock is held
502	// compute & write out new docNames	504	// compute & write out new docNames
		505	if (this.indexFile == null) {
		506	throw new IOException("Pre-built index file not writeable"); //$NON-NLS-1$
		507	}
503	String[] docNames = readAllDocumentNames();	508	String[] docNames = readAllDocumentNames();
504	int previousLength = docNames.length;	509	int previousLength = docNames.length;
505	int[] positions = new int[previousLength]; // keeps track of the position of each document in the new sorted docNames	510	int[] positions = new int[previousLength]; // keeps track of the position of each document in the new sorted docNames
Lines 509-523 Link Here
509	if (previousLength == 0) return this; // nothing to do... memory index contained deleted documents that had never been saved	514	if (previousLength == 0) return this; // nothing to do... memory index contained deleted documents that had never been saved
510		515
511	// index is now empty since all the saved documents were removed	516	// index is now empty since all the saved documents were removed
512	DiskIndex newDiskIndex = new DiskIndex(this.indexFile.getPath());	517	DiskIndex newDiskIndex = new DiskIndex(this.indexFile);
513	newDiskIndex.initialize(false);	518	newDiskIndex.initialize(false);
514	return newDiskIndex;	519	return newDiskIndex;
515	}	520	}
516		521	File oldIndexFile = this.indexFile.getIndexFile();
517	DiskIndex newDiskIndex = new DiskIndex(this.indexFile.getPath() + ".tmp"); //$NON-NLS-1$	522	DiskIndex newDiskIndex = new DiskIndex(new FlatFileIndex(new File(oldIndexFile.getPath() + ".tmp"))); //$NON-NLS-1$
		523	File newIndexFile = newDiskIndex.indexFile.getIndexFile();
518	try {	524	try {
519	newDiskIndex.initializeFrom(this, newDiskIndex.indexFile);	525	newDiskIndex.initializeFrom(this, newIndexFile);
520	FileOutputStream stream = new FileOutputStream(newDiskIndex.indexFile, false);	526	FileOutputStream stream = new FileOutputStream(newIndexFile, false);
521	int offsetToHeader = -1;	527	int offsetToHeader = -1;
522	try {	528	try {
523	newDiskIndex.writeAllDocumentNames(docNames, stream);	529	newDiskIndex.writeAllDocumentNames(docNames, stream);
Lines 549-566 Link Here
549	newDiskIndex.writeOffsetToHeader(offsetToHeader);	555	newDiskIndex.writeOffsetToHeader(offsetToHeader);
550		556
551	// rename file by deleting previous index file & renaming temp one	557	// rename file by deleting previous index file & renaming temp one
552	if (this.indexFile.exists() && !this.indexFile.delete()) {	558	if (oldIndexFile.exists() && !oldIndexFile.delete()) {
553	if (DEBUG)	559	if (DEBUG)
554	System.out.println("mergeWith - Failed to delete " + this.indexFile); //$NON-NLS-1$	560	System.out.println("mergeWith - Failed to delete " + this.indexFile); //$NON-NLS-1$
555	throw new IOException("Failed to delete index file " + this.indexFile); //$NON-NLS-1$	561	throw new IOException("Failed to delete index file " + this.indexFile); //$NON-NLS-1$
556	}	562	}
557	if (!newDiskIndex.indexFile.renameTo(this.indexFile)) {	563	if (!newIndexFile.renameTo(oldIndexFile)) {
558	if (DEBUG)	564	if (DEBUG)
559	System.out.println("mergeWith - Failed to rename " + this.indexFile); //$NON-NLS-1$	565	System.out.println("mergeWith - Failed to rename " + this.indexFile); //$NON-NLS-1$
560	throw new IOException("Failed to rename index file " + this.indexFile); //$NON-NLS-1$	566	throw new IOException("Failed to rename index file " + this.indexFile); //$NON-NLS-1$
561	}	567	}
562	} catch (IOException e) {	568	} catch (IOException e) {
563	if (newDiskIndex.indexFile.exists() && !newDiskIndex.indexFile.delete())	569	if (newIndexFile.exists() && !newIndexFile.delete())
564	if (DEBUG)	570	if (DEBUG)
565	System.out.println("mergeWith - Failed to delete temp index " + newDiskIndex.indexFile); //$NON-NLS-1$	571	System.out.println("mergeWith - Failed to delete temp index " + newDiskIndex.indexFile); //$NON-NLS-1$
566	throw e;	572	throw e;
Lines 573-579 Link Here
573	if (this.numberOfChunks <= 0)	579	if (this.numberOfChunks <= 0)
574	return CharOperation.NO_STRINGS;	580	return CharOperation.NO_STRINGS;
575		581
576	FileInputStream stream = new FileInputStream(this.indexFile);	582	InputStream stream = this.indexFile.getInputStream();
577	try {	583	try {
578	int offset = this.chunkOffsets[0];	584	int offset = this.chunkOffsets[0];
579	stream.skip(offset);	585	stream.skip(offset);
Lines 612-618 Link Here
612	}	618	}
613	}	619	}
614		620
615	FileInputStream stream = new FileInputStream(this.indexFile);	621	InputStream stream = this.indexFile.getInputStream();
616	HashtableOfObject categoryTable = null;	622	HashtableOfObject categoryTable = null;
617	char[][] matchingWords = null;	623	char[][] matchingWords = null;
618	int count = 0;	624	int count = 0;
Lines 678-684 Link Here
678	}	684	}
679		685
680	if (matchingWords != null && count > 0) {	686	if (matchingWords != null && count > 0) {
681	stream = new FileInputStream(this.indexFile);	687	stream = this.indexFile.getInputStream();
682	try {	688	try {
683	stream.skip(firstOffset);	689	stream.skip(firstOffset);
684	this.bufferIndex = 0;	690	this.bufferIndex = 0;
Lines 696-702 Link Here
696	this.streamBuffer = null;	702	this.streamBuffer = null;
697	return categoryTable;	703	return categoryTable;
698	}	704	}
699	private void readChunk(String[] docNames, FileInputStream stream, int index, int size) throws IOException {	705	private void readChunk(String[] docNames, InputStream stream, int index, int size) throws IOException {
700	String current = new String(readStreamChars(stream));	706	String current = new String(readStreamChars(stream));
701	docNames[index++] = current;	707	docNames[index++] = current;
702	for (int i = 1; i < size; i++) {	708	for (int i = 1; i < size; i++) {
Lines 734-740 Link Here
734	throw new IllegalArgumentException();	740	throw new IllegalArgumentException();
735	this.streamBuffer = new byte[numberOfBytes];	741	this.streamBuffer = new byte[numberOfBytes];
736	this.bufferIndex = 0;	742	this.bufferIndex = 0;
737	FileInputStream file = new FileInputStream(this.indexFile);	743	InputStream file = this.indexFile.getInputStream();
738	try {	744	try {
739	file.skip(start);	745	file.skip(start);
740	if (file.read(this.streamBuffer, 0, numberOfBytes) != numberOfBytes)	746	if (file.read(this.streamBuffer, 0, numberOfBytes) != numberOfBytes)
Lines 763-769 Link Here
763	if (arrayOffset instanceof int[])	769	if (arrayOffset instanceof int[])
764	return (int[]) arrayOffset;	770	return (int[]) arrayOffset;
765		771
766	FileInputStream stream = new FileInputStream(this.indexFile);	772	InputStream stream = this.indexFile.getInputStream();
767	try {	773	try {
768	int offset = ((Integer) arrayOffset).intValue();	774	int offset = ((Integer) arrayOffset).intValue();
769	stream.skip(offset);	775	stream.skip(offset);
Lines 776-790 Link Here
776	this.streamBuffer = null;	782	this.streamBuffer = null;
777	}	783	}
778	}	784	}
779	private void readHeaderInfo(FileInputStream stream) throws IOException {	785	private void readHeaderInfo(InputStream stream) throws IOException {
780		786
781	// must be same order as writeHeaderInfo()	787	// must be same order as writeHeaderInfo()
782	this.numberOfChunks = readStreamInt(stream);	788	this.numberOfChunks = readStreamInt(stream);
783	this.sizeOfLastChunk = this.streamBuffer[this.bufferIndex++] & 0xFF;	789	this.sizeOfLastChunk = this.streamBuffer[this.bufferIndex++] & 0xFF;
784	this.documentReferenceSize = this.streamBuffer[this.bufferIndex++] & 0xFF;	790	this.documentReferenceSize = this.streamBuffer[this.bufferIndex++] & 0xFF;
785	this.separator = (char) (this.streamBuffer[this.bufferIndex++] & 0xFF);	791	this.separator = (char) (this.streamBuffer[this.bufferIndex++] & 0xFF);
786	long fileLength = this.indexFile.length();	792	long length = this.indexFile.length();
787	if (this.numberOfChunks > fileLength ) {	793	if (length != -1 && this.numberOfChunks > length) {
788	// not an accurate check, but good enough https://bugs.eclipse.org/bugs/show_bug.cgi?id=350612	794	// not an accurate check, but good enough https://bugs.eclipse.org/bugs/show_bug.cgi?id=350612
789	if (DEBUG)	795	if (DEBUG)
790	System.out.println("Index file is corrupted " + this.indexFile); //$NON-NLS-1$	796	System.out.println("Index file is corrupted " + this.indexFile); //$NON-NLS-1$
Lines 799-805 Link Here
799	int size = readStreamInt(stream);	805	int size = readStreamInt(stream);
800	this.categoryOffsets = new HashtableOfIntValues(size);	806	this.categoryOffsets = new HashtableOfIntValues(size);
801	this.categoryEnds = new HashtableOfIntValues(size);	807	this.categoryEnds = new HashtableOfIntValues(size);
802	if (size > fileLength) {	808	if (length != -1 && this.numberOfChunks > length) {
803	// not an accurate check, but good enough https://bugs.eclipse.org/bugs/show_bug.cgi?id=350612	809	// not an accurate check, but good enough https://bugs.eclipse.org/bugs/show_bug.cgi?id=350612
804	if (DEBUG)	810	if (DEBUG)
805	System.out.println("Index file is corrupted " + this.indexFile); //$NON-NLS-1$	811	System.out.println("Index file is corrupted " + this.indexFile); //$NON-NLS-1$
Lines 840-846 Link Here
840	}	846	}
841	}	847	}
842	}	848	}
843	private void readStreamBuffer(FileInputStream stream) throws IOException {	849	private void readStreamBuffer(InputStream stream) throws IOException {
844	// if we're about to read a known amount at the end of the existing buffer, but it does not completely fit	850	// if we're about to read a known amount at the end of the existing buffer, but it does not completely fit
845	// so we need to shift the remaining bytes to be read, and fill the buffer from the stream	851	// so we need to shift the remaining bytes to be read, and fill the buffer from the stream
846	if (this.bufferEnd < this.streamBuffer.length)	852	if (this.bufferEnd < this.streamBuffer.length)
Lines 872-878 Link Here
872	* @exception UTFDataFormatException if the bytes do not represent a	878	* @exception UTFDataFormatException if the bytes do not represent a
873	* valid UTF-8 encoding of a Unicode string.	879	* valid UTF-8 encoding of a Unicode string.
874	*/	880	*/
875	private char[] readStreamChars(FileInputStream stream) throws IOException {	881	private char[] readStreamChars(InputStream stream) throws IOException {
876	// read chars array length	882	// read chars array length
877	if (stream != null && this.bufferIndex + 2 >= this.bufferEnd)	883	if (stream != null && this.bufferIndex + 2 >= this.bufferEnd)
878	readStreamBuffer(stream);	884	readStreamBuffer(stream);
Lines 931-937 Link Here
931	}	937	}
932	return word;	938	return word;
933	}	939	}
934	private int[] readStreamDocumentArray(FileInputStream stream, int arraySize) throws IOException {	940	private int[] readStreamDocumentArray(InputStream stream, int arraySize) throws IOException {
935	int[] indexes = new int[arraySize];	941	int[] indexes = new int[arraySize];
936	if (arraySize == 0) return indexes;	942	if (arraySize == 0) return indexes;
937		943
Lines 972-978 Link Here
972	}	978	}
973	return indexes;	979	return indexes;
974	}	980	}
975	private int readStreamInt(FileInputStream stream) throws IOException {	981	private int readStreamInt(InputStream stream) throws IOException {
976	if (this.bufferIndex + 4 >= this.bufferEnd) {	982	if (this.bufferIndex + 4 >= this.bufferEnd) {
977	readStreamBuffer(stream);	983	readStreamBuffer(stream);
978	}	984	}
Lines 1182-1188 Link Here
1182	}	1188	}
1183	private void writeOffsetToHeader(int offsetToHeader) throws IOException {	1189	private void writeOffsetToHeader(int offsetToHeader) throws IOException {
1184	if (offsetToHeader > 0) {	1190	if (offsetToHeader > 0) {
1185	RandomAccessFile file = new RandomAccessFile(this.indexFile, "rw"); //$NON-NLS-1$	1191	RandomAccessFile file = new RandomAccessFile(this.indexFile.getIndexFile(), "rw"); //$NON-NLS-1$
1186	try {	1192	try {
1187	file.seek(this.headerInfoOffset); // offset to position in header	1193	file.seek(this.headerInfoOffset); // offset to position in header
1188	file.writeInt(offsetToHeader);	1194	file.writeInt(offsetToHeader);

Lines 17-23 Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/PatternSearchJob.java (-2 / +16 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.FlatFileIndex;
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; i < paths.length; i++) {
		91	indexLocations[i] = new FlatFileIndex(paths[i].toFile());
		92	indexLocations[i].setParticipantIndex();
		93	}
		94	}
81	Index[] indexes = JavaModelManager.getIndexManager().getIndexes(indexLocations, progressMonitor);	95	Index[] indexes = JavaModelManager.getIndexManager().getIndexes(indexLocations, progressMonitor);
82	this.areIndexesReady = indexes.length == length;	96	this.areIndexesReady = indexes.length == length;
83	return indexes;	97	return indexes;

Added Link Here

(-)a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/indexing/DefaultJavaIndexer.java (+51 lines)
1	package org.eclipse.jdt.internal.core.search.indexing;
2
3	import java.io.File;
4	import java.io.FileNotFoundException;
5	import java.io.IOException;
6	import java.util.Enumeration;
7	import java.util.zip.ZipEntry;
8	import java.util.zip.ZipFile;
9
10	import org.eclipse.core.runtime.Path;
11	import org.eclipse.jdt.core.search.IJavaSearchScope;
12	import org.eclipse.jdt.core.search.SearchEngine;
13	import org.eclipse.jdt.core.search.SearchParticipant;
14	import org.eclipse.jdt.internal.compiler.util.Util;
15	import org.eclipse.jdt.internal.core.index.FlatFileIndex;
16	import org.eclipse.jdt.internal.core.index.Index;
17	import org.eclipse.jdt.internal.core.index.IndexLocation;
18	import org.eclipse.jdt.internal.core.search.JavaSearchDocument;
19
20	public class DefaultJavaIndexer {
21	private static final char JAR_SEPARATOR = IJavaSearchScope.JAR_FILE_ENTRY_SEPARATOR.charAt(0);
22
23	public void generateIndexForJar(String pathToJar, String pathToIndexFile) throws IOException {
24	File f = new File(pathToJar);
25	if (!f.exists()) {
26	throw new FileNotFoundException(pathToJar + "not found"); //$NON-NLS-1$
27	}
28	IndexLocation indexLocation = new FlatFileIndex(new File(pathToIndexFile));
29	Index index = new Index(indexLocation, pathToJar, false /reuse index file/);
30	SearchParticipant participant = SearchEngine.getDefaultSearchParticipant();
31	index.separator = JAR_SEPARATOR;
32	ZipFile zip = new ZipFile(pathToJar);
33	for (Enumeration e = zip.entries(); e.hasMoreElements();) {
34	// iterate each entry to index it
35	ZipEntry ze = (ZipEntry) e.nextElement();
36	String zipEntryName = ze.getName();
37	if (Util.isClassFileName(zipEntryName)) {
38	final byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(ze, zip);
39	JavaSearchDocument entryDocument = new JavaSearchDocument(ze, new Path(pathToJar), classFileBytes, participant);
40	entryDocument.setIndex(index);
41	if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(entryDocument.getPath())) {
42	new BinaryIndexer(entryDocument).indexDocument();
43	}
44	}
45	}
46	zip.close();
47	index.save();
48	return;
49	}
50
51	}