NodeIDMap.java

/*******************************************************************************
 * Copyright (c) 2000, 2005 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.core.internal.events;

import org.eclipse.core.runtime.IPath;

/**
 * A specialized map that maps Node IDs to their old and new paths. Used for calculating moves
 * during resource change notification.
 */
public class NodeIDMap {
	//using prime table sizes improves our hash function
	private static final int[] SIZES= new int[] { 13, 29, 71, 173, 349, 733, 1511, 3079, 6133, 16381, 32653, 65543, 131111, 262139, 524287, 1051601 };

	private static final double LOAD_FACTOR= 0.75;

	//2^32 * golden ratio
	private static final long LARGE_NUMBER= 2654435761L;

	int sizeOffset= 0;

	protected int elementCount= 0;

	protected long[] ids;

	protected IPath[] oldPaths;

	protected IPath[] newPaths;

	/**
	 * Creates a new node ID map of default capacity.
	 */
	public NodeIDMap() {
		this.sizeOffset= 0;
		this.ids= new long[SIZES[sizeOffset]];
		this.oldPaths= new IPath[SIZES[sizeOffset]];
		this.newPaths= new IPath[SIZES[sizeOffset]];
	}

	/**
	 * The array isn't large enough so double its size and rehash all its current values.
	 */
	protected void expand() {
		int newLength;
		try {
			newLength= SIZES[++sizeOffset];
		} catch (ArrayIndexOutOfBoundsException e) {
			//will only occur if there are > 1 million elements in delta
			newLength= ids.length * 2;
		}
		long[] grownIds= new long[newLength];
		IPath[] grownOldPaths= new IPath[newLength];
		IPath[] grownNewPaths= new IPath[newLength];
		int maxArrayIndex= newLength - 1;
		for (int i= 0; i < ids.length; i++) {
			long id= ids[i];
			if (id != 0) {
				int hash= hashFor(id, newLength);
				while (grownIds[hash] != 0) {
					hash++;
					if (hash > maxArrayIndex)
						hash= 0;
				}
				grownIds[hash]= id;
				grownOldPaths[hash]= oldPaths[i];
				grownNewPaths[hash]= newPaths[i];
			}
		}
		ids= grownIds;
		oldPaths= grownOldPaths;
		newPaths= grownNewPaths;
	}

	/**
	 * Returns the index of the given element in the map. If not found, returns -1.
	 */
	private int getIndex(long searchID) {
		final int len= ids.length;
		int hash= hashFor(searchID, len);

		// search the last half of the array
		for (int i= hash; i < len; i++) {
			if (ids[i] == searchID)
				return i;
			// marker info not found so return -1
			if (ids[i] == 0)
				return -1;
		}

		// search the beginning of the array
		for (int i= 0; i < hash - 1; i++) {
			if (ids[i] == searchID)
				return i;
			// marker info not found so return -1
			if (ids[i] == 0)
				return -1;
		}
		// marker info not found so return -1
		return -1;
	}

	/**
	 * Returns the new path location for the given ID, or null if no new path is available.
	 */
	public IPath getNewPath(long nodeID) {
		int index= getIndex(nodeID);
		if (index == -1)
			return null;
		return newPaths[index];
	}

	/**
	 * Returns the old path location for the given ID, or null if no old path is available.
	 */
	public IPath getOldPath(long nodeID) {
		int index= getIndex(nodeID);
		if (index == -1)
			return null;
		return oldPaths[index];
	}

	private int hashFor(long id, int size) {
		//Knuth's hash function from Art of Computer Programming section 6.4
		return (int)Math.abs((id * LARGE_NUMBER) % size);
	}

	/**
	 * Returns true if there are no elements in the map, and false otherwise.
	 */
	public boolean isEmpty() {
		return elementCount == 0;
	}

	/**
	 * Adds the given path mappings to the map. If either oldPath or newPath is null, they are
	 * ignored (old map values are not overwritten).
	 */
	private void put(long id, IPath oldPath, IPath newPath) {
		if (oldPath == null && newPath == null)
			return;
		int hash= hashFor(id, ids.length);

		// search for an empty slot at the end of the array
		for (int i= hash; i < ids.length; i++) {
			if (ids[i] == id) {
				//replace value for existing entry
				if (oldPath != null)
					oldPaths[i]= oldPath;
				if (newPath != null)
					newPaths[i]= newPath;
				return;
			}
			if (ids[i] == 0) {
				//add a new entry to the map
				ids[i]= id;
				if (oldPath != null)
					oldPaths[i]= oldPath;
				if (newPath != null)
					newPaths[i]= newPath;
				elementCount++;
				// grow if necessary
				if (shouldGrow())
					expand();
				return;
			}
		}

		// search for an empty slot at the beginning of the array
		for (int i= 0; i < hash - 1; i++) {
			if (ids[i] == id) {
				//replace value for existing entry
				if (oldPath != null)
					oldPaths[i]= oldPath;
				if (newPath != null)
					newPaths[i]= newPath;
				return;
			}
			if (ids[i] == 0) {
				//add a new entry to the map
				ids[i]= id;
				if (oldPath != null)
					oldPaths[i]= oldPath;
				if (newPath != null)
					newPaths[i]= newPath;
				elementCount++;
				// grow if necessary
				if (shouldGrow())
					expand();
				return;
			}
		}
		// if we didn't find a free slot, then try again with the expanded set
		expand();
		put(id, oldPath, newPath);
	}

	/**
	 * Adds an entry for a node's old path
	 */
	public void putOldPath(long id, IPath path) {
		put(id, path, null);
	}

	/**
	 * Adds an entry for a node's old path
	 */
	public void putNewPath(long id, IPath path) {
		put(id, null, path);
	}

	private boolean shouldGrow() {
		return elementCount > ids.length * LOAD_FACTOR;
	}
}