this(resource, indexFile, manager, false);

	}

	public AddJarFileToIndex(IPath jarPath, IndexLocation indexFile, IndexManager manager) {

		this(jarPath, indexFile, manager, false);

	}

	public AddJarFileToIndex(IFile resource, IndexLocation indexFile, IndexManager manager, final boolean updateIndex) {

		this.updateIndexIfNecessary = updateIndex;

		this.updateIndexIfNecessary = updateIndex;

	private boolean createOrUpdatePreBuiltIndex(final IProgressMonitor progressMonitor) throws IOException {

		boolean success = false;

		if(this.updateIndexIfNecessary || !this.indexFileURL.getIndexFile().exists()) {

			// construct a new index and populate the contents

			String containerPathString = this.containerPath.getDevice() == null ? this.containerPath.toString()

					: this.containerPath.toOSString();

			Index newIndex = null;

			try {

				newIndex = new Index(this.indexFileURL, containerPathString, false);

				this.populateIndex(newIndex, progressMonitor);

			} catch (IOException e) {

				if (JobManager.VERBOSE) {

					org.eclipse.jdt.internal.core.util.Util.verbose("-> failed to create index for " + this.containerPath + " because of the following exception:"); //$NON-NLS-1$ //$NON-NLS-2$

					e.printStackTrace();

				}

				this.manager.removeIndex(this.containerPath);

			}

			// add this index to the indexmanager

			if(newIndex != null) {

				success = this.manager.addIndex(this.containerPath, newIndex);

			}

		}

		else {

			// add the index as-is to the manager

			success = this.manager.addIndex(this.containerPath, this.indexFileURL);

		}

		if(!success && JobManager.VERBOSE) {

			org.eclipse.jdt.internal.core.util.Util.verbose("-> pre-build index could not be updated for " + this.containerPath); //$NON-NLS-1$

		}

		return success;

	}

	private boolean populateIndex(final Index index, final IProgressMonitor progressMonitor) throws IOException {

		ReadWriteMonitor monitor = index.monitor;

		if (monitor == null) {

			if (JobManager.VERBOSE)

				org.eclipse.jdt.internal.core.util.Util.verbose("-> index for " + this.containerPath + " just got deleted"); //$NON-NLS-1$//$NON-NLS-2$

			return true; // index got deleted since acquired

		}

		index.separator = JAR_SEPARATOR;

		ZipFile zip = null;

		try {

			// this path will be a relative path to the workspace in case the zipfile in the workspace otherwise it will be a path in the

			// local file system

			Path zipFilePath = null;

			monitor.enterWrite(); // ask permission to write

			if (this.resource != null) {

				URI location = this.resource.getLocationURI();

				if (location == null) return false;

				if (JavaModelManager.ZIP_ACCESS_VERBOSE)

					System.out.println("(" + Thread.currentThread() + ") [AddJarFileToIndex.execute()] Creating ZipFile on " + location.getPath()); //$NON-NLS-1$	//$NON-NLS-2$

				File file = null;

				try {

					file = org.eclipse.jdt.internal.core.util.Util.toLocalFile(location, progressMonitor);

				} catch (CoreException e) {

					if (JobManager.VERBOSE) {

						org.eclipse.jdt.internal.core.util.Util.verbose("-> failed to index " + location.getPath() + " because of the following exception:"); //$NON-NLS-1$ //$NON-NLS-2$

						e.printStackTrace();

					}

				}

				if (file == null) {

					if (JobManager.VERBOSE)

						org.eclipse.jdt.internal.core.util.Util.verbose("-> failed to index " + location.getPath() + " because the file could not be fetched"); //$NON-NLS-1$ //$NON-NLS-2$

					return false;

				}

				zip = new ZipFile(file);

				zipFilePath = (Path) this.resource.getFullPath().makeRelative();

				// absolute path relative to the workspace

			} else {

				if (JavaModelManager.ZIP_ACCESS_VERBOSE)

					System.out.println("(" + Thread.currentThread() + ") [AddJarFileToIndex.execute()] Creating ZipFile on " + this.containerPath); //$NON-NLS-1$	//$NON-NLS-2$

				// external file -> it is ok to use toFile()

				zip = new ZipFile(this.containerPath.toFile());

				zipFilePath = (Path) this.containerPath;

				// path is already canonical since coming from a library classpath entry

			}

			if (this.isCancelled) {

				if (JobManager.VERBOSE)

					org.eclipse.jdt.internal.core.util.Util.verbose("-> indexing of " + zip.getName() + " has been cancelled"); //$NON-NLS-1$ //$NON-NLS-2$

				return false;

			}

			if (JobManager.VERBOSE)

				org.eclipse.jdt.internal.core.util.Util.verbose("-> indexing " + zip.getName()); //$NON-NLS-1$

			long initialTime = System.currentTimeMillis();

			String[] paths = index.queryDocumentNames(""); // all file names //$NON-NLS-1$

			if (paths != null) {

				int max = paths.length;

				/* check integrity of the existing index file

				 * if the length is equal to 0, we want to index the whole jar again

				 * If not, then we want to check that there is no missing entry, if

				 * one entry is missing then we recreate the index

				 */

				String EXISTS = "OK"; //$NON-NLS-1$

				String DELETED = "DELETED"; //$NON-NLS-1$

				SimpleLookupTable indexedFileNames = new SimpleLookupTable(max == 0 ? 33 : max + 11);

				for (int i = 0; i < max; i++)

					indexedFileNames.put(paths[i], DELETED);

				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) && isValidPackageNameForClass(zipEntryName))

							// the class file may not be there if the package name is not valid

						indexedFileNames.put(zipEntryName, EXISTS);

				}

				boolean needToReindex = indexedFileNames.elementSize != max; // a new file was added

				if (!needToReindex) {

					Object[] valueTable = indexedFileNames.valueTable;

					for (int i = 0, l = valueTable.length; i < l; i++) {

						if (valueTable[i] == DELETED) {

							needToReindex = true; // a file was deleted so re-index

							break;

						}

					}

					if (!needToReindex) {

						if (JobManager.VERBOSE)

							org.eclipse.jdt.internal.core.util.Util.verbose("-> no indexing required (index is consistent with library) for " //$NON-NLS-1$

							+ zip.getName() + " (" //$NON-NLS-1$

							+ (System.currentTimeMillis() - initialTime) + "ms)"); //$NON-NLS-1$

						this.manager.saveIndex(index); // to ensure its placed into the saved state

						return true;

					}

				}

			}

			// Index the jar for the first time or reindex the jar in case the previous index file has been corrupted

			// index already existed: recreate it so that we forget about previous entries

			SearchParticipant participant = SearchEngine.getDefaultSearchParticipant();

			if (!this.manager.resetIndex(this.containerPath)) {

				// failed to recreate index, see 73330

				this.manager.removeIndex(this.containerPath);

				return false;

			}

			index.separator = JAR_SEPARATOR;

			IPath indexPath = null;

			IndexLocation indexLocation;

			if ((indexLocation = index.getIndexLocation()) != null) {

				indexPath = new Path(indexLocation.getCanonicalFilePath());

			}

			for (Enumeration e = zip.entries(); e.hasMoreElements();) {

				if (this.isCancelled) {

					if (JobManager.VERBOSE)

						org.eclipse.jdt.internal.core.util.Util.verbose("-> indexing of " + zip.getName() + " has been cancelled"); //$NON-NLS-1$ //$NON-NLS-2$

					return false;

				}

				// iterate each entry to index it

				ZipEntry ze = (ZipEntry) e.nextElement();

				String zipEntryName = ze.getName();

				if (Util.isClassFileName(zipEntryName) && 

						isValidPackageNameForClass(zipEntryName)) {

					// 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);

			if (JobManager.VERBOSE)

				org.eclipse.jdt.internal.core.util.Util.verbose("-> done indexing of " //$NON-NLS-1$

					+ zip.getName() + " (" //$NON-NLS-1$

					+ (System.currentTimeMillis() - initialTime) + "ms)"); //$NON-NLS-1$

		} finally {

			if (zip != null) {

				if (JavaModelManager.ZIP_ACCESS_VERBOSE)

					System.out.println("(" + Thread.currentThread() + ") [AddJarFileToIndex.execute()] Closing ZipFile " + zip); //$NON-NLS-1$	//$NON-NLS-2$

				zip.close();

			}

			monitor.exitWrite(); // free write lock

		}

		return true;

	}

	private Boolean updateProductIndexes = null;

	public synchronized boolean updateProductIndexes() {

		if (this.updateProductIndexes == null) {

			boolean manageIndexPropertyValue = Boolean.getBoolean("JDT_UPDATE_PRODUCT_INDEXES"); //$NON-NLS-1$

			this.updateProductIndexes = Boolean.valueOf(manageIndexPropertyValue);

		}

		return this.updateProductIndexes.booleanValue();

	}

	this.indexLibrary(path, requestingProject, indexURL, false);

}

/**

 * 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, final boolean forceUpdate) {

	// bug395897: work-around to enable any pre-built indexes to be regenerated

	boolean updateIndex = this.updateProductIndexes() && forceUpdate;

synchronized boolean addIndex(final IPath containerPath, final Index index) {

	boolean result = false;

	if((index != null) && (containerPath != null)) {

		getIndexStates().put(index.getIndexLocation(), REUSE_STATE);

		this.indexLocations.put(containerPath, index.getIndexLocation());

		result = true;

	}

	writeIndexMapFile();

	return result;

}