bundles/org.eclipse.equinox.p2.metadata/src/org/eclipse/equinox/internal/p2/metadata/IUMap.java - equinox/rt.equinox.p2 - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009, 2018 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *     Cloudsmith Inc. - rewrite for smaller memory footprint
  *******************************************************************************/
 package org.eclipse.equinox.internal.p2.metadata;

 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.NoSuchElementException;
 import org.eclipse.equinox.internal.p2.core.helpers.CollectionUtils;
 import org.eclipse.equinox.p2.core.IPool;
 import org.eclipse.equinox.p2.metadata.IInstallableUnit;
 import org.eclipse.equinox.p2.metadata.Version;
 import org.eclipse.equinox.p2.query.CollectionResult;
 import org.eclipse.equinox.p2.query.Collector;
 import org.eclipse.equinox.p2.query.IQuery;
 import org.eclipse.equinox.p2.query.IQueryResult;
 import org.eclipse.equinox.p2.query.QueryUtil;

 /**
  * A map that stores {@link IInstallableUnit} instances in a way that is efficient to query
  */
 public class IUMap implements Cloneable {
 	/**
 	 * Iterator over all the {@link IInstallableUnit} instances in the map.
 	 */
 	public class MapIterator implements Iterator<IInstallableUnit> {
 		//iterator over the keys in UIMap
 		private final Iterator<Object> unitIterator;
 		private IInstallableUnit[] currentBucket;
 		private int bucketIndex = 0;
 		private IInstallableUnit nextElement = null;

 		MapIterator() {
 			super();
 			unitIterator = units.values().iterator();
 		}

 		@Override
 		public boolean hasNext() {
 			return positionNext();
 		}

 		@Override
 		public IInstallableUnit next() {
 			if (!positionNext())
 				throw new NoSuchElementException();

 			IInstallableUnit nxt = nextElement;
 			nextElement = null;
 			return nxt;
 		}

 		@Override
 		public void remove() {
 			throw new UnsupportedOperationException();
 		}

 		private boolean positionNext() {
 			if (nextElement != null)
 				return true;

 			if (currentBucket != null) {
 				nextElement = currentBucket[bucketIndex];
 				if (++bucketIndex == currentBucket.length) {
 					currentBucket = null;
 					bucketIndex = -1;
 				}
 				return true;
 			}

 			if (!unitIterator.hasNext())
 				return false;

 			Object val = unitIterator.next();
 			if (val instanceof IInstallableUnit)
 				nextElement = (IInstallableUnit) val;
 			else {
 				currentBucket = (IInstallableUnit[]) val;
 				nextElement = currentBucket[0];
 				bucketIndex = 1;
 			}
 			return true;
 		}
 	}

 	/**
 	 * Map<String,Object> mapping IU id to either arrays of iu's or a single iu with that id.
 	 */
 	final Map<String, Object> units = new HashMap<>();

 	public IUMap() {
 		//
 	}

 	private IUMap(IUMap cloneSource) {
 		units.putAll(cloneSource.units);
 	}

 	public void add(IInstallableUnit unit) {
 		String key = unit.getId();
 		Object matching = units.get(key);
 		if (matching == null) {
 			units.put(key, unit);
 			return;
 		}

 		// We already had something at this key position. It must be
 		// preserved.
 		if (matching.getClass().isArray()) {
 			// Entry is an array. Add unique
 			IInstallableUnit[] iuArr = (IInstallableUnit[]) matching;
 			int idx = iuArr.length;
 			while (--idx >= 0)
 				if (iuArr[idx].equals(unit))
 					// This unit has already been added
 					return;

 			IInstallableUnit[] iuArrPlus = new IInstallableUnit[iuArr.length + 1];
 			System.arraycopy(iuArr, 0, iuArrPlus, 0, iuArr.length);
 			iuArrPlus[iuArr.length] = unit;
 			units.put(unit.getId(), iuArrPlus);
 		} else {
 			IInstallableUnit old = (IInstallableUnit) matching;
 			if (!old.equals(unit))
 				units.put(key, new IInstallableUnit[] {old, unit});
 		}
 	}

 	public void addAll(IInstallableUnit[] toAdd) {
 		for (IInstallableUnit toAdd1 : toAdd) {
 			add(toAdd1);
 		}
 	}

 	public void addAll(Collection<IInstallableUnit> toAdd) {
 		for (IInstallableUnit unit : toAdd) {
 			add(unit);
 		}
 	}

 	public void clear() {
 		units.clear();
 	}

 	@Override
 	public IUMap clone() {
 		return new IUMap(this);
 	}

 	public Iterator<IInstallableUnit> iterator() {
 		return new MapIterator();
 	}

 	public boolean contains(IInstallableUnit unit) {
 		return !internalGet(unit.getId(), unit.getVersion()).isEmpty();
 	}

 	/**
 	 * Returns a collection of units that has the given <code>id</code>.
 	 * @param id The id of the desired units. Must not be <code>null</code>.
 	 * @return The units corresponding to the given <code>id</code>.
 	 */
 	public Collection<IInstallableUnit> getUnits(String id) {
 		Object bucket = units.get(id);
 		if (bucket == null)
 			return Collections.emptyList();
 		return bucket.getClass().isArray() ? CollectionUtils.unmodifiableList((IInstallableUnit[]) bucket) : Collections.singletonList((IInstallableUnit) bucket);
 	}

 	public IQueryResult<IInstallableUnit> get(String id) {
 		return internalGet(id, null);
 	}

 	private IQueryResult<IInstallableUnit> internalGet(String id, Version version) {
 		if (id == null) {
 			IQuery<IInstallableUnit> query = version == null ? QueryUtil.createIUAnyQuery() : QueryUtil.createIUQuery(null, version);
 			return query.perform(iterator());
 		}

 		Collection<IInstallableUnit> idUnits = getUnits(id);
 		if (idUnits.isEmpty())
 			return Collector.emptyCollector();
 		return version == null ? new CollectionResult<>(idUnits) : QueryUtil.createIUQuery(id, version).perform(idUnits.iterator());
 	}

 	public IInstallableUnit get(String id, Version version) {
 		IQueryResult<IInstallableUnit> result = internalGet(id, version);
 		return result.isEmpty() ? null : result.iterator().next();
 	}

 	public void remove(IInstallableUnit unit) {
 		String key = unit.getId();
 		Object matching = units.get(key);
 		if (matching == null)
 			return;

 		if (matching instanceof IInstallableUnit) {
 			if (matching.equals(unit))
 				units.remove(key);
 			return;
 		}

 		IInstallableUnit[] array = (IInstallableUnit[]) matching;
 		int idx = array.length;
 		while (--idx >= 0) {
 			if (unit.equals(array[idx])) {
 				if (array.length == 2) {
 					// We no longer need this array. Replace it with the
 					// entry that we keep.
 					units.put(key, idx == 0 ? array[1] : array[0]);
 					break;
 				}

 				// Shrink the array
 				IInstallableUnit[] newArray = new IInstallableUnit[array.length - 1];
 				if (idx > 0)
 					System.arraycopy(array, 0, newArray, 0, idx);
 				if (idx + 1 < array.length)
 					System.arraycopy(array, idx + 1, newArray, idx, array.length - (idx + 1));
 				units.put(key, newArray);
 				break;
 			}
 		}
 	}

 	public void removeAll(Collection<IInstallableUnit> toRemove) {
 		for (IInstallableUnit iu : toRemove)
 			remove(iu);
 	}

 	/**
 	 * Replace all instances of the IInstallableUnits in the receiver
 	 * with the shared IInstallableUnits from the provided iuPool.
 	 * This operation is a no-op if iuPool is null.
 	 *
 	 * @param iuPool an IPool containing the shared IInstallableUnits
 	 */
 	public void compress(IPool<IInstallableUnit> iuPool) {
 		if (iuPool == null) {
 			return;
 		}

 		Iterator<Entry<String, Object>> entries = units.entrySet().iterator();
 		while (entries.hasNext()) {
 			Entry<String, Object> entry = entries.next();
 			Object value = entry.getValue();
 			if (value.getClass().isArray()) {
 				IInstallableUnit[] array = (IInstallableUnit[]) value;
 				for (int i = 0; i < array.length; i++) {
 					array[i] = iuPool.add(array[i]);
 				}
 			} else {
 				entry.setValue(iuPool.add((IInstallableUnit) value));
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009, 2018 IBM Corporation and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* Cloudsmith Inc. - rewrite for smaller memory footprint
	*******************************************************************************/
	package org.eclipse.equinox.internal.p2.metadata;

	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.NoSuchElementException;
	import org.eclipse.equinox.internal.p2.core.helpers.CollectionUtils;
	import org.eclipse.equinox.p2.core.IPool;
	import org.eclipse.equinox.p2.metadata.IInstallableUnit;
	import org.eclipse.equinox.p2.metadata.Version;
	import org.eclipse.equinox.p2.query.CollectionResult;
	import org.eclipse.equinox.p2.query.Collector;
	import org.eclipse.equinox.p2.query.IQuery;
	import org.eclipse.equinox.p2.query.IQueryResult;
	import org.eclipse.equinox.p2.query.QueryUtil;

	/**
	* A map that stores {@link IInstallableUnit} instances in a way that is efficient to query
	*/
	public class IUMap implements Cloneable {
	/**
	* Iterator over all the {@link IInstallableUnit} instances in the map.
	*/
	public class MapIterator implements Iterator<IInstallableUnit> {
	//iterator over the keys in UIMap
	private final Iterator<Object> unitIterator;
	private IInstallableUnit[] currentBucket;
	private int bucketIndex = 0;
	private IInstallableUnit nextElement = null;

	MapIterator() {
	super();
	unitIterator = units.values().iterator();
	}

	@Override
	public boolean hasNext() {
	return positionNext();
	}

	@Override
	public IInstallableUnit next() {
	if (!positionNext())
	throw new NoSuchElementException();

	IInstallableUnit nxt = nextElement;
	nextElement = null;
	return nxt;
	}

	@Override
	public void remove() {
	throw new UnsupportedOperationException();
	}

	private boolean positionNext() {
	if (nextElement != null)
	return true;

	if (currentBucket != null) {
	nextElement = currentBucket[bucketIndex];
	if (++bucketIndex == currentBucket.length) {
	currentBucket = null;
	bucketIndex = -1;
	}
	return true;
	}

	if (!unitIterator.hasNext())
	return false;

	Object val = unitIterator.next();
	if (val instanceof IInstallableUnit)
	nextElement = (IInstallableUnit) val;
	else {
	currentBucket = (IInstallableUnit[]) val;
	nextElement = currentBucket[0];
	bucketIndex = 1;
	}
	return true;
	}
	}

	/**
	* Map<String,Object> mapping IU id to either arrays of iu's or a single iu with that id.
	*/
	final Map<String, Object> units = new HashMap<>();

	public IUMap() {
	//
	}

	private IUMap(IUMap cloneSource) {
	units.putAll(cloneSource.units);
	}

	public void add(IInstallableUnit unit) {
	String key = unit.getId();
	Object matching = units.get(key);
	if (matching == null) {
	units.put(key, unit);
	return;
	}

	// We already had something at this key position. It must be
	// preserved.
	if (matching.getClass().isArray()) {
	// Entry is an array. Add unique
	IInstallableUnit[] iuArr = (IInstallableUnit[]) matching;
	int idx = iuArr.length;
	while (--idx >= 0)
	if (iuArr[idx].equals(unit))
	// This unit has already been added
	return;

	IInstallableUnit[] iuArrPlus = new IInstallableUnit[iuArr.length + 1];
	System.arraycopy(iuArr, 0, iuArrPlus, 0, iuArr.length);
	iuArrPlus[iuArr.length] = unit;
	units.put(unit.getId(), iuArrPlus);
	} else {
	IInstallableUnit old = (IInstallableUnit) matching;
	if (!old.equals(unit))
	units.put(key, new IInstallableUnit[] {old, unit});
	}
	}

	public void addAll(IInstallableUnit[] toAdd) {
	for (IInstallableUnit toAdd1 : toAdd) {
	add(toAdd1);
	}
	}

	public void addAll(Collection<IInstallableUnit> toAdd) {
	for (IInstallableUnit unit : toAdd) {
	add(unit);
	}
	}

	public void clear() {
	units.clear();
	}

	@Override
	public IUMap clone() {
	return new IUMap(this);
	}

	public Iterator<IInstallableUnit> iterator() {
	return new MapIterator();
	}

	public boolean contains(IInstallableUnit unit) {
	return !internalGet(unit.getId(), unit.getVersion()).isEmpty();
	}

	/**
	* Returns a collection of units that has the given <code>id</code>.
	* @param id The id of the desired units. Must not be <code>null</code>.
	* @return The units corresponding to the given <code>id</code>.
	*/
	public Collection<IInstallableUnit> getUnits(String id) {
	Object bucket = units.get(id);
	if (bucket == null)
	return Collections.emptyList();
	return bucket.getClass().isArray() ? CollectionUtils.unmodifiableList((IInstallableUnit[]) bucket) : Collections.singletonList((IInstallableUnit) bucket);
	}

	public IQueryResult<IInstallableUnit> get(String id) {
	return internalGet(id, null);
	}

	private IQueryResult<IInstallableUnit> internalGet(String id, Version version) {
	if (id == null) {
	IQuery<IInstallableUnit> query = version == null ? QueryUtil.createIUAnyQuery() : QueryUtil.createIUQuery(null, version);
	return query.perform(iterator());
	}

	Collection<IInstallableUnit> idUnits = getUnits(id);
	if (idUnits.isEmpty())
	return Collector.emptyCollector();
	return version == null ? new CollectionResult<>(idUnits) : QueryUtil.createIUQuery(id, version).perform(idUnits.iterator());
	}

	public IInstallableUnit get(String id, Version version) {
	IQueryResult<IInstallableUnit> result = internalGet(id, version);
	return result.isEmpty() ? null : result.iterator().next();
	}

	public void remove(IInstallableUnit unit) {
	String key = unit.getId();
	Object matching = units.get(key);
	if (matching == null)
	return;

	if (matching instanceof IInstallableUnit) {
	if (matching.equals(unit))
	units.remove(key);
	return;
	}

	IInstallableUnit[] array = (IInstallableUnit[]) matching;
	int idx = array.length;
	while (--idx >= 0) {
	if (unit.equals(array[idx])) {
	if (array.length == 2) {
	// We no longer need this array. Replace it with the
	// entry that we keep.
	units.put(key, idx == 0 ? array[1] : array[0]);
	break;
	}

	// Shrink the array
	IInstallableUnit[] newArray = new IInstallableUnit[array.length - 1];
	if (idx > 0)
	System.arraycopy(array, 0, newArray, 0, idx);
	if (idx + 1 < array.length)
	System.arraycopy(array, idx + 1, newArray, idx, array.length - (idx + 1));
	units.put(key, newArray);
	break;
	}
	}
	}

	public void removeAll(Collection<IInstallableUnit> toRemove) {
	for (IInstallableUnit iu : toRemove)
	remove(iu);
	}

	/**
	* Replace all instances of the IInstallableUnits in the receiver
	* with the shared IInstallableUnits from the provided iuPool.
	* This operation is a no-op if iuPool is null.
	*
	* @param iuPool an IPool containing the shared IInstallableUnits
	*/
	public void compress(IPool<IInstallableUnit> iuPool) {
	if (iuPool == null) {
	return;
	}

	Iterator<Entry<String, Object>> entries = units.entrySet().iterator();
	while (entries.hasNext()) {
	Entry<String, Object> entry = entries.next();
	Object value = entry.getValue();
	if (value.getClass().isArray()) {
	IInstallableUnit[] array = (IInstallableUnit[]) value;
	for (int i = 0; i < array.length; i++) {
	array[i] = iuPool.add(array[i]);
	}
	} else {
	entry.setValue(iuPool.add((IInstallableUnit) value));
	}
	}
	}
	}