/*******************************************************************************
* Copyright (c) 2003, 2010 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
* Rob Harrop - SpringSource Inc. (bug 247521)
*******************************************************************************/
package org.eclipse.osgi.framework.internal.core;
import java.util.*;
import org.eclipse.osgi.framework.util.KeyedHashSet;
import org.osgi.framework.Version;
/**
* The BundleRepository holds all installed Bundle object for the
* Framework. The BundleRepository is also used to mark and unmark
* bundle dependancies.
*
* <p>
* This class is internally synchronized and supports client locking. Clients
* wishing to perform threadsafe composite operations on instances of this
* class can synchronize on the instance itself when doing these operations.
*/
public final class BundleRepository {
/** bundles by install order */
private List<AbstractBundle> bundlesByInstallOrder;
/** bundles keyed by bundle Id */
private KeyedHashSet bundlesById;
/** bundles keyed by SymbolicName */
private Map<String, AbstractBundle[]> bundlesBySymbolicName;
public BundleRepository(int initialCapacity) {
synchronized (this) {
bundlesByInstallOrder = new ArrayList<AbstractBundle>(initialCapacity);
bundlesById = new KeyedHashSet(initialCapacity, true);
bundlesBySymbolicName = new HashMap<String, AbstractBundle[]>(initialCapacity);
}
}
/**
* Gets a list of bundles ordered by install order.
* @return List of bundles by install order.
*/
public synchronized List<AbstractBundle> getBundles() {
return bundlesByInstallOrder;
}
/**
* Gets a bundle by its bundle Id.
* @param bundleId
* @return a bundle with the specified id or null if one does not exist
*/
public synchronized AbstractBundle getBundle(long bundleId) {
Long key = new Long(bundleId);
return (AbstractBundle) bundlesById.getByKey(key);
}
public synchronized AbstractBundle[] getBundles(String symbolicName) {
if (Constants.SYSTEM_BUNDLE_SYMBOLICNAME.equals(symbolicName))
symbolicName = Constants.getInternalSymbolicName();
return bundlesBySymbolicName.get(symbolicName);
}
public synchronized AbstractBundle getBundle(String symbolicName, Version version) {
AbstractBundle[] bundles = getBundles(symbolicName);
if (bundles != null) {
if (bundles.length > 0) {
for (int i = 0; i < bundles.length; i++) {
if (bundles[i].getVersion().equals(version)) {
return bundles[i];
}
}
}
}
return null;
}
public synchronized void add(AbstractBundle bundle) {
bundlesByInstallOrder.add(bundle);
bundlesById.add(bundle);
addSymbolicName(bundle);
}
private void addSymbolicName(AbstractBundle bundle) {
String symbolicName = bundle.getSymbolicName();
if (symbolicName == null)
return;
AbstractBundle[] bundles = bundlesBySymbolicName.get(symbolicName);
if (bundles == null) {
// making the initial capacity on this 1 since it
// should be rare that multiple version exist
bundles = new AbstractBundle[1];
bundles[0] = bundle;
bundlesBySymbolicName.put(symbolicName, bundles);
return;
}
List<AbstractBundle> list = new ArrayList<AbstractBundle>(bundles.length + 1);
// find place to insert the bundle
Version newVersion = bundle.getVersion();
boolean added = false;
for (int i = 0; i < bundles.length; i++) {
AbstractBundle oldBundle = bundles[i];
Version oldVersion = oldBundle.getVersion();
if (!added && newVersion.compareTo(oldVersion) >= 0) {
added = true;
list.add(bundle);
}
list.add(oldBundle);
}
if (!added) {
list.add(bundle);
}
bundles = new AbstractBundle[list.size()];
list.toArray(bundles);
bundlesBySymbolicName.put(symbolicName, bundles);
}
public synchronized boolean remove(AbstractBundle bundle) {
// remove by bundle ID
boolean found = bundlesById.remove(bundle);
if (!found)
return false;
// remove by install order
bundlesByInstallOrder.remove(bundle);
// remove by symbolic name
String symbolicName = bundle.getSymbolicName();
if (symbolicName == null)
return true;
removeSymbolicName(symbolicName, bundle);
return true;
}
private void removeSymbolicName(String symbolicName, AbstractBundle bundle) {
AbstractBundle[] bundles = bundlesBySymbolicName.get(symbolicName);
if (bundles == null)
return;
// found some bundles with the global name.
// remove all references to the specified bundle.
int numRemoved = 0;
for (int i = 0; i < bundles.length; i++) {
if (bundle == bundles[i]) {
numRemoved++;
bundles[i] = null;
}
}
if (numRemoved > 0) {
if (bundles.length - numRemoved <= 0) {
// no bundles left in the array remove the array from the hash
bundlesBySymbolicName.remove(symbolicName);
} else {
// create a new array with the null entries removed.
AbstractBundle[] newBundles = new AbstractBundle[bundles.length - numRemoved];
int indexCnt = 0;
for (int i = 0; i < bundles.length; i++) {
if (bundles[i] != null) {
newBundles[indexCnt] = bundles[i];
indexCnt++;
}
}
bundlesBySymbolicName.put(symbolicName, newBundles);
}
}
}
public synchronized void update(String oldSymbolicName, AbstractBundle bundle) {
if (oldSymbolicName != null) {
if (!oldSymbolicName.equals(bundle.getSymbolicName())) {
removeSymbolicName(oldSymbolicName, bundle);
addSymbolicName(bundle);
}
} else {
addSymbolicName(bundle);
}
}
public synchronized void removeAllBundles() {
bundlesByInstallOrder.clear();
bundlesById = new KeyedHashSet();
bundlesBySymbolicName.clear();
}
}