Attachment #153351 for bug #233643




import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.eclipse.pde.api.tools.internal.model.ApiModelCache;
import org.eclipse.pde.api.tools.internal.model.ApiModelFactory;
import org.eclipse.pde.api.tools.internal.model.StubApiComponent;
import org.eclipse.pde.api.tools.internal.model.WorkspaceBaseline;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.IApiBaselineManager;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;

import org.eclipse.pde.api.tools.internal.util.Util;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;
import org.eclipse.pde.internal.core.DependencyManager;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

			IApiComponent comp = components[i];
			if (!comp.isSystemComponent()) {
				celement = document.createElement(IApiXmlConstants.ELEMENT_APICOMPONENT);
				celement.setAttribute(IApiXmlConstants.ATTR_ID, comp.getSymbolicName());
				celement.setAttribute(IApiXmlConstants.ATTR_VERSION, comp.getVersion());
				celement.setAttribute(IApiXmlConstants.ATTR_LOCATION, new Path(comp.getLocation()).toPortableString());
				root.appendChild(celement);

		long time = System.currentTimeMillis();
		IApiBaseline baseline = null; 
		try {
			baseline = new WorkspaceBaseline();
			// populate it with only projects that are API aware
			Set ids = DependencyManager.getSelfandDependencies(PluginRegistry.getWorkspaceModels(), null);
			List componentsList = new ArrayList(ids.size());
			IApiComponent apiComponent = null;
			IPluginModelBase model = null;
			for (Iterator iter = ids.iterator(); iter.hasNext();) {
				model = PluginRegistry.findModel((String) iter.next());
				if(model == null) {
					continue;
				}
				try {
					apiComponent = ApiModelFactory.newApiComponent(baseline, model);
					if (apiComponent != null) {
						componentsList.add(apiComponent);
					}

			baseline.addApiComponents((IApiComponent[]) componentsList.toArray(new IApiComponent[componentsList.size()]));
		} finally {
			if (DEBUG) {
				System.out.println("Time to create a workspace baseline : " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
			}
		}
		return baseline;

Lines 72-78 Link Here

(-)src/org/eclipse/pde/api/tools/internal/ApiDescriptionXmlCreator.java (-1 / +1 lines)
72	* @throws CoreException if unable to construct the visitor	72	* @throws CoreException if unable to construct the visitor
73	*/	73	*/
74	public ApiDescriptionXmlCreator(IApiComponent component) throws CoreException {	74	public ApiDescriptionXmlCreator(IApiComponent component) throws CoreException {
75	this(component.getName(), component.getId());	75	this(component.getName(), component.getSymbolicName());
76	}	76	}
77		77
78	/**	78	/**




import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.pde.api.tools.internal.model.BundleComponent;
import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
import org.eclipse.pde.api.tools.internal.provisional.ApiDescriptionVisitor;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.Factory;

						for (int i = 0; i < fragments.length; i++) {
							names.add(fragments[i].getElementName());
						}
						ProjectComponent component = getApiComponent();
						BundleComponent.initializeApiDescription(this, component.getBundleDescription(), names);
						fPackageTimeStamp = fManifestFile.getModificationStamp();
					} catch (CoreException e) {
						ApiPlugin.log(e.getStatus());

	 * @return API component
	 * @exception CoreException if the API component cannot be located
	 */
	private ProjectComponent getApiComponent() throws CoreException {
		IApiBaseline baseline = ApiBaselineManager.getManager().getWorkspaceBaseline();
		ProjectComponent component = (ProjectComponent) baseline.getApiComponent(getJavaProject().getProject());
		if (component == null) {
			throw new CoreException(new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, "Unable to resolve project API component for API description"));  //$NON-NLS-1$
		}

Lines 72-78 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/AbstractIllegalMethodReference.java (-1 / +1 lines)
72	IApiMember method = reference.getResolvedReference();	72	IApiMember method = reference.getResolvedReference();
73	String componentId = (String) fMethodComponents.get(method.getHandle());	73	String componentId = (String) fMethodComponents.get(method.getHandle());
74	// TODO: would it be faster to store component objects and use identity instead of equals?	74	// TODO: would it be faster to store component objects and use identity instead of equals?
75	return componentId != null && method.getApiComponent().getId().equals(componentId);	75	return componentId != null && method.getApiComponent().getSymbolicName().equals(componentId);
76	}	76	}
77		77
78	/* (non-Javadoc)	78	/* (non-Javadoc)

Lines 79-85 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/AbstractIllegalTypeReference.java (-1 / +1 lines)
79	}	79	}
80	IApiMember type = reference.getResolvedReference();	80	IApiMember type = reference.getResolvedReference();
81	Object componentId = fIllegalTypes.get(type.getName());	81	Object componentId = fIllegalTypes.get(type.getName());
82	return componentId != null && type.getApiComponent().getId().equals(componentId);	82	return componentId != null && type.getApiComponent().getSymbolicName().equals(componentId);
83	}	83	}
84	/* (non-Javadoc)	84	/* (non-Javadoc)
85	* @see org.eclipse.pde.api.tools.internal.search.AbstractProblemDetector#getSourceRange(org.eclipse.jdt.core.IType, org.eclipse.jface.text.IDocument, org.eclipse.pde.api.tools.internal.provisional.model.IReference)	85	* @see org.eclipse.pde.api.tools.internal.search.AbstractProblemDetector#getSourceRange(org.eclipse.jdt.core.IType, org.eclipse.jface.text.IDocument, org.eclipse.pde.api.tools.internal.provisional.model.IReference)

Lines 31-37 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/AbstractProblemDetector.java (-3 / +3 lines)
31	import org.eclipse.jface.text.BadLocationException;	31	import org.eclipse.jface.text.BadLocationException;
32	import org.eclipse.jface.text.IDocument;	32	import org.eclipse.jface.text.IDocument;
33	import org.eclipse.jface.text.Position;	33	import org.eclipse.jface.text.Position;
34	import org.eclipse.pde.api.tools.internal.model.PluginProjectApiComponent;	34	import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
35	import org.eclipse.pde.api.tools.internal.problems.ApiProblemFactory;	35	import org.eclipse.pde.api.tools.internal.problems.ApiProblemFactory;
36	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;	36	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
37	import org.eclipse.pde.api.tools.internal.provisional.IApiMarkerConstants;	37	import org.eclipse.pde.api.tools.internal.provisional.IApiMarkerConstants;
Lines 368-375 Link Here
368	try {	368	try {
369	IApiProblem problem = null;	369	IApiProblem problem = null;
370	IApiComponent component = reference.getMember().getApiComponent();	370	IApiComponent component = reference.getMember().getApiComponent();
371	if (component instanceof PluginProjectApiComponent) {	371	if (component instanceof ProjectComponent) {
372	PluginProjectApiComponent ppac = (PluginProjectApiComponent) component;	372	ProjectComponent ppac = (ProjectComponent) component;
373	IJavaProject project = ppac.getJavaProject();	373	IJavaProject project = ppac.getJavaProject();
374	problem = createProblem(reference, project);	374	problem = createProblem(reference, project);
375	} else {	375	} else {




import org.eclipse.pde.api.tools.internal.ApiFilterStore;
import org.eclipse.pde.api.tools.internal.IApiCoreConstants;
import org.eclipse.pde.api.tools.internal.comparator.Delta;
import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
import org.eclipse.pde.api.tools.internal.problems.ApiProblemFactory;
import org.eclipse.pde.api.tools.internal.problems.ApiProblemFilter;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;

			}
			boolean checkfilters = false;
			if(baseline != null) {
				IApiComponent reference = baseline.getApiComponent(component.getSymbolicName());
				this.fBuildState = state;
				if(fBuildState == null) {
					fBuildState = getBuildState();
				}
				//compatibility checks
				if(reference != null) {
					localMonitor.subTask(NLS.bind(BuilderMessages.BaseApiAnalyzer_comparing_api_profiles, new String[] {reference.getSymbolicName(), baseline.getName()}));
					if(bcontext.hasChangedTypes()) {
						String[] changedtypes = bcontext.getStructurallyChangedTypes();
						for(int i = 0; i < changedtypes.length; i++) {

					}
					this.fBuildState.setReexportedComponents(Util.getReexportedComponents(component));
				} else {
					localMonitor.subTask(NLS.bind(BuilderMessages.BaseApiAnalyzer_comparing_api_profiles, new String[] {component.getSymbolicName(), baseline.getName()}));
					checkCompatibility(null, component, localMonitor.newChild(1));
					Util.updateMonitor(localMonitor);
				}

			}
			scope = getSearchScope(component, (String[]) typenames.toArray(new String[typenames.size()]));
		}
		SubMonitor localMonitor = SubMonitor.convert(monitor, MessageFormat.format(BuilderMessages.checking_api_usage, new String[] {component.getSymbolicName()}), 2);
		ReferenceAnalyzer analyzer = new ReferenceAnalyzer();
		try {
			long start = System.currentTimeMillis();

	 * @param monitor
	 */
	private void checkCompatibility(final String typeName, final IApiComponent reference, final IApiComponent component, IProgressMonitor monitor) throws CoreException {
		String id = component.getSymbolicName();
		if (DEBUG) {
			System.out.println("comparing profiles ["+reference.getSymbolicName()+"] and ["+id+"] for type ["+typeName+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		}
		IApiTypeRoot classFile = null;
		try {

				while (classFile == null && index < providers.length) {
					IApiComponent p = providers[index];
					if (!p.equals(component)) {
						String id2 = p.getSymbolicName();
						if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
							classFile = p.findTypeRoot(typeName);
						} else {

						IDelta.ADDED,
						IDelta.API_COMPONENT,
						null,
						component.getSymbolicName(),
						component.getSymbolicName());
				Util.updateMonitor(localmonitor, 5);
			} else {
				try {
					delta = ApiComparator.compare(reference, component, VisibilityModifiers.API, localmonitor.newChild(1));
				} finally {
					if (DEBUG) {
						System.out.println("Time spent for " + component.getSymbolicName() + " : " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
					}
					fPendingDeltaInfos.clear();
				}

	private void createApiComponentResolutionProblem(final IApiComponent component, final String message) throws CoreException {
		IApiProblem problem = ApiProblemFactory.newApiComponentResolutionProblem(
				Path.EMPTY.toPortableString(),
				new String[] {component.getSymbolicName(), message },
				new String[] {IApiMarkerConstants.API_MARKER_ATTR_ID},
				new Object[] {new Integer(IApiMarkerConstants.API_COMPONENT_RESOLUTION_MARKER_ID)},
				IElementDescriptor.RESOURCE,

							IApiTypeRoot typeRoot = null;
							IApiType type = null;
							try {
								String id = component.getSymbolicName();
								if (Util.ORG_ECLIPSE_SWT.equals(id)) {
									typeRoot = component.findTypeRoot(typeName);
								} else {

									while (typeRoot == null && index < providers.length) {
										IApiComponent p = providers[index];
										if (!p.equals(component)) {
											String id2 = p.getSymbolicName();
											if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
												typeRoot = p.findTypeRoot(typeName);
											} else {

		Version compversion = new Version(compversionval);
		Version newversion = null;
		if (DEBUG) {
			System.out.println("reference version of " + reference.getSymbolicName() + " : " + refversion); //$NON-NLS-1$ //$NON-NLS-2$
			System.out.println("component version of " + component.getSymbolicName() + " : " + compversion); //$NON-NLS-1$ //$NON-NLS-2$
		}
		IDelta[] breakingChanges = fBuildState.getBreakingChanges();
		if (breakingChanges.length != 0) {

	 * @return Java project or <code>null</code>
	 */
	private IJavaProject getJavaProject(IApiComponent component) {
		if (component instanceof ProjectComponent) {
			ProjectComponent pp = (ProjectComponent) component;
			return pp.getJavaProject();
		}
		return null;

Lines 315-321 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/BuildState.java (-1 / +1 lines)
315	final int length = components.length;	315	final int length = components.length;
316	String[] result = new String[length];	316	String[] result = new String[length];
317	for (int i = 0; i < length; i++) {	317	for (int i = 0; i < length; i++) {
318	result[i] = components[i].getId();	318	result[i] = components[i].getSymbolicName();
319	}	319	}
320	this.reexportedComponents = result;	320	this.reexportedComponents = result;
321	}	321	}

Lines 144-149 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/IllegalFieldReferenceDetector.java (-1 / +1 lines)
144	return false;	144	return false;
145	}	145	}
146	Object componentId = fFieldComponents.get(reference.getResolvedReference().getHandle());	146	Object componentId = fFieldComponents.get(reference.getResolvedReference().getHandle());
147	return componentId != null && reference.getResolvedReference().getApiComponent().getId().equals(componentId);	147	return componentId != null && reference.getResolvedReference().getApiComponent().getSymbolicName().equals(componentId);
148	}	148	}
149	}	149	}




import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
import org.eclipse.pde.api.tools.internal.provisional.ApiDescriptionVisitor;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.IApiAnnotations;

			default:
				if (!RestrictionModifiers.isUnrestricted(mask)) {
					if(RestrictionModifiers.isOverrideRestriction(mask) && fIllegalOverride != null) {
						fIllegalOverride.addIllegalMethod((IMethodDescriptor) element, fComponent.getSymbolicName());
					}
					if (RestrictionModifiers.isExtendRestriction(mask) && fIllegalExtends != null) {
						fIllegalExtends.addIllegalType((IReferenceTypeDescriptor) element, fComponent.getSymbolicName());
					}
					if (RestrictionModifiers.isImplementRestriction(mask) && fIllegalImplements != null) {
						fIllegalImplements.addIllegalType((IReferenceTypeDescriptor) element, fComponent.getSymbolicName());
					}
					if (RestrictionModifiers.isInstantiateRestriction(mask) && fIllegalInstantiate != null) {
						fIllegalInstantiate.addIllegalType((IReferenceTypeDescriptor) element, fComponent.getSymbolicName());
					}
					if (RestrictionModifiers.isReferenceRestriction(mask)) {
						if (element.getElementType() == IElementDescriptor.METHOD && fIllegalMethodRef != null) {
							fIllegalMethodRef.addIllegalMethod((IMethodDescriptor) element, fComponent.getSymbolicName());
						} else if (element.getElementType() == IElementDescriptor.FIELD && fIllegalFieldRef != null) {
							fIllegalFieldRef.addIllegalField((IFieldDescriptor) element, fComponent.getSymbolicName());
						}
					}
				}

	 * if the component is not a {@link PluginProjectApiComponent}
	 */
	private IProject getProject(IApiComponent component) {
		if(component instanceof ProjectComponent) {
			ProjectComponent comp = (ProjectComponent) component;
			return comp.getJavaProject().getProject();
		}
		return null;




			visibility = annot.getVisibility();
			if(annot.getVisibility() == VisibilityModifiers.PRIVATE) {
				IApiComponent host = mcomponent.getHost();
				if(host != null && host.getSymbolicName().equals(rcomponent.getSymbolicName())) {
					visibility = UseReportConverter.FRAGMENT_PERMISSIBLE;
				}
				else {
					IApiAccess access = description.resolveAccessLevel(
							Factory.componentDescriptor(mcomponent.getSymbolicName()),  // component descriptors in API description are not version qualified
							getResolvedReference().getHandle().getPackage());
					if(access != null && access.getAccessLevel() == IApiAccess.FRIEND) {
						visibility = VisibilityModifiers.PRIVATE_PERMISSIBLE;

Lines 145-151 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/ReferenceResolver.java (-1 / +1 lines)
145	*/	145	*/
146	private static String createSignatureKey(IReference reference) throws CoreException {	146	private static String createSignatureKey(IReference reference) throws CoreException {
147	StringBuffer buffer = new StringBuffer();	147	StringBuffer buffer = new StringBuffer();
148	buffer.append(reference.getMember().getApiComponent().getId());	148	buffer.append(reference.getMember().getApiComponent().getSymbolicName());
149	buffer.append("#"); //$NON-NLS-1$	149	buffer.append("#"); //$NON-NLS-1$
150	buffer.append(reference.getReferencedTypeName());	150	buffer.append(reference.getReferencedTypeName());
151	switch (reference.getReferenceType()) {	151	switch (reference.getReferenceType()) {




import org.eclipse.jface.text.Position;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.ImportPackageSpecification;
import org.eclipse.pde.api.tools.internal.model.BundleComponent;
import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.ProfileModifiers;
import org.eclipse.pde.api.tools.internal.provisional.builder.IReference;

					 * Make sure that the resolved reference doesn't below to one of the imported package of
					 * the current component
					 */
					if (apiComponent instanceof BundleComponent) {
						BundleDescription bundle = ((BundleComponent)apiComponent).getBundleDescription();
						ImportPackageSpecification[] importPackages = bundle.getImportPackages();
						String referencedTypeName = reference.getReferencedTypeName();
						int index = referencedTypeName.lastIndexOf('.');

				try {
					IApiProblem problem = null;
					IApiComponent component = reference.getMember().getApiComponent();
					if (component instanceof ProjectComponent) {
						ProjectComponent ppac = (ProjectComponent) component;
						IJavaProject project = ppac.getJavaProject();
						problem = createProblem(reference, project);
					} else {

Lines 130-136 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/TypeScope.java (-1 / +1 lines)
130	* @see org.eclipse.pde.api.tools.internal.provisional.IApiTypeContainer#findClassFile(java.lang.String, java.lang.String)	130	* @see org.eclipse.pde.api.tools.internal.provisional.IApiTypeContainer#findClassFile(java.lang.String, java.lang.String)
131	*/	131	*/
132	public IApiTypeRoot findTypeRoot(String qualifiedName, String id) throws CoreException {	132	public IApiTypeRoot findTypeRoot(String qualifiedName, String id) throws CoreException {
133	if (fComponent.getId().equals(id)) {	133	if (fComponent.getSymbolicName().equals(id)) {
134	return findTypeRoot(qualifiedName);	134	return findTypeRoot(qualifiedName);
135	}	135	}
136	return null;	136	return null;




					if (result == null) {
						// TODO should we report this failure ?
						if (Debug) {
							System.err.println("CHECKED EXCEPTION LOOKUP: Could not find " + superName + " in profile " + profile.getName() + " from component " + apiComponent.getSymbolicName()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
						}
						break;
					}

		String packageName = Signatures.getPackageName(typeName);
		IApiComponent[] components = profile.resolvePackage(component, packageName);
		if (components == null) {
			String msg = MessageFormat.format(ComparatorMessages.ClassFileComparator_1, new String[] {packageName, profile.getName(), component.getSymbolicName()});
			if (Debug) {
				System.err.println("TYPE LOOKUP: "+msg); //$NON-NLS-1$
			}
			reportStatus(new Status(IStatus.ERROR, component.getSymbolicName(), msg));
			return null;
		}
		IApiTypeRoot result = Util.getClassFile(components, typeName); 
		if (result == null) {
			String msg = MessageFormat.format(ComparatorMessages.ClassFileComparator_2, new String[] {typeName, profile.getName(), component.getSymbolicName()});
			if (Debug) {
				System.err.println("TYPE LOOKUP: "+msg); //$NON-NLS-1$
			}
			reportStatus(new Status(IStatus.ERROR, component.getSymbolicName(), msg));
			return null;
		}
		return result;




/*******************************************************************************
 * Copyright (c) 2007, 2009 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.pde.api.tools.internal.model;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.api.tools.internal.problems.ApiProblemFilter;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.Factory;
import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;
import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;
import org.eclipse.pde.api.tools.internal.provisional.descriptors.IElementDescriptor;
import org.eclipse.pde.api.tools.internal.provisional.model.ApiTypeContainerVisitor;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiElement;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
import org.eclipse.pde.api.tools.internal.provisional.problems.IApiProblem;
import org.eclipse.pde.api.tools.internal.provisional.problems.IApiProblemFilter;

/**
 * Common implementation of an API component as a composite class file container.
 * 
 * @since 1.0.0
 */
public abstract class AbstractApiComponent extends AbstractApiTypeContainer implements IApiComponent {
	/**
	 * API description
	 */
	private IApiDescription fApiDescription = null;
		
	/**
	 * Api Filter store
	 */
	private IApiFilterStore fFilterStore = null;
	
	/**
	 * Constructs an API component in the given {@link IApiBaseline}.
	 * 
	 * @param baseline the parent {@link IApiBaseline}
	 */
	public AbstractApiComponent(IApiBaseline baseline) {
		super(baseline, IApiElement.COMPONENT, null);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IClassFileContainer#accept(org.eclipse.pde.api.tools.model.component.ClassFileContainerVisitor)
	 */
	public void accept(ApiTypeContainerVisitor visitor) throws CoreException {
		if (visitor.visit(this)) {
			super.accept(visitor);
		}
		visitor.end(this);
	}	
		
	/**
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getHost()
	 */
	public IApiComponent getHost() throws CoreException {
		return null;
	}
	
	/**
	 * @see org.eclipse.pde.api.tools.internal.provisional.IApiComponent#getBaseline()
	 */
	public IApiBaseline getBaseline() {
		return (IApiBaseline) getAncestor(IApiElement.BASELINE);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IApiComponent#dispose()
	 */
	public void dispose() {
		try {
			close();
		} catch (CoreException e) {
			ApiPlugin.log(e);
		}
		fApiDescription = null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.ApiElement#getApiComponent()
	 */
	public IApiComponent getApiComponent() {
		return this;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IApiComponent#getApiDescription()
	 */
	public synchronized IApiDescription getApiDescription() throws CoreException {
		if (fApiDescription == null) {
			fApiDescription = createApiDescription();
		}
		return fApiDescription;
	}
	
	/**
	 * Returns whether this component has created an API description.
	 * 
	 * @return whether this component has created an API description
	 */
	protected synchronized boolean isApiDescriptionInitialized() {
		return fApiDescription != null;
	}

	/**
	 * Returns if this component has created an API filter store
	 * 
	 * @return true if a store has been created, false other wise
	 */
	protected synchronized boolean hasApiFilterStore() {
		return fFilterStore != null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.AbstractApiTypeContainer#getApiTypeContainers()
	 */
	public synchronized IApiTypeContainer[] getApiTypeContainers() throws CoreException {
		return super.getApiTypeContainers();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.AbstractApiTypeContainer#getApiTypeContainers()
	 */
	public synchronized IApiTypeContainer[] getApiTypeContainers(String id) throws CoreException {
		if (this.hasFragments()) {
			return super.getApiTypeContainers(id);
		} else {
			return super.getApiTypeContainers();
		}
	}
	
	/**
	 * Creates and returns the API description for this component.
	 * 
	 * @return newly created API description for this component
	 */
	protected abstract IApiDescription createApiDescription() throws CoreException;

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.IApiComponent#getFilterStore()
	 */
	public IApiFilterStore getFilterStore() throws CoreException {
		if(fFilterStore == null) {
			fFilterStore = createApiFilterStore();
		}
		return fFilterStore;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.IApiComponent#newProblemFilter(org.eclipse.pde.api.tools.internal.provisional.IApiProblem)
	 */
	public IApiProblemFilter newProblemFilter(IApiProblem problem) throws CoreException {
		//TODO either expose a way to make problems or change the method to accept the parts of a problem
		return new ApiProblemFilter(getId(), problem);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getHandle()
	 */
	public IElementDescriptor getHandle() {
		return Factory.componentDescriptor(this.getId(), this.getVersion());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer#getContainerType()
	 */
	public int getContainerType() {
		return IApiTypeContainer.COMPONENT;
	}
	
	/**
	 * Lazily creates a new {@link IApiFilterStore} when it is requested
	 * 
	 * @return the current {@link IApiFilterStore} for this component
	 * @throws CoreException
	 */
	protected abstract IApiFilterStore createApiFilterStore() throws CoreException;	
}

Lines 116-122 Link Here

(-)src/org/eclipse/pde/api/tools/internal/model/AbstractApiTypeContainer.java (-2 / +2 lines)
116	for (int i = 0; i < containers.length; i++) {	116	for (int i = 0; i < containers.length; i++) {
117	comp = (IApiComponent) containers[i].getAncestor(IApiElement.COMPONENT);	117	comp = (IApiComponent) containers[i].getAncestor(IApiElement.COMPONENT);
118	if(comp != null) {	118	if(comp != null) {
119	origin = comp.getId();	119	origin = comp.getSymbolicName();
120	}	120	}
121	if (origin == null) {	121	if (origin == null) {
122	IApiTypeRoot file = containers[i].findTypeRoot(qualifiedName);	122	IApiTypeRoot file = containers[i].findTypeRoot(qualifiedName);
Lines 180-186 Link Here
180	IApiTypeContainer container = null;	180	IApiTypeContainer container = null;
181	for (Iterator iterator = this.fApiTypeContainers.iterator(); iterator.hasNext(); ) {	181	for (Iterator iterator = this.fApiTypeContainers.iterator(); iterator.hasNext(); ) {
182	container = (IApiTypeContainer) iterator.next();	182	container = (IApiTypeContainer) iterator.next();
183	origin = ((IApiComponent)container.getAncestor(IApiElement.COMPONENT)).getId();	183	origin = ((IApiComponent)container.getAncestor(IApiElement.COMPONENT)).getSymbolicName();
184	if (origin != null && origin.equals(id)) {	184	if (origin != null && origin.equals(id)) {
185	containers.add(container);	185	containers.add(container);
186	}	186	}

Lines 47-53 Link Here

(-)src/org/eclipse/pde/api/tools/internal/model/AbstractApiTypeRoot.java (-1 / +1 lines)
47	IApiType type = null;	47	IApiType type = null;
48	if(comp != null) {	48	if(comp != null) {
49	IApiBaseline baseline = comp.getBaseline();	49	IApiBaseline baseline = comp.getBaseline();
50	type = (IApiType) cache.getElementInfo(baseline.getName(), comp.getId(), this.getTypeName(), IApiElement.TYPE);	50	type = (IApiType) cache.getElementInfo(baseline.getName(), comp.getSymbolicName(), this.getTypeName(), IApiElement.TYPE);
51	}	51	}
52	if(type == null) {	52	if(type == null) {
53	type = TypeStructureBuilder.buildTypeStructure(getContents(), getApiComponent(), this);	53	type = TypeStructureBuilder.buildTypeStructure(getContents(), getApiComponent(), this);




		getState().setPlatformProperties(dictionary);
		// clean up previous system library
		if (fSystemLibraryComponent != null && fComponentsById != null) {
			fComponentsById.remove(fSystemLibraryComponent.getSymbolicName());
		}
		if(fSystemPackageNames != null) {
			fSystemPackageNames.clear();

	 * Adds an {@link IApiComponent} to the fComponentsById mapping
	 * @param component
	 */
	protected void addComponent(IApiComponent component) throws CoreException {
		if(component == null) {
			return;
		}
		if(fComponentsById == null) {
			fComponentsById = new HashMap();
		}
		fComponentsById.put(component.getSymbolicName(), component);
		if (component instanceof ProjectComponent) {
			ProjectComponent projectApiComponent = (ProjectComponent) component;
			if (this.fComponentsByProjectNames == null) {
				this.fComponentsByProjectNames = new HashMap();
			}

	public void addApiComponents(IApiComponent[] components) throws CoreException {
		HashSet ees = new HashSet();
		for (int i = 0; i < components.length; i++) {
			BundleComponent component = (BundleComponent) components[i];
			if (component.isSourceComponent()) {
				continue;
			}

	 * Resolves and initializes the system library to use based on API component requirements.
	 * Only works when running in the framework. Has no effect if not running in the framework.
	 */
	protected void resolveSystemLibrary(HashSet ees) {
		if (ApiPlugin.isRunningInFramework() && fAutoResolve) {
			IStatus error = null;
			IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();

	 * @throws CoreException
	 */
	private void resolvePackage0(IApiComponent component, String packageName, List componentsList) throws CoreException {
		if (component instanceof BundleComponent) {
			BundleDescription bundle = ((BundleComponent)component).getBundleDescription();
			if (bundle != null) {
				StateHelper helper = getState().getStateHelper();
				ExportPackageDescription[] visiblePackages = helper.getVisiblePackages(bundle);

		ArrayList bundles = new ArrayList(components.length);
		for (int i = 0; i < components.length; i++) {
			IApiComponent component = components[i];
			if (component instanceof BundleComponent) {
				bundles.add(((BundleComponent)component).getBundleDescription());
			}
		}
		return bundles;




				IApiComponent comp = element.getApiComponent();
				if(comp != null) {
					IApiBaseline baseline = comp.getBaseline();
					String id = comp.getSymbolicName();
					if(id == null) {
						return;
					}

					Cache typecache = (Cache) compcache.get(id);
					if(typecache == null) {
						typecache = new Cache(DEFAULT_CACHE_SIZE, DEFAULT_OVERFLOW);
						compcache.put(comp.getSymbolicName(), typecache);
					}
					ApiType type = (ApiType) element;
					if(type.isMemberType() || isMemberType(type.getName()) /*cache even a root type with a '$' in its name here as well*/) {

					if(comp != null) {
						try {
							IApiBaseline baseline = comp.getBaseline();
							return removeElementInfo(baseline.getName(), comp.getSymbolicName(), element.getName(), element.getType());
						}
						catch(CoreException ce) {}
					}




import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.util.Util;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;

/**
 * Utility class for creating new {@link org.eclipse.pde.api.tools.internal.provisional.model.IApiElement}s

	 * @exception CoreException if unable to create the component
	 */
	public static IApiComponent newApiComponent(IApiBaseline profile, String location) throws CoreException {
		BundleComponent component = new BundleComponent(profile, location, getBundleID());
		if(component.isValidBundle()) {
			component.init(getBundleID());
			return component;
		}
		return null;

	/**
	 * Creates and returns a new API component for this profile based on the given
	 * model or <code>null</code> if the given model cannot be resolved or does not contain
	 * a valid API component. The component is not added to the baseline.
	 *
	 * @param baseline
	 * @param model the given model
	 * @return API component or <code>null</code> if the given model cannot be resolved or does not contain
	 * a valid API component
	 * @exception CoreException if unable to create the component
	 */
	public static IApiComponent newApiComponent(IApiBaseline baseline, IPluginModelBase model) throws CoreException {
		BundleDescription bundleDescription = model.getBundleDescription();
		if (bundleDescription == null) {
			return null;

		if (location == null) {
			return null;
		}
		BundleComponent component = null;
		if (isBinaryProject(location)) {
			component = new BundleComponent(baseline, location, getBundleID());
			if (isBinaryProject(location)) {
				component = new BundleApiComponent(profile, location);
			} else {
				component = new PluginProjectApiComponent(profile, location, model);
			}
		} else {
			component = new ProjectComponent(baseline, location, model, getBundleID());
		}
		if(component.isValidBundle()) {
			component.init(getBundleID());
			return component;
		}
		return null;
	}
	
	/**
	 * Returns the plug-in model associated with the project at the specified location
	 * or <code>null</code> if none (i.e. if its an external model).
	 * 
	 * @param project location
	 * @return plug-in model or <code>null</code> if none
	 */
	private static IPluginModelBase getProjectModel(String location) {
		String projectName = (new Path(location)).lastSegment();
		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
		if (project != null) {
			return PluginRegistry.findModel(project); 
		}
		return null;
	}
	
	/**
	 * Returns if the specified location is an imported binary project.
	 * <p>
	 * We accept projects that are plug-ins even if not API enabled (i.e.

	private static boolean isBinaryProject(String location) throws CoreException {
		IPath path = new Path(location);
		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(path.lastSegment());
		return project != null && (!project.exists() || Util.isBinaryProject(project));
	}

	/**




/*******************************************************************************
 * Copyright (c) 2007, 2009 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.pde.api.tools.internal.model;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.BundleSpecification;
import org.eclipse.osgi.service.resolver.ExportPackageDescription;
import org.eclipse.osgi.service.resolver.HostSpecification;
import org.eclipse.osgi.service.resolver.ResolverError;
import org.eclipse.osgi.service.resolver.StateObjectFactory;
import org.eclipse.osgi.util.ManifestElement;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.api.tools.internal.ApiBaselineManager;
import org.eclipse.pde.api.tools.internal.ApiDescription;
import org.eclipse.pde.api.tools.internal.ApiDescriptionProcessor;
import org.eclipse.pde.api.tools.internal.BundleVersionRange;
import org.eclipse.pde.api.tools.internal.CompositeApiDescription;
import org.eclipse.pde.api.tools.internal.IApiCoreConstants;
import org.eclipse.pde.api.tools.internal.RequiredComponentDescription;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.Factory;
import org.eclipse.pde.api.tools.internal.provisional.IApiAccess;
import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;
import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;
import org.eclipse.pde.api.tools.internal.provisional.IRequiredComponentDescription;
import org.eclipse.pde.api.tools.internal.provisional.ProfileModifiers;
import org.eclipse.pde.api.tools.internal.provisional.VisibilityModifiers;
import org.eclipse.pde.api.tools.internal.provisional.descriptors.IPackageDescriptor;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiElement;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
import org.eclipse.pde.api.tools.internal.util.FileManager;
import org.eclipse.pde.api.tools.internal.util.SourceDefaultHandler;
import org.eclipse.pde.api.tools.internal.util.Util;
import org.eclipse.pde.internal.core.TargetWeaver;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.framework.Version;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Implementation of an API component based on a bundle in the file system.
 * 
 * @since 1.0.0
 */
public class BundleApiComponent extends AbstractApiComponent {
	
	static final String TMP_API_FILE_PREFIX = "api"; //$NON-NLS-1$
	static final String TMP_API_FILE_POSTFIX = "tmp"; //$NON-NLS-1$
	
	/**
	 * Dictionary parsed from MANIFEST.MF
	 */
	private Dictionary fManifest;
	
	/**
	 * Manifest headers that are maintained after {@link BundleDescription} creation.
	 * Only these headers are maintained in the manifest dictionary to reduce footprint.  
	 */
	private static final String[] MANIFEST_HEADERS = new String[] {
		IApiCoreConstants.ECLIPSE_SOURCE_BUNDLE,
		Constants.BUNDLE_CLASSPATH,
		Constants.BUNDLE_NAME,
		Constants.BUNDLE_VERSION
	};
	
	/**
	 * Whether there is an underlying .api_description file
	 */
	private boolean fHasApiDescription = false;
	
	/**
	 * Root location of component in the file system
	 */
	private String fLocation;
	
	/**
	 * Underlying bundle description (OSGi model of a bundle)
	 */
	private BundleDescription fBundleDescription;
	
	/**
	 * Symbolic name of this bundle
	 */
	private String fSymbolicName = null;
	
	/**
	 * Bundle version
	 */
	private Version fVersion = null;
	
	/**
	 * Cached value for the lowest EEs
	 */
	private String[] lowestEEs;

	/**
	 * Constructs a new API component from the specified location in the file system
	 * in the given profile.
	 * 
	 * @param profile owning profile
	 * @param location directory or jar file
	 * @exception CoreException if unable to create a component from the specified location
	 */
	public BundleApiComponent(IApiBaseline profile, String location) throws CoreException {
		super(profile);
		fLocation = location;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.descriptors.AbstractApiComponent#dispose()
	 */
	public void dispose() {
		try {
			super.dispose();
		} finally {
			synchronized(this) {
				fManifest = null;
				fBundleDescription = null;
			}
		}
	}
	
	/**
	 * Returns this bundle's manifest as a dictionary.
	 * 
	 * @return manifest dictionary
	 * @exception CoreException if something goes terribly wrong
	 */
	protected synchronized Dictionary getManifest() throws CoreException {
		if(fManifest == null) {
			try {
				fManifest = (Dictionary) loadManifest(new File(fLocation));
			} catch (IOException e) {
				abort("Unable to load manifest due to IO error", e); //$NON-NLS-1$
			}
		}
		return fManifest;
	}

	/**
	 * Reduce the manifest to only contain required headers after {@link BundleDescription} creation.
	 */
	protected synchronized void doManifestCompaction() throws CoreException {
		Dictionary temp = fManifest;
		fManifest = new Hashtable(MANIFEST_HEADERS.length);
		for (int i = 0; i < MANIFEST_HEADERS.length; i++) {
			String header = MANIFEST_HEADERS[i];
			Object value = temp.get(header);
			if (value != null) {
				fManifest.put(header, value);
			}
		}
	}
	
	/**
	 * Returns if the bundle at the specified location is a valid bundle or not.
	 * Validity is determined via the existence of a readable manifest file
	 * @param location
	 * @return true if the bundle at the given location is valid false otherwise
	 * @throws IOException
	 */
	public boolean isValidBundle() throws CoreException {
		Dictionary manifest = getManifest();
		return manifest != null && (manifest.get(Constants.BUNDLE_NAME) != null && manifest.get(Constants.BUNDLE_VERSION) != null);
	}
	
	/**
	 * Initializes component state from the underlying bundle for the given
	 * state.
	 * 
	 * @param state PDE state
	 * @throws CoreException on failure
	 */
	protected synchronized void init(long bundleId) throws CoreException {
		try {
			Dictionary manifest = getManifest();
			if (isBinaryBundle() && ApiBaselineManager.WORKSPACE_API_BASELINE_ID.equals(getBaseline().getName())) {
				// must account for bundles in development mode - look for class files in output
				// folders rather than jars
				TargetWeaver.weaveManifest(manifest);
			}
			StateObjectFactory factory = StateObjectFactory.defaultFactory;
			fBundleDescription = factory.createBundleDescription(((ApiBaseline)getBaseline()).getState(), manifest, fLocation, bundleId);
			fSymbolicName = fBundleDescription.getSymbolicName();
			fVersion = fBundleDescription.getVersion();
			setName((String)getManifest().get(Constants.BUNDLE_NAME));
		} catch (BundleException e) {
			abort("Unable to create API component from specified location: " + fLocation, e); //$NON-NLS-1$
		}
		// compact manifest after initialization - only keep used headers
		doManifestCompaction();
	}
	
	/**
	 * Returns whether this API component represents a binary bundle versus a project bundle.
	 * 
	 * @return whether this API component represents a binary bundle
	 */
	protected boolean isBinaryBundle() {
		return true;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.AbstractApiComponent#createApiDescription()
	 */
	protected IApiDescription createApiDescription() throws CoreException {
		BundleDescription[] fragments = getBundleDescription().getFragments();
		if (fragments.length == 0) {
			return createLocalApiDescription();
		}
		// build a composite description
		IApiDescription[] descriptions = new IApiDescription[fragments.length + 1];
		for (int i = 0; i < fragments.length; i++) {
			BundleDescription fragment = fragments[i];
			BundleApiComponent component = (BundleApiComponent) getBaseline().getApiComponent(fragment.getSymbolicName());
			descriptions[i + 1] = component.getApiDescription();
		}
		descriptions[0] = createLocalApiDescription();
		return new CompositeApiDescription(descriptions);
	}

	/**
	 * Creates and returns this component's API description based on packages
	 * supplied by this component, exported packages, and associated directives.
	 * 
	 * @return API description
	 * @throws CoreException if unable to initialize 
	 */
	protected IApiDescription createLocalApiDescription() throws CoreException {
		IApiDescription apiDesc = new ApiDescription(getId());
		// first mark all packages as internal
		initializeApiDescription(apiDesc, getBundleDescription(), getLocalPackageNames());
		try {
			String xml = loadApiDescription(new File(fLocation));
			setHasApiDescription(xml != null);
			if (xml != null) {
				ApiDescriptionProcessor.annotateApiSettings(null, apiDesc, xml);
			}
		} catch (IOException e) {
			abort("Unable to load .api_description file ", e); //$NON-NLS-1$
		}
		return apiDesc;
	}
	
	/**
	 * Returns the names of all packages that originate from this bundle.
	 * Does not include packages that originate from fragments or a host.
	 * 
	 * @return local package names
	 * @throws CoreException
	 */
	protected Set getLocalPackageNames() throws CoreException {
		Set names = new HashSet();
		IApiTypeContainer[] containers = getApiTypeContainers();
		IApiComponent comp = null;
		for (int i = 0; i < containers.length; i++) {
			comp = (IApiComponent) containers[i].getAncestor(IApiElement.COMPONENT);
			if (comp != null && comp.getId().equals(getId())) {
				String[] packageNames = containers[i].getPackageNames();
				for (int j = 0; j < packageNames.length; j++) {
					names.add(packageNames[j]);
				}
			}
		}
		return names;
	}	
	

	/**
	 * Initializes the given API description based on package exports in the manifest.
	 * The API description for a bundle only contains packages that originate from
	 * this bundle (so a host will not contain API descriptions for packages that
	 * originate from fragments). However, a host's API description will be represented
	 * by a proxy that delegates to the host and all of its fragments to provide
	 * a complete description of the host.
	 * 
	 * @param apiDesc API description to initialize
	 * @param bundle the bundle to load from
	 * @param packages the complete set of packages names originating from the backing
	 * 		component
	 * @throws CoreException if an error occurs
	 */
	public static void initializeApiDescription(IApiDescription apiDesc, BundleDescription bundle, Set packages) throws CoreException {
		Iterator iterator = packages.iterator();
		while (iterator.hasNext()) {
			String name = (String) iterator.next();
			apiDesc.setVisibility(Factory.packageDescriptor(name), VisibilityModifiers.PRIVATE);
		}
		// then process exported packages that originate from this bundle
		// considering host and fragment package exports
		List supplied = new ArrayList();
		ExportPackageDescription[] exportPackages = bundle.getExportPackages();
		addSuppliedPackages(packages, supplied, exportPackages);
		HostSpecification host = bundle.getHost();
		if (host != null) {
			BundleDescription[] hosts = host.getHosts();
			for (int i = 0; i < hosts.length; i++) {
				addSuppliedPackages(packages, supplied, hosts[i].getExportPackages());
			}
		}
		BundleDescription[] fragments = bundle.getFragments();
		for (int i = 0; i < fragments.length; i++) {
			addSuppliedPackages(packages, supplied, fragments[i].getExportPackages());
		}
		
		annotateExportedPackages(apiDesc, (ExportPackageDescription[]) supplied.toArray(new ExportPackageDescription[supplied.size()]));
	}

	/**
	 * Adds package exports to the given list if the associated package originates
	 * from this bundle.
	 *   
	 * @param packages names of packages supplied by this bundle
	 * @param supplied list to append package exports to
	 * @param exportPackages package exports to consider
	 */
	protected static void addSuppliedPackages(Set packages, List supplied, ExportPackageDescription[] exportPackages) {
		for (int i = 0; i < exportPackages.length; i++) {
			ExportPackageDescription pkg = exportPackages[i];
			String name = pkg.getName();
			if (name.equals(".")) { //$NON-NLS-1$
				// translate . to default package
				name = Util.DEFAULT_PACKAGE_NAME;
			}
			if (packages.contains(name)) {
				supplied.add(pkg);
			}
		}
	}
	
	/**
	 * Annotates the API description with exported packages.
	 * 
	 * @param apiDesc description to annotate
	 * @param exportedPackages packages that are exported
	 */
	protected static void annotateExportedPackages(IApiDescription apiDesc, ExportPackageDescription[] exportedPackages) {
		for(int i = 0; i < exportedPackages.length; i++) {
			ExportPackageDescription pkg = exportedPackages[i];
			boolean internal = ((Boolean) pkg.getDirective("x-internal")).booleanValue(); //$NON-NLS-1$
			String[] friends = (String[]) pkg.getDirective("x-friends"); //$NON-NLS-1$
			String pkgName = pkg.getName();
			if (pkgName.equals(".")) { //$NON-NLS-1$
				// default package
				pkgName = ""; //$NON-NLS-1$
			}
			IPackageDescriptor pkgDesc = Factory.packageDescriptor(pkgName);
			if(internal) {
				apiDesc.setVisibility(pkgDesc, VisibilityModifiers.PRIVATE);
			}
			if (friends != null) {
				apiDesc.setVisibility(pkgDesc, VisibilityModifiers.PRIVATE);
				for(int j = 0; j < friends.length; j++) {
					//annotate the api description for x-friends access levels
					apiDesc.setAccessLevel(
							Factory.componentDescriptor(friends[j]), 
							Factory.packageDescriptor(pkgName), 
							IApiAccess.FRIEND);
				}
			}
			if (!internal && friends == null) {
				//there could have been directives that have nothing to do with
				//visibility, so we need to add the package as API in that case
				apiDesc.setVisibility(pkgDesc, VisibilityModifiers.API);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.AbstractApiComponent#createApiFilterStore()
	 */
	protected IApiFilterStore createApiFilterStore() throws CoreException {
		//always return a new empty store since we do not support filtering from bundles
		return null;
	}
	
	/**
	 * @see org.eclipse.pde.api.tools.internal.AbstractApiTypeContainer#createApiTypeContainers()
	 */
	protected synchronized List createApiTypeContainers() throws CoreException {
		if (this.fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		List containers = new ArrayList(5);
		try {
			List all = new ArrayList();
			// build the classpath from bundle and all fragments
			all.add(this);
			boolean considerFragments = true;
			if (Util.ORG_ECLIPSE_SWT.equals(getId())) {
				// if SWT is a project to be built/analyzed don't consider its fragments
				considerFragments = !isApiEnabled();
			}
			if (considerFragments) { 
				BundleDescription[] fragments = fBundleDescription.getFragments();
				for (int i = 0; i < fragments.length; i++) {
					BundleDescription fragment = fragments[i];
					BundleApiComponent component = (BundleApiComponent) getBaseline().getApiComponent(fragment.getSymbolicName());
					if (component != null) {
						// force initialization of the fragment so we can retrieve its class file containers
						component.getApiTypeContainers();
						all.add(component);
					}
				}
			}
			Iterator iterator = all.iterator();
			Set entryNames = new HashSet(5);
			BundleApiComponent other = null;
			while (iterator.hasNext()) {
				BundleApiComponent component = (BundleApiComponent) iterator.next();
				String[] paths = getClasspathEntries(component.getManifest());
				for (int i = 0; i < paths.length; i++) {
					String path = paths[i];
					// don't re-process the same entry twice (except default entries ".")
					if (!(".".equals(path))) { //$NON-NLS-1$
						if (entryNames.contains(path)) {
							continue;
						}
					}
					IApiTypeContainer container = component.createApiTypeContainer(path);
					if (container == null) {
						for(Iterator iter = all.iterator(); iter.hasNext();) {
							other = (BundleApiComponent) iter.next();
							if (other != component) {
								container = other.createApiTypeContainer(path);
							}
						}
					}
					if (container != null) {
						containers.add(container);
						if (!(".".equals(path))) { //$NON-NLS-1$
							entryNames.add(path);
						}
					}
				}
			}
		} catch (BundleException e) {
			abort("Unable to parse bundle classpath", e); //$NON-NLS-1$
		} catch (IOException e) {
			abort("Unable to initialize class file containers", e); //$NON-NLS-1$
		}
		return containers;
	}
	
	/**
	 * Returns whether this API component is enabled for API analysis by the API builder.
	 * 
	 * @return whether this API component is enabled for API analysis by the API builder.
	 */
	protected boolean isApiEnabled() {
		return false;
	}
	
	/**
	 * Returns classpath entries defined in the given manifest.
	 * 
	 * @param manifest
	 * @return classpath entries as bundle relative paths
	 * @throws BundleException
	 */
	protected String[] getClasspathEntries(Dictionary manifest) throws BundleException {
		ManifestElement[] classpath = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, (String) manifest.get(Constants.BUNDLE_CLASSPATH));
		String elements[] = null;
		if (classpath == null) {
			// default classpath is '.'
			elements = new String[]{"."}; //$NON-NLS-1$
		} else {
			elements = new String[classpath.length];
			for (int i = 0; i < classpath.length; i++) {
				elements[i] = classpath[i].getValue();
			}
		}
		return elements;
	}
	
	/**
	 * Creates and returns an {@link IApiTypeContainer} at the specified path in
	 * this bundle, or <code>null</code> if the {@link IApiTypeContainer} does not
	 * exist. The path is the name (path) of entries specified by the
	 * <code>Bundle-ClassPath:</code> header.
	 * 
	 * @param path relative path to a class file container in this bundle
	 * @return {@link IApiTypeContainer} or <code>null</code>
	 * @exception IOException
	 */
	protected IApiTypeContainer createApiTypeContainer(String path) throws IOException, CoreException {
		File bundle = new File(fLocation);
		if (bundle.isDirectory()) {
			// bundle is folder
			File entry = new File(bundle, path);
			if (entry.exists()) {
				if (entry.isFile()) {
					return new ArchiveApiTypeContainer(this, entry.getCanonicalPath());
				} else {
					return new DirectoryApiTypeContainer(this, entry.getCanonicalPath());
				}
			}
		} else {
			// bundle is jar'd
			ZipFile zip = null;
			try {
				if (path.equals(".")) { //$NON-NLS-1$
					return new ArchiveApiTypeContainer(this, fLocation);
				} else {
					//classpath element can be jar or folder
					//https://bugs.eclipse.org/bugs/show_bug.cgi?id=279729
					zip = new ZipFile(fLocation);
					ZipEntry entry = zip.getEntry(path);
					if (entry != null) {
						File tmpfolder = new File(System.getProperty("java.io.tmpdir")); //$NON-NLS-1$
						if(entry.isDirectory()) {
							//extract the dir and all children
							File dir = File.createTempFile(TMP_API_FILE_PREFIX, TMP_API_FILE_POSTFIX);
							dir.deleteOnExit();
							//hack to create a temp directory
							// see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4735419
							if(dir.delete()) {
								dir.mkdir();
								FileManager.getManager().recordTempFileRoot(dir.getCanonicalPath());
							}
							extractDirectory(zip, entry.getName(), dir);
							if(dir.isDirectory() && dir.exists()) {
								return new DirectoryApiTypeContainer(this, dir.getCanonicalPath());
							}
						}
						else {
							File file = extractEntry(zip, entry, tmpfolder);
							if(Util.isArchive(file.getName())) {
								File parent = file.getParentFile();
								if(!parent.equals(tmpfolder)) {
									FileManager.getManager().recordTempFileRoot(parent.getCanonicalPath());
								}
								else {
									FileManager.getManager().recordTempFileRoot(file.getCanonicalPath());
								}
								return new ArchiveApiTypeContainer(this, file.getCanonicalPath());
							}
						}
					}
				}
			} finally {
				if (zip != null) {
					zip.close();
				}
			}
		}
		return null;
	}
		
	/**
	 * Extracts a directory from the archive given a path prefix for entries to retrieve.
	 * <code>null</code> can be passed in as a prefix, causing all entries to be be extracted from 
	 * the archive.
	 * 
	 * @param zip the {@link ZipFile} to extract from
	 * @param pathprefix the prefix'ing path to include for extraction
	 * @param parent the parent directory to extract to
	 * @throws IOException if the {@link ZipFile} cannot be read or extraction fails to write the file(s)
	 */
	void extractDirectory(ZipFile zip, String pathprefix, File parent) throws IOException {
		Enumeration entries = zip.entries();
		String prefix = (pathprefix == null ? Util.EMPTY_STRING : pathprefix);
		ZipEntry entry = null;
		File file = null;
		while (entries.hasMoreElements()) {
			entry = (ZipEntry) entries.nextElement();
			if(entry.getName().startsWith(prefix)) {
				file = new File(parent, entry.getName());
				if (entry.isDirectory()) {
					file.mkdir();
					continue;
				}
				extractEntry(zip, entry, parent);
			}
		}
	}
	
	/**
	 * Extracts a non-directory entry from a zip file and returns the File handle
	 * @param zip the zip to extract from
	 * @param entry the entry to extract
	 * @param parent the parent directory to add the extracted entry to
	 * @return the file handle to the extracted entry, <code>null</code> otherwise
	 * @throws IOException
	 */
	File extractEntry(ZipFile zip, ZipEntry entry, File parent) throws IOException {
		InputStream inputStream = null;
		File file;
		FileOutputStream outputStream = null;
		try {
			inputStream = zip.getInputStream(entry);
			file = new File(parent, entry.getName());
			File lparent = file.getParentFile();
			if(!lparent.exists()) {
				lparent.mkdirs();
			}
			outputStream = new FileOutputStream(file);
			byte[] bytes = new byte[8096];
			while (inputStream.available() > 0) {
				int read = inputStream.read(bytes);
				if (read > 0) {
					outputStream.write(bytes, 0, read);
				}
			}
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch(IOException e) {
					ApiPlugin.log(e);
				}
			}
			if (outputStream != null) {
				try {
					outputStream.close();
				} catch(IOException e) {
					ApiPlugin.log(e);
				}
			}
		}
		return file;
	}
	
	/**
	 * Parses a bunlde's manifest into a dictionary. The bundle may be in a jar
	 * or in a directory at the specified location.
	 * 
	 * @param bundleLocation root location of the bundle
	 * @return bundle manifest dictionary or <code>null</code> if none
	 * @throws IOException if unable to parse
	 */
	protected Map loadManifest(File bundleLocation) throws IOException {
		ZipFile jarFile = null;
		InputStream manifestStream = null;
		String extension = new Path(bundleLocation.getName()).getFileExtension();
		try {
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(JarFile.MANIFEST_NAME);
				if (manifestEntry != null) {
					manifestStream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, JarFile.MANIFEST_NAME);
				if (file.exists())
					manifestStream = new FileInputStream(file);
			}
			if (manifestStream == null) {
				return null;
			}
			return ManifestElement.parseBundleManifest(manifestStream, new Hashtable(10));
		} catch (BundleException e) {
			ApiPlugin.log(e);
		} finally {
			closingZipFileAndStream(manifestStream, jarFile);
		}
		return null;
	}
	
	/**
	 * Reads and returns this bunlde's manifest in a Manifest object.
	 * The bundle may be in a jar or in a directory at the specified location.
	 * 
	 * @param bundleLocation root location of the bundle
	 * @return manifest or <code>null</code> if not present
	 * @throws IOException if unable to parse
	 */
	protected Manifest readManifest(File bundleLocation) throws IOException {
		ZipFile jarFile = null;
		InputStream manifestStream = null;
		try {
			String extension = new Path(bundleLocation.getName()).getFileExtension();
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(JarFile.MANIFEST_NAME);
				if (manifestEntry != null) {
					manifestStream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, JarFile.MANIFEST_NAME);
				if (file.exists())
					manifestStream = new FileInputStream(file);
			}
			if (manifestStream == null) {
				return null;
			}
			return new Manifest(manifestStream);
		} finally {
			closingZipFileAndStream(manifestStream, jarFile);
		}
	}

	void closingZipFileAndStream(InputStream stream, ZipFile jarFile) {
		try {
			if (stream != null) {
				stream.close();
			}
		} catch (IOException e) {
			ApiPlugin.log(e);
		}
		try {
			if (jarFile != null) {
				jarFile.close();
			}
		} catch (IOException e) {
			ApiPlugin.log(e);
		}
	}
	
	/**
	 * Reads and returns the file contents corresponding to the given file name.
	 * The bundle may be in a jar or in a directory at the specified location.
	 * 
	 * @param xmlFileName the given file name
	 * @param bundleLocation the root location of the bundle
	 * @return the file contents or <code>null</code> if not present
	 */
	protected String readFileContents(String xmlFileName, File bundleLocation) {
		ZipFile jarFile = null;
		InputStream stream = null;
		try {
			String extension = new Path(bundleLocation.getName()).getFileExtension();
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(xmlFileName);
				if (manifestEntry != null) {
					stream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, xmlFileName);
				if (file.exists()) {
					stream = new FileInputStream(file);
				}
			}
			if (stream == null) {
				return null;
			}
			return new String(Util.getInputStreamAsCharArray(stream, -1, IApiCoreConstants.UTF_8));
		} catch(IOException e) {
			//TODO abort
			ApiPlugin.log(e);
		} finally {
			closingZipFileAndStream(stream, jarFile);
		}
		return null;
	}

	/**
	 * Parses a bundle's .api_description XML into a string. The file may be in a jar
	 * or in a directory at the specified location.
	 * 
	 * @param bundleLocation root location of the bundle
	 * @return API description XML as a string or <code>null</code> if none
	 * @throws IOException if unable to parse
	 */
	protected String loadApiDescription(File bundleLocation) throws IOException {
		ZipFile jarFile = null;
		InputStream stream = null;
		String contents = null;
		try {
			String extension = new Path(bundleLocation.getName()).getFileExtension();
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(IApiCoreConstants.API_DESCRIPTION_XML_NAME);
				if (manifestEntry != null) {
					// new file is present
					stream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, IApiCoreConstants.API_DESCRIPTION_XML_NAME);
				if (file.exists()) {
					// use new file
					stream = new FileInputStream(file);
				}
			}
			if (stream == null) {
				return null;
			}
			char[] charArray = Util.getInputStreamAsCharArray(stream, -1, IApiCoreConstants.UTF_8);
			contents = new String(charArray);
		} finally {
			closingZipFileAndStream(stream, jarFile);
		}
		return contents;
	}
	
	
	/**
	 * Returns a URL describing a file inside a bundle.
	 * 
	 * @param bundleLocation root location of the bundle. May be a
	 *  directory or a file (jar)
	 * @param filePath bundle relative path to desired file
	 * @return URL to the file
	 * @throws MalformedURLException 
	 */
	protected URL getFileInBundle(File bundleLocation, String filePath) throws MalformedURLException {
		String extension = new Path(bundleLocation.getName()).getFileExtension();
		StringBuffer urlSt = new StringBuffer();
		if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
			urlSt.append("jar:file:"); //$NON-NLS-1$
			urlSt.append(bundleLocation.getAbsolutePath());
			urlSt.append("!/"); //$NON-NLS-1$
			urlSt.append(filePath);
		} else {
			urlSt.append("file:"); //$NON-NLS-1$
			urlSt.append(bundleLocation.getAbsolutePath());
			urlSt.append(File.separatorChar);
			urlSt.append(filePath);
		}	
		return new URL(urlSt.toString());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.manifest.IApiComponent#getExecutionEnvironments()
	 */
	public synchronized String[] getExecutionEnvironments() throws CoreException {
		if (this.fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		return fBundleDescription.getExecutionEnvironments();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.manifest.IApiComponent#getId()
	 */
	public final String getId() {
		return fSymbolicName;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.manifest.IApiComponent#getRequiredComponents()
	 */
	public synchronized IRequiredComponentDescription[] getRequiredComponents() throws CoreException {
		if (this.fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		BundleSpecification[] requiredBundles = fBundleDescription.getRequiredBundles();
		IRequiredComponentDescription[] req = new IRequiredComponentDescription[requiredBundles.length];
		for (int i = 0; i < requiredBundles.length; i++) {
			BundleSpecification bundle = requiredBundles[i];
			req[i] = new RequiredComponentDescription(bundle.getName(),
					new BundleVersionRange(bundle.getVersionRange()),
					bundle.isOptional(),
					bundle.isExported());
		}
		return req;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.manifest.IApiComponent#getVersion()
	 */
	public synchronized String getVersion() {
		return fVersion.toString();
	}
	
	/**
	 * Returns this component's bundle description.
	 * 
	 * @return bundle description
	 */
	public synchronized BundleDescription getBundleDescription() throws CoreException {
		if (this.fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		return fBundleDescription;
	}

	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		if (fBundleDescription != null) {
			try {
				StringBuffer buffer = new StringBuffer();
				buffer.append(fBundleDescription.toString());
				buffer.append(" - "); //$NON-NLS-1$
				buffer.append("[fragment: ").append(isFragment()).append("] "); //$NON-NLS-1$ //$NON-NLS-2$
				buffer.append("[host: ").append(fBundleDescription.getFragments().length > 0).append("] "); //$NON-NLS-1$ //$NON-NLS-2$
				buffer.append("[system bundle: ").append(isSystemComponent()).append("] "); //$NON-NLS-1$ //$NON-NLS-2$
				buffer.append("[source bundle: ").append(isSourceComponent()).append("] "); //$NON-NLS-1$ //$NON-NLS-2$
				return buffer.toString();
			}
			catch(CoreException ce) {} 
		}
		return super.toString();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IApiComponent#getLocation()
	 */
	public String getLocation() {
		return fLocation;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IApiComponent#isSystemComponent()
	 */
	public boolean isSystemComponent() {
		return false;
	}
	
	/**
	 * Returns a boolean option from the map or the default value if not present.
	 * 
	 * @param options option map
	 * @param optionName option name
	 * @param defaultValue default value for option if not present
	 * @return boolean value
	 */
	protected boolean getBooleanOption(Map options, String optionName, boolean defaultValue) {
		Boolean optionB = (Boolean)options.get(optionName);
		if (optionB != null) {
			return optionB.booleanValue();
		}
		return defaultValue;
	}
	
	/* (non-Javadoc)
	 * @see IApiComponent#isSourceComponent()
	 */
	public synchronized boolean isSourceComponent() throws CoreException {
		if (this.fManifest == null) {
			baselineDisposed(getBaseline());
		}
		ManifestElement[] sourceBundle = null;
		try {
			sourceBundle = ManifestElement.parseHeader(IApiCoreConstants.ECLIPSE_SOURCE_BUNDLE, (String) fManifest.get(IApiCoreConstants.ECLIPSE_SOURCE_BUNDLE));
		} catch (BundleException e) {
			// ignore
		}
		if (sourceBundle != null) {
			// this is a source bundle with the new format
			return true;
		}
		// check for the old format
		String pluginXMLContents = readFileContents(IApiCoreConstants.PLUGIN_XML_NAME,new File(getLocation()));
		if (pluginXMLContents != null) {
			if (containsSourceExtensionPoint(pluginXMLContents)) {
				return true;
			}
		}
		// check if it contains a fragment.xml with the appropriate extension point
		pluginXMLContents = readFileContents(IApiCoreConstants.FRAGMENT_XML_NAME,new File(getLocation()));
		if (pluginXMLContents != null) {
			if (containsSourceExtensionPoint(pluginXMLContents)) {
				return true;
			}
		}
		// parse XML contents to find extension points
		return false;
	}

	/**
	 * Check if the given source contains an source extension point.
	 * 
	 * @param pluginXMLContents the given file contents
	 * @return true if it contains a source extension point, false otherwise
	 */
	private boolean containsSourceExtensionPoint(String pluginXMLContents) {
		SAXParserFactory factory = null;
		try {
			factory = SAXParserFactory.newInstance();
		} catch (FactoryConfigurationError e) {
			return false;
		}
		SAXParser saxParser = null;
		try {
			saxParser = factory.newSAXParser();
		} catch (ParserConfigurationException e) {
			// ignore
		} catch (SAXException e) {
			// ignore
		}

		if (saxParser == null) {
			return false;
		}

		// Parse
		InputSource inputSource = new InputSource(new BufferedReader(new StringReader(pluginXMLContents)));
		try {
			SourceDefaultHandler defaultHandler = new SourceDefaultHandler();
			saxParser.parse(inputSource, defaultHandler);
			return defaultHandler.isSource();
		} catch (SAXException e) {
			// ignore
		} catch (IOException e) {
			// ignore
		}
		return false;
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.IApiComponent#isFragment()
	 */
	public synchronized boolean isFragment() throws CoreException {
		if (this.fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		return fBundleDescription.getHost() != null;
	}

	/**
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getHost()
	 */
	public synchronized IApiComponent getHost() throws CoreException {
		if (this.fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		HostSpecification host = fBundleDescription.getHost();
		if(host != null) {
			return getBaseline().getApiComponent(host.getName());
		}
		return null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.IApiComponent#hasFragments()
	 */
	public synchronized boolean hasFragments() throws CoreException {
		if (this.fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		return fBundleDescription.getFragments().length != 0;
	}
	
	/**
	 * Sets whether this bundle has an underlying API description file.
	 * 
	 * @param hasApiDescription whether this bundle has an underlying API description file
	 */
	protected void setHasApiDescription(boolean hasApiDescription) {
		fHasApiDescription = hasApiDescription;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.IApiComponent#hasApiDescription()
	 */
	public boolean hasApiDescription() {
		// ensure initialized
		try {
			getApiDescription();
		} catch (CoreException e) {
		}
		return fHasApiDescription;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getLowestEEs()
	 */
	public String[] getLowestEEs() throws CoreException {
		if (this.lowestEEs != null) return this.lowestEEs;
		String[] temp = null;
		String[] executionEnvironments = this.getExecutionEnvironments();
		int length = executionEnvironments.length;
		switch(length) {
			case 0 :
				return null;
			case 1 :
				temp = new String[] { executionEnvironments[0] };
				break;
			default :
				int values = ProfileModifiers.NO_PROFILE_VALUE;
				for (int i = 0; i < length; i++) {
					values |= ProfileModifiers.getValue(executionEnvironments[i]);
				}
				if (ProfileModifiers.isJRE(values)) {
					if (ProfileModifiers.isJRE_1_1(values)) {
						temp = new String[] { ProfileModifiers.JRE_1_1_NAME };
					} else if (ProfileModifiers.isJ2SE_1_2(values)) {
						temp = new String[] { ProfileModifiers.J2SE_1_2_NAME };
					} else if (ProfileModifiers.isJ2SE_1_3(values)) {
						temp = new String[] { ProfileModifiers.J2SE_1_3_NAME };
					} else if (ProfileModifiers.isJ2SE_1_4(values)) {
						temp = new String[] { ProfileModifiers.J2SE_1_4_NAME };
					} else if (ProfileModifiers.isJ2SE_1_5(values)) {
						temp = new String[] { ProfileModifiers.J2SE_1_5_NAME };
					} else {
						// this is 1.6
						temp = new String[] { ProfileModifiers.JAVASE_1_6_NAME };
					}
				}
				if (ProfileModifiers.isCDC_Foundation(values)) {
					if (ProfileModifiers.isCDC_1_0_FOUNDATION_1_0(values)) {
						if (temp != null) {
							temp = new String[] { temp[0], ProfileModifiers.CDC_1_0_FOUNDATION_1_0_NAME };
						} else {
							temp = new String[] { ProfileModifiers.CDC_1_0_FOUNDATION_1_0_NAME };
						}
					} else {
						if (temp != null) {
							temp = new String[] { temp[0], ProfileModifiers.CDC_1_1_FOUNDATION_1_1_NAME };
						} else {
							temp = new String[] { ProfileModifiers.CDC_1_1_FOUNDATION_1_1_NAME };
						}
					}
				}
				if (ProfileModifiers.isOSGi(values)) {
					if (ProfileModifiers.isOSGI_MINIMUM_1_0(values)) {
						if (temp != null) {
							int tempLength = temp.length;
							System.arraycopy(temp, 0, (temp = new String[tempLength + 1]), 0, tempLength);
							temp[tempLength] = ProfileModifiers.OSGI_MINIMUM_1_0_NAME;
						} else {
							temp = new String[] { ProfileModifiers.OSGI_MINIMUM_1_0_NAME };
						}
					} else if (ProfileModifiers.isOSGI_MINIMUM_1_1(values)) {
						if (temp != null) {
							int tempLength = temp.length;
							System.arraycopy(temp, 0, (temp = new String[tempLength + 1]), 0, tempLength);
							temp[tempLength] = ProfileModifiers.OSGI_MINIMUM_1_1_NAME;
						} else {
							temp = new String[] { ProfileModifiers.OSGI_MINIMUM_1_1_NAME };
						}
					} else {
						// OSGI_MINIMUM_1_2
						if (temp != null) {
							int tempLength = temp.length;
							System.arraycopy(temp, 0, (temp = new String[tempLength + 1]), 0, tempLength);
							temp[tempLength] = ProfileModifiers.OSGI_MINIMUM_1_2_NAME;
						} else {
							temp = new String[] { ProfileModifiers.OSGI_MINIMUM_1_2_NAME };
						}
					}
				}
		}
		this.lowestEEs = temp;
		return temp;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getErrors()
	 */
	public synchronized ResolverError[] getErrors() throws CoreException {
		ApiBaseline baseline = (ApiBaseline) getBaseline();
		if (this.fBundleDescription == null) {
			baselineDisposed(baseline);
		}
		if (baseline != null) {
			ResolverError[] resolverErrors = baseline.getState().getResolverErrors(this.fBundleDescription);
			if (resolverErrors.length == 0) {
				return null;
			}
			return resolverErrors;
		}
		return null;
	}
	
	/**
	 * @param baseline the baseline that is disposed
	 * @throws CoreException with the baseline disposed information
	 */
	protected void baselineDisposed(IApiBaseline baseline) throws CoreException {
		throw new CoreException(
				new Status(
						IStatus.ERROR,
						ApiPlugin.PLUGIN_ID,
						ApiPlugin.REPORT_BASELINE_IS_DISPOSED,
						NLS.bind(Messages.BundleApiComponent_baseline_disposed, baseline.getName()),
						null));
	}
}




/*******************************************************************************
 * Copyright (c) 2007, 2009 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.pde.api.tools.internal.model;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.BundleSpecification;
import org.eclipse.osgi.service.resolver.ExportPackageDescription;
import org.eclipse.osgi.service.resolver.HostSpecification;
import org.eclipse.osgi.service.resolver.ResolverError;
import org.eclipse.osgi.service.resolver.State;
import org.eclipse.osgi.service.resolver.StateObjectFactory;
import org.eclipse.osgi.util.ManifestElement;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.api.tools.internal.ApiBaselineManager;
import org.eclipse.pde.api.tools.internal.ApiDescription;
import org.eclipse.pde.api.tools.internal.ApiDescriptionProcessor;
import org.eclipse.pde.api.tools.internal.BundleVersionRange;
import org.eclipse.pde.api.tools.internal.CompositeApiDescription;
import org.eclipse.pde.api.tools.internal.IApiCoreConstants;
import org.eclipse.pde.api.tools.internal.RequiredComponentDescription;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.Factory;
import org.eclipse.pde.api.tools.internal.provisional.IApiAccess;
import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;
import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;
import org.eclipse.pde.api.tools.internal.provisional.IRequiredComponentDescription;
import org.eclipse.pde.api.tools.internal.provisional.ProfileModifiers;
import org.eclipse.pde.api.tools.internal.provisional.VisibilityModifiers;
import org.eclipse.pde.api.tools.internal.provisional.descriptors.IPackageDescriptor;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiElement;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
import org.eclipse.pde.api.tools.internal.util.FileManager;
import org.eclipse.pde.api.tools.internal.util.SourceDefaultHandler;
import org.eclipse.pde.api.tools.internal.util.Util;
import org.eclipse.pde.internal.core.TargetWeaver;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.framework.Version;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Implementation of an API component based on a bundle in the file system.
 * 
 * @since 1.0.0
 */
public class BundleComponent extends Component {
	
	static final String TMP_API_FILE_PREFIX = "api"; //$NON-NLS-1$
	static final String TMP_API_FILE_POSTFIX = "tmp"; //$NON-NLS-1$
	
	/**
	 * Dictionary parsed from MANIFEST.MF
	 */
	private Dictionary fManifest;
	
	/**
	 * Manifest headers that are maintained after {@link BundleDescription} creation.
	 * Only these headers are maintained in the manifest dictionary to reduce footprint.  
	 */
	private static final String[] MANIFEST_HEADERS = new String[] {
		IApiCoreConstants.ECLIPSE_SOURCE_BUNDLE,
		Constants.BUNDLE_CLASSPATH,
		Constants.BUNDLE_NAME,
		Constants.BUNDLE_VERSION
	};
	
	/**
	 * Whether there is an underlying .api_description file
	 */
	private boolean fHasApiDescription = false;
	
	/**
	 * Root location of component in the file system
	 */
	private String fLocation;
	
	/**
	 * Underlying bundle description (OSGi model of a bundle)
	 */
	private BundleDescription fBundleDescription;
	
	/**
	 * Symbolic name of this bundle
	 */
	private String fSymbolicName = null;
	
	/**
	 * Bundle version
	 */
	private Version fVersion = null;
	
	/**
	 * Cached value for the lowest EEs
	 */
	private String[] lowestEEs;
	
	/**
	 * Flag to know if this component is a binary bundle in the workspace
	 * i.e. an imported binary bundle
	 */
	private boolean fWorkspaceBinary = false;
	
	/**
	 * The id of this component
	 */
	private long fBundleId = 0L;

	/**
	 * Constructs a new API component from the specified location in the file system
	 * in the given profile.
	 * 
	 * @param baseline owning API baseline
	 * @param location directory or jar file
	 * @param bundleid
	 * @exception CoreException if unable to create a component from the specified location
	 */
	public BundleComponent(IApiBaseline baseline, String location, long bundleid) throws CoreException {
		super(baseline);
		fLocation = location;
		fBundleId = bundleid;
		fWorkspaceBinary = isBinary() && ApiBaselineManager.WORKSPACE_API_BASELINE_ID.equals(baseline.getName());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.descriptors.AbstractApiComponent#dispose()
	 */
	public void dispose() {
		try {
			super.dispose();
		} finally {
			synchronized(this) {
				fManifest = null;
				fBundleDescription = null;
			}
		}
	}
	
	/**
	 * Returns this bundle's manifest as a dictionary.
	 * 
	 * @return manifest dictionary
	 * @exception CoreException if something goes terribly wrong
	 */
	protected synchronized Dictionary getManifest() throws CoreException {
		if(fManifest == null) {
			try {
				fManifest = (Dictionary) loadManifest(new File(fLocation));
			} catch (IOException e) {
				abort("Unable to load manifest due to IO error", e); //$NON-NLS-1$
			}
		}
		return fManifest;
	}

	/**
	 * Reduce the manifest to only contain required headers after {@link BundleDescription} creation.
	 */
	protected synchronized void doManifestCompaction() {
		Dictionary temp = fManifest;
		fManifest = new Hashtable(MANIFEST_HEADERS.length, 1);
		for (int i = 0; i < MANIFEST_HEADERS.length; i++) {
			String header = MANIFEST_HEADERS[i];
			Object value = temp.get(header);
			if (value != null) {
				fManifest.put(header, value);
			}
		}
	}
	
	/**
	 * Returns if the bundle at the specified location is a valid bundle or not.
	 * Validity is determined via the existence of a readable manifest file
	 * @param location
	 * @return true if the bundle at the given location is valid false otherwise
	 * @throws IOException
	 */
	public boolean isValidBundle() throws CoreException {
		Dictionary manifest = getManifest();
		return manifest != null && (manifest.get(Constants.BUNDLE_NAME) != null && manifest.get(Constants.BUNDLE_VERSION) != null);
	}
	
	/* (non-Javadoc)
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object obj) {
		if(obj instanceof BundleComponent) {
			BundleComponent comp = (BundleComponent) obj;
			return getName().equals(comp.getName()) && 
					getSymbolicName().equals(comp.getSymbolicName()) &&
					getVersion().equals(comp.getVersion());
		}
		return false;
	}
	
	/**
	 * Initializes the component
	 * @throws CoreException on failure
	 */
	protected synchronized void init() {
		if(fBundleDescription != null) {
			return;
		}
		try {
			Dictionary manifest = getManifest();
			if (isWorkspaceBinary()) {
				// must account for bundles in development mode - look for class files in output
				// folders rather than jars
				TargetWeaver.weaveManifest(manifest);
			}
			fBundleDescription = getBundleDescription(manifest, fLocation, fBundleId);
			if(fBundleDescription == null) {
				ApiPlugin.log(new Status(
						IStatus.ERROR, 
						ApiPlugin.PLUGIN_ID, 
						"Unable to resolve the BundleDescription for the component from: " + fLocation,  //$NON-NLS-1$
						null));
			}
			fSymbolicName = fBundleDescription.getSymbolicName();
			fVersion = fBundleDescription.getVersion();
			setName((String)manifest.get(Constants.BUNDLE_NAME));
		} catch (BundleException e) {
			ApiPlugin.log(new Status(
					IStatus.ERROR, 
					ApiPlugin.PLUGIN_ID, 
					"Unable to create API component from specified location: " + fLocation,  //$NON-NLS-1$
					e));
		}
		catch (CoreException ce) {
			ApiPlugin.log(ce);
		}
		// compact manifest after initialization - only keep used headers
		doManifestCompaction();
	}
	
	/**
	 * Returns if this component is a a binary bundle in the workspace
	 * i.e. an imported binary bundle
	 * @return true if the component is a binary bundle in the workspace, false otherwise
	 */
	public boolean isWorkspaceBinary() {
		return fWorkspaceBinary;
	}
	
	/**
	 * Returns the {@link State} from the backing baseline
	 * @return the state from the backing {@link ApiBaseline}
	 */
	protected State getState() {
		return ((ApiBaseline)getBaseline()).getState();
	}
	
	/**
	 * Returns the {@link BundleDescription} for the given manifest + state or throws an exception, never
	 * returns <code>null</code>
	 * @param manifest
	 * @param location
	 * @param id
	 * @return the {@link BundleDescription} or throws an exception
	 * @throws BundleException
	 */
	protected BundleDescription getBundleDescription(Dictionary manifest, String location, long id) throws BundleException {
		State state = getState();
		BundleDescription bundle = lookupBundle(state, manifest);
		if(bundle != null) {
			return bundle;
		}
		StateObjectFactory factory = StateObjectFactory.defaultFactory;
		bundle = factory.createBundleDescription(state, manifest, fLocation, id);
		state.addBundle(bundle);
		return bundle;
	}
	
	/**
	 * Tries to look up the bundle described by the given manifest in the given state
	 * @param manifest
	 * @return the bundle for the given manifest, <code>null</code> otherwise
	 */
	protected BundleDescription lookupBundle(State state, Dictionary manifest) {
		Version version = null;
		try {
			//just in case the version is not a number
			String ver = (String)manifest.get(Constants.BUNDLE_VERSION);
			version = ver != null ? new Version(ver) : null;
		}
		catch (NumberFormatException nfe) {
			version = null;
		}
		return state.getBundle((String)manifest.get(Constants.BUNDLE_SYMBOLICNAME),	version);
	}
	
	/**
	 * Returns whether this API component represents a binary bundle versus a project bundle.
	 * 
	 * @return whether this API component represents a binary bundle
	 */
	protected boolean isBinary() {
		return true;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.AbstractApiComponent#createApiDescription()
	 */
	protected IApiDescription createApiDescription() throws CoreException {
		BundleDescription[] fragments = getBundleDescription().getFragments();
		if (fragments.length == 0) {
			return createLocalApiDescription();
		}
		// build a composite description
		IApiDescription[] descriptions = new IApiDescription[fragments.length + 1];
		for (int i = 0; i < fragments.length; i++) {
			BundleDescription fragment = fragments[i];
			BundleComponent component = (BundleComponent) getBaseline().getApiComponent(fragment.getSymbolicName());
			descriptions[i + 1] = component.getApiDescription();
		}
		descriptions[0] = createLocalApiDescription();
		return new CompositeApiDescription(descriptions);
	}

	/**
	 * Creates and returns this component's API description based on packages
	 * supplied by this component, exported packages, and associated directives.
	 * 
	 * @return API description
	 * @throws CoreException if unable to initialize 
	 */
	protected IApiDescription createLocalApiDescription() throws CoreException {
		IApiDescription apiDesc = new ApiDescription(getSymbolicName());
		// first mark all packages as internal
		initializeApiDescription(apiDesc, getBundleDescription(), getLocalPackageNames());
		try {
			String xml = loadApiDescription(new File(fLocation));
			setHasApiDescription(xml != null);
			if (xml != null) {
				ApiDescriptionProcessor.annotateApiSettings(null, apiDesc, xml);
			}
		} catch (IOException e) {
			abort("Unable to load .api_description file ", e); //$NON-NLS-1$
		}
		return apiDesc;
	}
	
	/**
	 * Returns the names of all packages that originate from this bundle.
	 * Does not include packages that originate from fragments or a host.
	 * 
	 * @return local package names
	 * @throws CoreException
	 */
	protected Set getLocalPackageNames() throws CoreException {
		Set names = new HashSet();
		IApiTypeContainer[] containers = getApiTypeContainers();
		IApiComponent comp = null;
		for (int i = 0; i < containers.length; i++) {
			comp = (IApiComponent) containers[i].getAncestor(IApiElement.COMPONENT);
			if (comp != null && comp.getSymbolicName().equals(getSymbolicName())) {
				String[] packageNames = containers[i].getPackageNames();
				for (int j = 0; j < packageNames.length; j++) {
					names.add(packageNames[j]);
				}
			}
		}
		return names;
	}	
	

	/**
	 * Initializes the given API description based on package exports in the manifest.
	 * The API description for a bundle only contains packages that originate from
	 * this bundle (so a host will not contain API descriptions for packages that
	 * originate from fragments). However, a host's API description will be represented
	 * by a proxy that delegates to the host and all of its fragments to provide
	 * a complete description of the host.
	 * 
	 * @param apiDesc API description to initialize
	 * @param bundle the bundle to load from
	 * @param packages the complete set of packages names originating from the backing
	 * 		component
	 * @throws CoreException if an error occurs
	 */
	public static void initializeApiDescription(IApiDescription apiDesc, BundleDescription bundle, Set packages) throws CoreException {
		Iterator iterator = packages.iterator();
		while (iterator.hasNext()) {
			String name = (String) iterator.next();
			apiDesc.setVisibility(Factory.packageDescriptor(name), VisibilityModifiers.PRIVATE);
		}
		// then process exported packages that originate from this bundle
		// considering host and fragment package exports
		List supplied = new ArrayList();
		ExportPackageDescription[] exportPackages = bundle.getExportPackages();
		addSuppliedPackages(packages, supplied, exportPackages);
		HostSpecification host = bundle.getHost();
		if (host != null) {
			BundleDescription[] hosts = host.getHosts();
			for (int i = 0; i < hosts.length; i++) {
				addSuppliedPackages(packages, supplied, hosts[i].getExportPackages());
			}
		}
		BundleDescription[] fragments = bundle.getFragments();
		for (int i = 0; i < fragments.length; i++) {
			addSuppliedPackages(packages, supplied, fragments[i].getExportPackages());
		}
		
		annotateExportedPackages(apiDesc, (ExportPackageDescription[]) supplied.toArray(new ExportPackageDescription[supplied.size()]));
	}

	/**
	 * Adds package exports to the given list if the associated package originates
	 * from this bundle.
	 *   
	 * @param packages names of packages supplied by this bundle
	 * @param supplied list to append package exports to
	 * @param exportPackages package exports to consider
	 */
	protected static void addSuppliedPackages(Set packages, List supplied, ExportPackageDescription[] exportPackages) {
		for (int i = 0; i < exportPackages.length; i++) {
			ExportPackageDescription pkg = exportPackages[i];
			String name = pkg.getName();
			if (name.equals(".")) { //$NON-NLS-1$
				// translate . to default package
				name = Util.DEFAULT_PACKAGE_NAME;
			}
			if (packages.contains(name)) {
				supplied.add(pkg);
			}
		}
	}
	
	/**
	 * Annotates the API description with exported packages.
	 * 
	 * @param apiDesc description to annotate
	 * @param exportedPackages packages that are exported
	 */
	protected static void annotateExportedPackages(IApiDescription apiDesc, ExportPackageDescription[] exportedPackages) {
		for(int i = 0; i < exportedPackages.length; i++) {
			ExportPackageDescription pkg = exportedPackages[i];
			boolean internal = ((Boolean) pkg.getDirective("x-internal")).booleanValue(); //$NON-NLS-1$
			String[] friends = (String[]) pkg.getDirective("x-friends"); //$NON-NLS-1$
			String pkgName = pkg.getName();
			if (pkgName.equals(".")) { //$NON-NLS-1$
				// default package
				pkgName = ""; //$NON-NLS-1$
			}
			IPackageDescriptor pkgDesc = Factory.packageDescriptor(pkgName);
			if(internal) {
				apiDesc.setVisibility(pkgDesc, VisibilityModifiers.PRIVATE);
			}
			if (friends != null) {
				apiDesc.setVisibility(pkgDesc, VisibilityModifiers.PRIVATE);
				for(int j = 0; j < friends.length; j++) {
					//annotate the api description for x-friends access levels
					apiDesc.setAccessLevel(
							Factory.componentDescriptor(friends[j]), 
							Factory.packageDescriptor(pkgName), 
							IApiAccess.FRIEND);
				}
			}
			if (!internal && friends == null) {
				//there could have been directives that have nothing to do with
				//visibility, so we need to add the package as API in that case
				apiDesc.setVisibility(pkgDesc, VisibilityModifiers.API);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.AbstractApiComponent#createApiFilterStore()
	 */
	protected IApiFilterStore createApiFilterStore() throws CoreException {
		//always return a new empty store since we do not support filtering from bundles
		return null;
	}
	
	/**
	 * @see org.eclipse.pde.api.tools.internal.AbstractApiTypeContainer#createApiTypeContainers()
	 */
	protected synchronized List createApiTypeContainers() throws CoreException {
		if (fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		List containers = new ArrayList(5);
		try {
			List all = new ArrayList();
			// build the classpath from bundle and all fragments
			all.add(this);
			boolean considerFragments = true;
			if (Util.ORG_ECLIPSE_SWT.equals(getSymbolicName())) {
				// if SWT is a project to be built/analyzed don't consider its fragments
				considerFragments = !isApiEnabled();
			}
			if (considerFragments) { 
				BundleDescription[] fragments = fBundleDescription.getFragments();
				for (int i = 0; i < fragments.length; i++) {
					BundleDescription fragment = fragments[i];
					BundleComponent component = (BundleComponent) getBaseline().getApiComponent(fragment.getSymbolicName());
					if (component != null) {
						// force initialization of the fragment so we can retrieve its class file containers
						component.getApiTypeContainers();
						all.add(component);
					}
				}
			}
			Iterator iterator = all.iterator();
			Set entryNames = new HashSet(5);
			BundleComponent other = null;
			while (iterator.hasNext()) {
				BundleComponent component = (BundleComponent) iterator.next();
				String[] paths = getClasspathEntries(component.getManifest());
				for (int i = 0; i < paths.length; i++) {
					String path = paths[i];
					// don't re-process the same entry twice (except default entries ".")
					if (!(".".equals(path))) { //$NON-NLS-1$
						if (entryNames.contains(path)) {
							continue;
						}
					}
					IApiTypeContainer container = component.createApiTypeContainer(path);
					if (container == null) {
						for(Iterator iter = all.iterator(); iter.hasNext();) {
							other = (BundleComponent) iter.next();
							if (other != component) {
								container = other.createApiTypeContainer(path);
							}
						}
					}
					if (container != null) {
						containers.add(container);
						if (!(".".equals(path))) { //$NON-NLS-1$
							entryNames.add(path);
						}
					}
				}
			}
		} catch (BundleException e) {
			abort("Unable to parse bundle classpath", e); //$NON-NLS-1$
		} catch (IOException e) {
			abort("Unable to initialize class file containers", e); //$NON-NLS-1$
		}
		return containers;
	}
	
	/**
	 * Returns whether this API component is enabled for API analysis by the API builder.
	 * 
	 * @return whether this API component is enabled for API analysis by the API builder.
	 */
	protected boolean isApiEnabled() {
		return false;
	}
	
	/**
	 * Returns classpath entries defined in the given manifest.
	 * 
	 * @param manifest
	 * @return classpath entries as bundle relative paths
	 * @throws BundleException
	 */
	protected String[] getClasspathEntries(Dictionary manifest) throws BundleException {
		ManifestElement[] classpath = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, (String) manifest.get(Constants.BUNDLE_CLASSPATH));
		String elements[] = null;
		if (classpath == null) {
			// default classpath is '.'
			elements = new String[]{"."}; //$NON-NLS-1$
		} else {
			elements = new String[classpath.length];
			for (int i = 0; i < classpath.length; i++) {
				elements[i] = classpath[i].getValue();
			}
		}
		return elements;
	}
	
	/**
	 * Creates and returns an {@link IApiTypeContainer} at the specified path in
	 * this bundle, or <code>null</code> if the {@link IApiTypeContainer} does not
	 * exist. The path is the name (path) of entries specified by the
	 * <code>Bundle-ClassPath:</code> header.
	 * 
	 * @param path relative path to a class file container in this bundle
	 * @return {@link IApiTypeContainer} or <code>null</code>
	 * @exception IOException
	 */
	protected IApiTypeContainer createApiTypeContainer(String path) throws IOException, CoreException {
		File bundle = new File(fLocation);
		if (bundle.isDirectory()) {
			// bundle is folder
			File entry = new File(bundle, path);
			if (entry.exists()) {
				if (entry.isFile()) {
					return new ArchiveApiTypeContainer(this, entry.getCanonicalPath());
				} else {
					return new DirectoryApiTypeContainer(this, entry.getCanonicalPath());
				}
			}
		} else {
			// bundle is jar'd
			ZipFile zip = null;
			try {
				if (path.equals(".")) { //$NON-NLS-1$
					return new ArchiveApiTypeContainer(this, fLocation);
				} else {
					//classpath element can be jar or folder
					//https://bugs.eclipse.org/bugs/show_bug.cgi?id=279729
					zip = new ZipFile(fLocation);
					ZipEntry entry = zip.getEntry(path);
					if (entry != null) {
						File tmpfolder = new File(System.getProperty("java.io.tmpdir")); //$NON-NLS-1$
						if(entry.isDirectory()) {
							//extract the dir and all children
							File dir = File.createTempFile(TMP_API_FILE_PREFIX, TMP_API_FILE_POSTFIX);
							dir.deleteOnExit();
							//hack to create a temp directory
							// see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4735419
							if(dir.delete()) {
								dir.mkdir();
								FileManager.getManager().recordTempFileRoot(dir.getCanonicalPath());
							}
							extractDirectory(zip, entry.getName(), dir);
							if(dir.isDirectory() && dir.exists()) {
								return new DirectoryApiTypeContainer(this, dir.getCanonicalPath());
							}
						}
						else {
							File file = extractEntry(zip, entry, tmpfolder);
							if(Util.isArchive(file.getName())) {
								File parent = file.getParentFile();
								if(!parent.equals(tmpfolder)) {
									FileManager.getManager().recordTempFileRoot(parent.getCanonicalPath());
								}
								else {
									FileManager.getManager().recordTempFileRoot(file.getCanonicalPath());
								}
								return new ArchiveApiTypeContainer(this, file.getCanonicalPath());
							}
						}
					}
				}
			} finally {
				if (zip != null) {
					zip.close();
				}
			}
		}
		return null;
	}
		
	/**
	 * Extracts a directory from the archive given a path prefix for entries to retrieve.
	 * <code>null</code> can be passed in as a prefix, causing all entries to be be extracted from 
	 * the archive.
	 * 
	 * @param zip the {@link ZipFile} to extract from
	 * @param pathprefix the prefix'ing path to include for extraction
	 * @param parent the parent directory to extract to
	 * @throws IOException if the {@link ZipFile} cannot be read or extraction fails to write the file(s)
	 */
	void extractDirectory(ZipFile zip, String pathprefix, File parent) throws IOException {
		Enumeration entries = zip.entries();
		String prefix = (pathprefix == null ? Util.EMPTY_STRING : pathprefix);
		ZipEntry entry = null;
		File file = null;
		while (entries.hasMoreElements()) {
			entry = (ZipEntry) entries.nextElement();
			if(entry.getName().startsWith(prefix)) {
				file = new File(parent, entry.getName());
				if (entry.isDirectory()) {
					file.mkdir();
					continue;
				}
				extractEntry(zip, entry, parent);
			}
		}
	}
	
	/**
	 * Extracts a non-directory entry from a zip file and returns the File handle
	 * @param zip the zip to extract from
	 * @param entry the entry to extract
	 * @param parent the parent directory to add the extracted entry to
	 * @return the file handle to the extracted entry, <code>null</code> otherwise
	 * @throws IOException
	 */
	File extractEntry(ZipFile zip, ZipEntry entry, File parent) throws IOException {
		InputStream inputStream = null;
		File file;
		FileOutputStream outputStream = null;
		try {
			inputStream = zip.getInputStream(entry);
			file = new File(parent, entry.getName());
			File lparent = file.getParentFile();
			if(!lparent.exists()) {
				lparent.mkdirs();
			}
			outputStream = new FileOutputStream(file);
			byte[] bytes = new byte[8096];
			while (inputStream.available() > 0) {
				int read = inputStream.read(bytes);
				if (read > 0) {
					outputStream.write(bytes, 0, read);
				}
			}
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch(IOException e) {
					ApiPlugin.log(e);
				}
			}
			if (outputStream != null) {
				try {
					outputStream.close();
				} catch(IOException e) {
					ApiPlugin.log(e);
				}
			}
		}
		return file;
	}
	
	/**
	 * Parses a bunlde's manifest into a dictionary. The bundle may be in a jar
	 * or in a directory at the specified location.
	 * 
	 * @param bundleLocation root location of the bundle
	 * @return bundle manifest dictionary or <code>null</code> if none
	 * @throws IOException if unable to parse
	 */
	protected Map loadManifest(File bundleLocation) throws IOException {
		ZipFile jarFile = null;
		InputStream manifestStream = null;
		String extension = new Path(bundleLocation.getName()).getFileExtension();
		try {
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(JarFile.MANIFEST_NAME);
				if (manifestEntry != null) {
					manifestStream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, JarFile.MANIFEST_NAME);
				if (file.exists())
					manifestStream = new FileInputStream(file);
			}
			if (manifestStream == null) {
				return null;
			}
			return ManifestElement.parseBundleManifest(manifestStream, new Hashtable(10));
		} catch (BundleException e) {
			ApiPlugin.log(e);
		} finally {
			closingZipFileAndStream(manifestStream, jarFile);
		}
		return null;
	}
	
	/**
	 * Reads and returns this bunlde's manifest in a Manifest object.
	 * The bundle may be in a jar or in a directory at the specified location.
	 * 
	 * @param bundleLocation root location of the bundle
	 * @return manifest or <code>null</code> if not present
	 * @throws IOException if unable to parse
	 */
	protected Manifest readManifest(File bundleLocation) throws IOException {
		ZipFile jarFile = null;
		InputStream manifestStream = null;
		try {
			String extension = new Path(bundleLocation.getName()).getFileExtension();
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(JarFile.MANIFEST_NAME);
				if (manifestEntry != null) {
					manifestStream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, JarFile.MANIFEST_NAME);
				if (file.exists())
					manifestStream = new FileInputStream(file);
			}
			if (manifestStream == null) {
				return null;
			}
			return new Manifest(manifestStream);
		} finally {
			closingZipFileAndStream(manifestStream, jarFile);
		}
	}

	void closingZipFileAndStream(InputStream stream, ZipFile jarFile) {
		try {
			if (stream != null) {
				stream.close();
			}
		} catch (IOException e) {
			ApiPlugin.log(e);
		}
		try {
			if (jarFile != null) {
				jarFile.close();
			}
		} catch (IOException e) {
			ApiPlugin.log(e);
		}
	}
	
	/**
	 * Reads and returns the file contents corresponding to the given file name.
	 * The bundle may be in a jar or in a directory at the specified location.
	 * 
	 * @param xmlFileName the given file name
	 * @param bundleLocation the root location of the bundle
	 * @return the file contents or <code>null</code> if not present
	 */
	protected String readFileContents(String xmlFileName, File bundleLocation) {
		ZipFile jarFile = null;
		InputStream stream = null;
		try {
			String extension = new Path(bundleLocation.getName()).getFileExtension();
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(xmlFileName);
				if (manifestEntry != null) {
					stream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, xmlFileName);
				if (file.exists()) {
					stream = new FileInputStream(file);
				}
			}
			if (stream == null) {
				return null;
			}
			return new String(Util.getInputStreamAsCharArray(stream, -1, IApiCoreConstants.UTF_8));
		} catch(IOException e) {
			//TODO abort
			ApiPlugin.log(e);
		} finally {
			closingZipFileAndStream(stream, jarFile);
		}
		return null;
	}

	/**
	 * Parses a bundle's .api_description XML into a string. The file may be in a jar
	 * or in a directory at the specified location.
	 * 
	 * @param bundleLocation root location of the bundle
	 * @return API description XML as a string or <code>null</code> if none
	 * @throws IOException if unable to parse
	 */
	protected String loadApiDescription(File bundleLocation) throws IOException {
		ZipFile jarFile = null;
		InputStream stream = null;
		String contents = null;
		try {
			String extension = new Path(bundleLocation.getName()).getFileExtension();
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(IApiCoreConstants.API_DESCRIPTION_XML_NAME);
				if (manifestEntry != null) {
					// new file is present
					stream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, IApiCoreConstants.API_DESCRIPTION_XML_NAME);
				if (file.exists()) {
					// use new file
					stream = new FileInputStream(file);
				}
			}
			if (stream == null) {
				return null;
			}
			char[] charArray = Util.getInputStreamAsCharArray(stream, -1, IApiCoreConstants.UTF_8);
			contents = new String(charArray);
		} finally {
			closingZipFileAndStream(stream, jarFile);
		}
		return contents;
	}
	
	
	/**
	 * Returns a URL describing a file inside a bundle.
	 * 
	 * @param bundleLocation root location of the bundle. May be a
	 *  directory or a file (jar)
	 * @param filePath bundle relative path to desired file
	 * @return URL to the file
	 * @throws MalformedURLException 
	 */
	protected URL getFileInBundle(File bundleLocation, String filePath) throws MalformedURLException {
		String extension = new Path(bundleLocation.getName()).getFileExtension();
		StringBuffer urlSt = new StringBuffer();
		if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
			urlSt.append("jar:file:"); //$NON-NLS-1$
			urlSt.append(bundleLocation.getAbsolutePath());
			urlSt.append("!/"); //$NON-NLS-1$
			urlSt.append(filePath);
		} else {
			urlSt.append("file:"); //$NON-NLS-1$
			urlSt.append(bundleLocation.getAbsolutePath());
			urlSt.append(File.separatorChar);
			urlSt.append(filePath);
		}	
		return new URL(urlSt.toString());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.manifest.IApiComponent#getExecutionEnvironments()
	 */
	public synchronized String[] getExecutionEnvironments() throws CoreException {
		if (fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		return fBundleDescription.getExecutionEnvironments();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.manifest.IApiComponent#getSymbolicName()
	 */
	public final String getSymbolicName() {
		init();
		return fSymbolicName;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.manifest.IApiComponent#getRequiredComponents()
	 */
	public synchronized IRequiredComponentDescription[] getRequiredComponents() throws CoreException {
		if (fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		BundleSpecification[] requiredBundles = fBundleDescription.getRequiredBundles();
		IRequiredComponentDescription[] req = new IRequiredComponentDescription[requiredBundles.length];
		for (int i = 0; i < requiredBundles.length; i++) {
			BundleSpecification bundle = requiredBundles[i];
			req[i] = new RequiredComponentDescription(bundle.getName(),
					new BundleVersionRange(bundle.getVersionRange()),
					bundle.isOptional(),
					bundle.isExported());
		}
		return req;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.manifest.IApiComponent#getVersion()
	 */
	public synchronized String getVersion() {
		init();
		return fVersion.toString();
	}
	
	/**
	 * Returns this component's bundle description.
	 * 
	 * @return bundle description
	 */
	public synchronized BundleDescription getBundleDescription() throws CoreException {
		init();
		if (fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		return fBundleDescription;
	}

	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		if (fBundleDescription != null) {
			try {
				StringBuffer buffer = new StringBuffer();
				buffer.append(fBundleDescription.toString());
				buffer.append(" - "); //$NON-NLS-1$
				buffer.append("[fragment: ").append(isFragment()).append("] "); //$NON-NLS-1$ //$NON-NLS-2$
				buffer.append("[host: ").append(fBundleDescription.getFragments().length > 0).append("] "); //$NON-NLS-1$ //$NON-NLS-2$
				buffer.append("[system bundle: ").append(isSystemComponent()).append("] "); //$NON-NLS-1$ //$NON-NLS-2$
				buffer.append("[source bundle: ").append(isSourceComponent()).append("] "); //$NON-NLS-1$ //$NON-NLS-2$
				buffer.append("[dev bundle: ").append(fWorkspaceBinary).append("]"); //$NON-NLS-1$ //$NON-NLS-2$
				return buffer.toString();
			}
			catch(CoreException ce) {} 
		}
		else {
			StringBuffer buffer = new StringBuffer();
			buffer.append("Un-initialized Bundle Component"); //$NON-NLS-1$
			buffer.append("[location: ").append(fLocation).append("]"); //$NON-NLS-1$ //$NON-NLS-2$
			buffer.append("[dev bundle: ").append(fWorkspaceBinary).append("]"); //$NON-NLS-1$ //$NON-NLS-2$
			return buffer.toString();
		}
		return super.toString();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IApiComponent#getLocation()
	 */
	public String getLocation() {
		return fLocation;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IApiComponent#isSystemComponent()
	 */
	public boolean isSystemComponent() {
		return false;
	}
	
	/* (non-Javadoc)
	 * @see IApiComponent#isSourceComponent()
	 */
	public synchronized boolean isSourceComponent() throws CoreException {
		getManifest();
		if (fManifest == null) {
			baselineDisposed(getBaseline());
		}
		ManifestElement[] sourceBundle = null;
		try {
			sourceBundle = ManifestElement.parseHeader(IApiCoreConstants.ECLIPSE_SOURCE_BUNDLE, (String) fManifest.get(IApiCoreConstants.ECLIPSE_SOURCE_BUNDLE));
		} catch (BundleException e) {
			// ignore
		}
		if (sourceBundle != null) {
			// this is a source bundle with the new format
			return true;
		}
		// check for the old format
		String pluginXMLContents = readFileContents(IApiCoreConstants.PLUGIN_XML_NAME,new File(getLocation()));
		if (pluginXMLContents != null) {
			if (containsSourceExtensionPoint(pluginXMLContents)) {
				return true;
			}
		}
		// check if it contains a fragment.xml with the appropriate extension point
		pluginXMLContents = readFileContents(IApiCoreConstants.FRAGMENT_XML_NAME,new File(getLocation()));
		if (pluginXMLContents != null) {
			if (containsSourceExtensionPoint(pluginXMLContents)) {
				return true;
			}
		}
		// parse XML contents to find extension points
		return false;
	}

	/**
	 * Check if the given source contains an source extension point.
	 * 
	 * @param pluginXMLContents the given file contents
	 * @return true if it contains a source extension point, false otherwise
	 */
	private boolean containsSourceExtensionPoint(String pluginXMLContents) {
		SAXParserFactory factory = null;
		try {
			factory = SAXParserFactory.newInstance();
		} catch (FactoryConfigurationError e) {
			return false;
		}
		SAXParser saxParser = null;
		try {
			saxParser = factory.newSAXParser();
		} catch (ParserConfigurationException e) {
			// ignore
		} catch (SAXException e) {
			// ignore
		}

		if (saxParser == null) {
			return false;
		}

		// Parse
		InputSource inputSource = new InputSource(new BufferedReader(new StringReader(pluginXMLContents)));
		try {
			SourceDefaultHandler defaultHandler = new SourceDefaultHandler();
			saxParser.parse(inputSource, defaultHandler);
			return defaultHandler.isSource();
		} catch (SAXException e) {
			// ignore
		} catch (IOException e) {
			// ignore
		}
		return false;
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.IApiComponent#isFragment()
	 */
	public synchronized boolean isFragment() throws CoreException {
		init();
		if (fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		return fBundleDescription.getHost() != null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.Component#getHost()
	 */
	public synchronized IApiComponent getHost() throws CoreException {
		init();
		if (fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		HostSpecification host = fBundleDescription.getHost();
		if(host != null) {
			return getBaseline().getApiComponent(host.getName());
		}
		return null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.IApiComponent#hasFragments()
	 */
	public synchronized boolean hasFragments() throws CoreException {
		init();
		if (fBundleDescription == null) {
			baselineDisposed(getBaseline());
		}
		return fBundleDescription.getFragments().length != 0;
	}
	
	/**
	 * Sets whether this bundle has an underlying API description file.
	 * 
	 * @param hasApiDescription whether this bundle has an underlying API description file
	 */
	protected void setHasApiDescription(boolean hasApiDescription) {
		fHasApiDescription = hasApiDescription;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.IApiComponent#hasApiDescription()
	 */
	public boolean hasApiDescription() {
		// ensure initialized
		try {
			getApiDescription();
		} catch (CoreException e) {
		}
		return fHasApiDescription;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getLowestEEs()
	 */
	public String[] getLowestEEs() throws CoreException {
		if (lowestEEs != null) return lowestEEs;
		String[] temp = null;
		String[] executionEnvironments = getExecutionEnvironments();
		int length = executionEnvironments.length;
		switch(length) {
			case 0 :
				return null;
			case 1 :
				temp = new String[] { executionEnvironments[0] };
				break;
			default :
				int values = ProfileModifiers.NO_PROFILE_VALUE;
				for (int i = 0; i < length; i++) {
					values |= ProfileModifiers.getValue(executionEnvironments[i]);
				}
				if (ProfileModifiers.isJRE(values)) {
					if (ProfileModifiers.isJRE_1_1(values)) {
						temp = new String[] { ProfileModifiers.JRE_1_1_NAME };
					} else if (ProfileModifiers.isJ2SE_1_2(values)) {
						temp = new String[] { ProfileModifiers.J2SE_1_2_NAME };
					} else if (ProfileModifiers.isJ2SE_1_3(values)) {
						temp = new String[] { ProfileModifiers.J2SE_1_3_NAME };
					} else if (ProfileModifiers.isJ2SE_1_4(values)) {
						temp = new String[] { ProfileModifiers.J2SE_1_4_NAME };
					} else if (ProfileModifiers.isJ2SE_1_5(values)) {
						temp = new String[] { ProfileModifiers.J2SE_1_5_NAME };
					} else {
						// this is 1.6
						temp = new String[] { ProfileModifiers.JAVASE_1_6_NAME };
					}
				}
				if (ProfileModifiers.isCDC_Foundation(values)) {
					if (ProfileModifiers.isCDC_1_0_FOUNDATION_1_0(values)) {
						if (temp != null) {
							temp = new String[] { temp[0], ProfileModifiers.CDC_1_0_FOUNDATION_1_0_NAME };
						} else {
							temp = new String[] { ProfileModifiers.CDC_1_0_FOUNDATION_1_0_NAME };
						}
					} else {
						if (temp != null) {
							temp = new String[] { temp[0], ProfileModifiers.CDC_1_1_FOUNDATION_1_1_NAME };
						} else {
							temp = new String[] { ProfileModifiers.CDC_1_1_FOUNDATION_1_1_NAME };
						}
					}
				}
				if (ProfileModifiers.isOSGi(values)) {
					if (ProfileModifiers.isOSGI_MINIMUM_1_0(values)) {
						if (temp != null) {
							int tempLength = temp.length;
							System.arraycopy(temp, 0, (temp = new String[tempLength + 1]), 0, tempLength);
							temp[tempLength] = ProfileModifiers.OSGI_MINIMUM_1_0_NAME;
						} else {
							temp = new String[] { ProfileModifiers.OSGI_MINIMUM_1_0_NAME };
						}
					} else if (ProfileModifiers.isOSGI_MINIMUM_1_1(values)) {
						if (temp != null) {
							int tempLength = temp.length;
							System.arraycopy(temp, 0, (temp = new String[tempLength + 1]), 0, tempLength);
							temp[tempLength] = ProfileModifiers.OSGI_MINIMUM_1_1_NAME;
						} else {
							temp = new String[] { ProfileModifiers.OSGI_MINIMUM_1_1_NAME };
						}
					} else {
						// OSGI_MINIMUM_1_2
						if (temp != null) {
							int tempLength = temp.length;
							System.arraycopy(temp, 0, (temp = new String[tempLength + 1]), 0, tempLength);
							temp[tempLength] = ProfileModifiers.OSGI_MINIMUM_1_2_NAME;
						} else {
							temp = new String[] { ProfileModifiers.OSGI_MINIMUM_1_2_NAME };
						}
					}
				}
		}
		lowestEEs = temp;
		return temp;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getErrors()
	 */
	public synchronized ResolverError[] getErrors() throws CoreException {
		init();
		ApiBaseline baseline = (ApiBaseline) getBaseline();
		if (fBundleDescription == null) {
			baselineDisposed(baseline);
		}
		if (baseline != null) {
			ResolverError[] resolverErrors = baseline.getState().getResolverErrors(fBundleDescription);
			if (resolverErrors.length == 0) {
				return null;
			}
			return resolverErrors;
		}
		return null;
	}
	
	/**
	 * @param baseline the baseline that is disposed
	 * @throws CoreException with the baseline disposed information
	 */
	protected void baselineDisposed(IApiBaseline baseline) throws CoreException {
		throw new CoreException(
				new Status(
						IStatus.ERROR,
						ApiPlugin.PLUGIN_ID,
						ApiPlugin.REPORT_BASELINE_IS_DISPOSED,
						NLS.bind(Messages.BundleApiComponent_baseline_disposed, baseline.getName()),
						null));
	}
}




/*******************************************************************************
 * Copyright (c) 2007, 2009 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.pde.api.tools.internal.model;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.api.tools.internal.problems.ApiProblemFilter;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.Factory;
import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;
import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;
import org.eclipse.pde.api.tools.internal.provisional.descriptors.IElementDescriptor;
import org.eclipse.pde.api.tools.internal.provisional.model.ApiTypeContainerVisitor;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiElement;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
import org.eclipse.pde.api.tools.internal.provisional.problems.IApiProblem;
import org.eclipse.pde.api.tools.internal.provisional.problems.IApiProblemFilter;

/**
 * Common implementation of an API component as a composite class file container.
 * 
 * @since 1.0.0
 */
public abstract class Component extends AbstractApiTypeContainer implements IApiComponent {
	/**
	 * API description
	 */
	private IApiDescription fApiDescription = null;
		
	/**
	 * Api Filter store
	 */
	private IApiFilterStore fFilterStore = null;
	
	/**
	 * Constructs an API component in the given {@link IApiBaseline}.
	 * 
	 * @param baseline the parent {@link IApiBaseline}
	 */
	public Component(IApiBaseline baseline) {
		super(baseline, IApiElement.COMPONENT, null);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IClassFileContainer#accept(org.eclipse.pde.api.tools.model.component.ClassFileContainerVisitor)
	 */
	public void accept(ApiTypeContainerVisitor visitor) throws CoreException {
		if (visitor.visit(this)) {
			super.accept(visitor);
		}
		visitor.end(this);
	}	
		
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getHost()
	 */
	public IApiComponent getHost() throws CoreException {
		return null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getBaseline()
	 */
	public IApiBaseline getBaseline() {
		return (IApiBaseline) getAncestor(IApiElement.BASELINE);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IApiComponent#dispose()
	 */
	public void dispose() {
		try {
			close();
		} catch (CoreException e) {
			ApiPlugin.log(e);
		}
		finally {
			synchronized(this) {
				fApiDescription = null;
			}
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.ApiElement#getApiComponent()
	 */
	public IApiComponent getApiComponent() {
		return this;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.model.component.IApiComponent#getApiDescription()
	 */
	public synchronized IApiDescription getApiDescription() throws CoreException {
		if (fApiDescription == null) {
			fApiDescription = createApiDescription();
		}
		return fApiDescription;
	}
	
	/**
	 * Returns whether this component has created an API description.
	 * 
	 * @return whether this component has created an API description
	 */
	protected synchronized boolean isApiDescriptionInitialized() {
		return fApiDescription != null;
	}

	/**
	 * Returns if this component has created an API filter store
	 * 
	 * @return true if a store has been created, false other wise
	 */
	protected synchronized boolean hasApiFilterStore() {
		return fFilterStore != null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.AbstractApiTypeContainer#getApiTypeContainers()
	 */
	public synchronized IApiTypeContainer[] getApiTypeContainers() throws CoreException {
		return super.getApiTypeContainers();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.AbstractApiTypeContainer#getApiTypeContainers()
	 */
	public synchronized IApiTypeContainer[] getApiTypeContainers(String id) throws CoreException {
		if (this.hasFragments()) {
			return super.getApiTypeContainers(id);
		} else {
			return super.getApiTypeContainers();
		}
	}
	
	/**
	 * Creates and returns the API description for this component.
	 * 
	 * @return newly created API description for this component
	 */
	protected abstract IApiDescription createApiDescription() throws CoreException;

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.IApiComponent#getFilterStore()
	 */
	public IApiFilterStore getFilterStore() throws CoreException {
		if(fFilterStore == null) {
			fFilterStore = createApiFilterStore();
		}
		return fFilterStore;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.IApiComponent#newProblemFilter(org.eclipse.pde.api.tools.internal.provisional.IApiProblem)
	 */
	public IApiProblemFilter newProblemFilter(IApiProblem problem) throws CoreException {
		//TODO either expose a way to make problems or change the method to accept the parts of a problem
		return new ApiProblemFilter(getSymbolicName(), problem);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getHandle()
	 */
	public IElementDescriptor getHandle() {
		return Factory.componentDescriptor(this.getSymbolicName(), this.getVersion());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer#getContainerType()
	 */
	public int getContainerType() {
		return IApiTypeContainer.COMPONENT;
	}
	
	/**
	 * Lazily creates a new {@link IApiFilterStore} when it is requested
	 * 
	 * @return the current {@link IApiFilterStore} for this component
	 * @throws CoreException
	 */
	protected abstract IApiFilterStore createApiFilterStore() throws CoreException;	
}




/*******************************************************************************
 * Copyright (c) 2007, 2009 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.pde.api.tools.internal.model;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.pde.api.tools.internal.ApiDescriptionManager;
import org.eclipse.pde.api.tools.internal.ApiFilterStore;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;
import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
import org.eclipse.pde.api.tools.internal.util.Util;
import org.eclipse.pde.core.build.IBuild;
import org.eclipse.pde.core.build.IBuildEntry;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.internal.core.build.WorkspaceBuildModel;

/**
 * An API component for a plug-in project in the workspace.
 * <p>
 * Note: this class requires a running workspace to be instantiated.
 * </p>
 * @since 1.0.0
 */
public class PluginProjectApiComponent extends BundleApiComponent {
	
	/**
	 * Constant used for controlling tracing in the plug-in workspace component
	 */
	private static boolean DEBUG = Util.DEBUG;
	
	/**
	 * Method used for initializing tracing in the plug-in workspace component
	 */
	public static void setDebug(boolean debugValue) {
		DEBUG = debugValue || Util.DEBUG;
	}
		
	/**
	 * Associated Java project
	 */
	private IJavaProject fProject = null;

	/**
	 * Associated IPluginModelBase object
	 */
	private IPluginModelBase fModel = null;
	
	/**
	 * A cache of bundle class path entries to class file containers.
	 */
	private Map fPathToOutputContainers = null;
	
	/**
	 * A cache of output location paths to corresponding class file containers.
	 */
	private Map fOutputLocationToContainer = null;

	/**
	 * Constructs an API component for the given Java project in the specified profile.
	 * 
	 * @param profile the owning profile
	 * @param location the given location of the component
	 * @param model the given model
	 * @param project java project
	 * @throws CoreException if unable to create the API component
	 */
	public PluginProjectApiComponent(IApiBaseline profile, String location, IPluginModelBase model) throws CoreException {
		super(profile, location);
		IPath path = new Path(location);
		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(path.lastSegment());
		this.fProject = JavaCore.create(project);
		this.fModel = model;
		setName(fModel.getResourceString(super.getName()));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#isBinaryBundle()
	 */
	protected boolean isBinaryBundle() {
		return false;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#isApiEnabled()
	 */
	protected boolean isApiEnabled() {
		return Util.isApiProject(fProject);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.descriptors.AbstractApiComponent#dispose()
	 */
	public void dispose() {
		try {
			if(hasApiFilterStore()) {
				getFilterStore().dispose();
			}
			fModel = null;
			if (fOutputLocationToContainer != null) {
				fOutputLocationToContainer.clear();
				fOutputLocationToContainer = null;
			}
			if (fPathToOutputContainers != null) {
				fPathToOutputContainers.clear();
				fPathToOutputContainers = null;
			}
		} 
		catch(CoreException ce) {
			ApiPlugin.log(ce);
		}
		finally {
			super.dispose();
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#createLocalApiDescription()
	 */
	protected IApiDescription createLocalApiDescription() throws CoreException {
		long time = System.currentTimeMillis();
		if(Util.isApiProject(getJavaProject())) {
			setHasApiDescription(true);
		}
		IApiDescription apiDesc = ApiDescriptionManager.getDefault().getApiDescription(this, getBundleDescription());
		if (DEBUG) {
			System.out.println("Time to create api description for: ["+fProject.getElementName()+"] " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}
		return apiDesc;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#createApiFilterStore()
	 */
	protected IApiFilterStore createApiFilterStore() throws CoreException {
		long time = System.currentTimeMillis();
		IApiFilterStore store = new ApiFilterStore(getJavaProject());
		if (DEBUG) {
			System.out.println("Time to create api filter store for: ["+fProject.getElementName()+"] " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}
		return store;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.descriptors.BundleApiComponent#createClassFileContainers()
	 */
	protected synchronized List createApiTypeContainers() throws CoreException {
		// first populate build.properties cache so we can create class file containers
		// from bundle classpath entries
		fPathToOutputContainers = new HashMap(4);
		fOutputLocationToContainer = new HashMap(4);
		if (fProject.exists() && fProject.getProject().isOpen()) {
			IFile prop = fProject.getProject().getFile("build.properties"); //$NON-NLS-1$
			if (prop.exists()) {
				WorkspaceBuildModel properties = new WorkspaceBuildModel(prop);
				IBuild build = properties.getBuild();
				IBuildEntry entry = build.getEntry("custom"); //$NON-NLS-1$
				if (entry != null) {
					String[] tokens = entry.getTokens();
					if (tokens.length == 1 && tokens[0].equals("true")) { //$NON-NLS-1$
						// hack : add the current output location for each classpath entries
						IClasspathEntry[] classpathEntries = fProject.getRawClasspath();
						List containers = new ArrayList();
						for (int i = 0; i < classpathEntries.length; i++) {
							IClasspathEntry classpathEntry = classpathEntries[i];
							switch(classpathEntry.getEntryKind()) {
								case IClasspathEntry.CPE_SOURCE :
									String containerPath = classpathEntry.getPath().removeFirstSegments(1).toString();
									IApiTypeContainer container = getApiTypeContainer(containerPath, this);
									if (container != null && !containers.contains(container)) {
										containers.add(container);
									}
									break;
								case IClasspathEntry.CPE_VARIABLE :
									classpathEntry = JavaCore.getResolvedClasspathEntry(classpathEntry);
									//$FALL-THROUGH$
								case IClasspathEntry.CPE_LIBRARY :
									IPath path = classpathEntry.getPath();
									if (Util.isArchive(path.lastSegment())) {
										IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(path);
										if (resource != null) {
											// jar inside the workspace
											containers.add(new ArchiveApiTypeContainer(this, resource.getLocation().toOSString()));
										} else {
											// external jar
											containers.add(new ArchiveApiTypeContainer(this, path.toOSString()));
										}
									}
									break;
							}
						}
						if (!containers.isEmpty()) {
							IApiTypeContainer cfc = null;
							if (containers.size() == 1) {
								cfc = (IApiTypeContainer) containers.get(0);
							} else {
								cfc = new CompositeApiTypeContainer(this, containers);
							}
							fPathToOutputContainers.put(".", cfc); //$NON-NLS-1$
						}
					}
				} else {
					IBuildEntry[] entries = build.getBuildEntries();
					int length = entries.length;
					for (int i = 0; i < length; i++) {
						IBuildEntry buildEntry = entries[i];
						if (buildEntry.getName().startsWith(IBuildEntry.JAR_PREFIX)) {
							String jar = buildEntry.getName().substring(IBuildEntry.JAR_PREFIX.length());
							String[] tokens = buildEntry.getTokens();
							if (tokens.length == 1) {
								IApiTypeContainer container = getApiTypeContainer(tokens[0], this);
								if (container != null) {
									fPathToOutputContainers.put(jar, container);
								}
							} else {
								List containers = new ArrayList();
								for (int j = 0; j < tokens.length; j++) {
									String currentToken = tokens[j];
									IApiTypeContainer container = getApiTypeContainer(currentToken, this);
									if (container != null && !containers.contains(container)) {
										containers.add(container);
									}
								}
								if (!containers.isEmpty()) {
									IApiTypeContainer cfc = null;
									if (containers.size() == 1) {
										cfc = (IApiTypeContainer) containers.get(0);
									} else {
										cfc = new CompositeApiTypeContainer(this, containers);
									}
									fPathToOutputContainers.put(jar, cfc);
								}
							}
						}
					}
				}
			}
			return super.createApiTypeContainers();
		}
		return Collections.EMPTY_LIST;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#createClassFileContainer(java.lang.String)
	 */
	protected IApiTypeContainer createApiTypeContainer(String path) throws IOException, CoreException {
		if (this.fPathToOutputContainers == null) {
			baselineDisposed(getBaseline());
		}
		IApiTypeContainer container = (IApiTypeContainer) fPathToOutputContainers.get(path);
		if (container == null) {
			// could be a binary jar included in the plug-in, just look for it
			container = findApiTypeContainer(path);
		}
		return container;
	}
	
	/** 
	 * Finds and returns an existing {@link IApiTypeContainer} at the specified location
	 * in this project, or <code>null</code> if none.
	 * 
	 * @param location project relative path to the class file container
	 * @return {@link IApiTypeContainer} or <code>null</code>
	 */
	private IApiTypeContainer findApiTypeContainer(String location) {
		IResource res = fProject.getProject().findMember(new Path(location));
		if (res != null) {
			if (res.getType() == IResource.FILE) {
				return new ArchiveApiTypeContainer(this, res.getLocation().toOSString());
			} else {
				return new DirectoryApiTypeContainer(this, res.getLocation().toOSString());
			}
		}
		return null;
	}
	
	/** 
	 * Finds and returns an {@link IApiTypeContainer} for the specified
	 * source folder, or <code>null</code> if it does not exist. If the
	 * source folder shares an output location with a previous source
	 * folder, the output location is shared (a new one is not created).
	 * 
	 * @param location project relative path to the source folder
	 * @return {@link IApiTypeContainer} or <code>null</code>
	 */
	private IApiTypeContainer getApiTypeContainer(String location, IApiComponent component) throws CoreException {
		if (this.fOutputLocationToContainer == null) {
			baselineDisposed(getBaseline());
		}
		IResource res = fProject.getProject().findMember(new Path(location));
		if (res != null) {
			IPackageFragmentRoot root = fProject.getPackageFragmentRoot(res);
			if (root.exists()) {
				if (root.getKind() == IPackageFragmentRoot.K_BINARY) {
					if (res.getType() == IResource.FOLDER) {
						// class file folder
						IPath location2 = res.getLocation();
						IApiTypeContainer cfc = (IApiTypeContainer) fOutputLocationToContainer.get(location2);
						if (cfc == null) {
							cfc = new FolderApiTypeContainer(component, (IContainer) res);
							fOutputLocationToContainer.put(location2, cfc);
						}
						return cfc;
					}
				} else {
					IClasspathEntry entry = root.getRawClasspathEntry();
					IPath outputLocation = entry.getOutputLocation();
					if (outputLocation == null) {
						outputLocation = fProject.getOutputLocation();
					}
					IApiTypeContainer cfc = (IApiTypeContainer) fOutputLocationToContainer.get(outputLocation);
					if (cfc == null) {
						IPath projectFullPath = fProject.getProject().getFullPath();
						IContainer container = null;
						if (projectFullPath.equals(outputLocation)) {
							// The project is its own output location
							container = fProject.getProject();
						} else {
							container = fProject.getProject().getWorkspace().getRoot().getFolder(outputLocation);
						}
						if (container.exists()) {
							cfc = new FolderApiTypeContainer(component, container);
							fOutputLocationToContainer.put(outputLocation, cfc);
						}
					}
					return cfc;
				}
			}
		}
		return null;
	}	
	
	/**
	 * Returns the Java project associated with this component.
	 * 
	 * @return associated Java project
	 */
	public IJavaProject getJavaProject() {
		return fProject;
	}
	
	/**
	 * Returns the cached API type container for the given package fragment root, or <code>null</code>
	 * if none. The given package fragment has to be a SOURCE package fragment - this method is only
	 * used by the project API description to obtain a class file corresponding to a compilation unit
	 * when tag scanning (to resolve signatures).
	 *  
	 * @param root source package fragment root
	 * @return API type container associated with the package fragment root, or <code>null</code> 
	 * 	if none
	 */
	public IApiTypeContainer getTypeContainer(IPackageFragmentRoot root) throws CoreException {
		if (root.getKind() == IPackageFragmentRoot.K_SOURCE) {
			getApiTypeContainers(); // ensure initialized
			IResource resource = root.getResource();
			if (resource != null) {
				String location = resource.getProjectRelativePath().toString();
				return getApiTypeContainer(location, this);
			}
		}
		return null;
	}
	
}




/*******************************************************************************
 * Copyright (c) 2007, 2009 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.pde.api.tools.internal.model;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.pde.api.tools.internal.ApiDescriptionManager;
import org.eclipse.pde.api.tools.internal.ApiFilterStore;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;
import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
import org.eclipse.pde.api.tools.internal.util.Util;
import org.eclipse.pde.core.build.IBuild;
import org.eclipse.pde.core.build.IBuildEntry;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.internal.core.build.WorkspaceBuildModel;
import org.osgi.framework.BundleException;

/**
 * An API component for a plug-in project in the workspace.
 * <p>
 * Note: this class requires a running workspace to be instantiated.
 * </p>
 * @since 1.0.0
 */
public class ProjectComponent extends BundleComponent {
	
	/**
	 * Constant used for controlling tracing in the plug-in workspace component
	 */
	private static boolean DEBUG = Util.DEBUG;
	
	/**
	 * Method used for initializing tracing in the plug-in workspace component
	 */
	public static void setDebug(boolean debugValue) {
		DEBUG = debugValue || Util.DEBUG;
	}
		
	/**
	 * Associated Java project
	 */
	private IJavaProject fProject = null;

	/**
	 * Associated IPluginModelBase object
	 */
	private IPluginModelBase fModel = null;
	
	/**
	 * A cache of bundle class path entries to class file containers.
	 */
	private Map fPathToOutputContainers = null;
	
	/**
	 * A cache of output location paths to corresponding class file containers.
	 */
	private Map fOutputLocationToContainer = null;

	/**
	 * Constructs an API component for the given Java project in the specified profile.
	 * 
	 * @param baseline the owning API baseline
	 * @param location the given location of the component
	 * @param model the given model
	 * @param bundleid
	 * @throws CoreException if unable to create the API component
	 */
	public ProjectComponent(IApiBaseline baseline, String location, IPluginModelBase model, long bundleid) throws CoreException {
		super(baseline, location, bundleid);
		IPath path = new Path(location);
		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(path.lastSegment());
		this.fProject = JavaCore.create(project);
		this.fModel = model;
		setName(fModel.getResourceString(super.getName()));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#isBinaryBundle()
	 */
	protected boolean isBinary() {
		return false;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.BundleApiComponent#getBundleDescription(java.util.Dictionary, java.lang.String, long)
	 */
	protected BundleDescription getBundleDescription(Dictionary manifest, String location, long id) throws BundleException {
		return fModel.getBundleDescription();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#isApiEnabled()
	 */
	protected boolean isApiEnabled() {
		return Util.isApiProject(fProject);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.descriptors.AbstractApiComponent#dispose()
	 */
	public void dispose() {
		try {
			if(hasApiFilterStore()) {
				getFilterStore().dispose();
			}
			fModel = null;
			if (fOutputLocationToContainer != null) {
				fOutputLocationToContainer.clear();
				fOutputLocationToContainer = null;
			}
			if (fPathToOutputContainers != null) {
				fPathToOutputContainers.clear();
				fPathToOutputContainers = null;
			}
		} 
		catch(CoreException ce) {
			ApiPlugin.log(ce);
		}
		finally {
			super.dispose();
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#createLocalApiDescription()
	 */
	protected IApiDescription createLocalApiDescription() throws CoreException {
		long time = System.currentTimeMillis();
		if(Util.isApiProject(getJavaProject())) {
			setHasApiDescription(true);
		}
		IApiDescription apiDesc = ApiDescriptionManager.getDefault().getApiDescription(this, getBundleDescription());
		if (DEBUG) {
			System.out.println("Time to create api description for: ["+fProject.getElementName()+"] " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}
		return apiDesc;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#createApiFilterStore()
	 */
	protected IApiFilterStore createApiFilterStore() throws CoreException {
		long time = System.currentTimeMillis();
		IApiFilterStore store = new ApiFilterStore(getJavaProject());
		if (DEBUG) {
			System.out.println("Time to create api filter store for: ["+fProject.getElementName()+"] " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}
		return store;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.descriptors.BundleApiComponent#createClassFileContainers()
	 */
	protected synchronized List createApiTypeContainers() throws CoreException {
		// first populate build.properties cache so we can create class file containers
		// from bundle classpath entries
		fPathToOutputContainers = new HashMap(4);
		fOutputLocationToContainer = new HashMap(4);
		if (fProject.exists() && fProject.getProject().isOpen()) {
			IFile prop = fProject.getProject().getFile("build.properties"); //$NON-NLS-1$
			if (prop.exists()) {
				WorkspaceBuildModel properties = new WorkspaceBuildModel(prop);
				IBuild build = properties.getBuild();
				IBuildEntry entry = build.getEntry("custom"); //$NON-NLS-1$
				if (entry != null) {
					String[] tokens = entry.getTokens();
					if (tokens.length == 1 && tokens[0].equals("true")) { //$NON-NLS-1$
						// hack : add the current output location for each classpath entries
						IClasspathEntry[] classpathEntries = fProject.getRawClasspath();
						List containers = new ArrayList();
						for (int i = 0; i < classpathEntries.length; i++) {
							IClasspathEntry classpathEntry = classpathEntries[i];
							switch(classpathEntry.getEntryKind()) {
								case IClasspathEntry.CPE_SOURCE :
									String containerPath = classpathEntry.getPath().removeFirstSegments(1).toString();
									IApiTypeContainer container = getApiTypeContainer(containerPath, this);
									if (container != null && !containers.contains(container)) {
										containers.add(container);
									}
									break;
								case IClasspathEntry.CPE_VARIABLE :
									classpathEntry = JavaCore.getResolvedClasspathEntry(classpathEntry);
									//$FALL-THROUGH$
								case IClasspathEntry.CPE_LIBRARY :
									IPath path = classpathEntry.getPath();
									if (Util.isArchive(path.lastSegment())) {
										IResource resource = ResourcesPlugin.getWorkspace().getRoot().findMember(path);
										if (resource != null) {
											// jar inside the workspace
											containers.add(new ArchiveApiTypeContainer(this, resource.getLocation().toOSString()));
										} else {
											// external jar
											containers.add(new ArchiveApiTypeContainer(this, path.toOSString()));
										}
									}
									break;
							}
						}
						if (!containers.isEmpty()) {
							IApiTypeContainer cfc = null;
							if (containers.size() == 1) {
								cfc = (IApiTypeContainer) containers.get(0);
							} else {
								cfc = new CompositeApiTypeContainer(this, containers);
							}
							fPathToOutputContainers.put(".", cfc); //$NON-NLS-1$
						}
					}
				} else {
					IBuildEntry[] entries = build.getBuildEntries();
					int length = entries.length;
					for (int i = 0; i < length; i++) {
						IBuildEntry buildEntry = entries[i];
						if (buildEntry.getName().startsWith(IBuildEntry.JAR_PREFIX)) {
							String jar = buildEntry.getName().substring(IBuildEntry.JAR_PREFIX.length());
							String[] tokens = buildEntry.getTokens();
							if (tokens.length == 1) {
								IApiTypeContainer container = getApiTypeContainer(tokens[0], this);
								if (container != null) {
									fPathToOutputContainers.put(jar, container);
								}
							} else {
								List containers = new ArrayList();
								for (int j = 0; j < tokens.length; j++) {
									String currentToken = tokens[j];
									IApiTypeContainer container = getApiTypeContainer(currentToken, this);
									if (container != null && !containers.contains(container)) {
										containers.add(container);
									}
								}
								if (!containers.isEmpty()) {
									IApiTypeContainer cfc = null;
									if (containers.size() == 1) {
										cfc = (IApiTypeContainer) containers.get(0);
									} else {
										cfc = new CompositeApiTypeContainer(this, containers);
									}
									fPathToOutputContainers.put(jar, cfc);
								}
							}
						}
					}
				}
			}
			return super.createApiTypeContainers();
		}
		return Collections.EMPTY_LIST;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.BundleApiComponent#createClassFileContainer(java.lang.String)
	 */
	protected IApiTypeContainer createApiTypeContainer(String path) throws IOException, CoreException {
		if (this.fPathToOutputContainers == null) {
			baselineDisposed(getBaseline());
		}
		IApiTypeContainer container = (IApiTypeContainer) fPathToOutputContainers.get(path);
		if (container == null) {
			// could be a binary jar included in the plug-in, just look for it
			container = findApiTypeContainer(path);
		}
		return container;
	}
	
	/** 
	 * Finds and returns an existing {@link IApiTypeContainer} at the specified location
	 * in this project, or <code>null</code> if none.
	 * 
	 * @param location project relative path to the class file container
	 * @return {@link IApiTypeContainer} or <code>null</code>
	 */
	private IApiTypeContainer findApiTypeContainer(String location) {
		IResource res = fProject.getProject().findMember(new Path(location));
		if (res != null) {
			if (res.getType() == IResource.FILE) {
				return new ArchiveApiTypeContainer(this, res.getLocation().toOSString());
			} else {
				return new DirectoryApiTypeContainer(this, res.getLocation().toOSString());
			}
		}
		return null;
	}
	
	/** 
	 * Finds and returns an {@link IApiTypeContainer} for the specified
	 * source folder, or <code>null</code> if it does not exist. If the
	 * source folder shares an output location with a previous source
	 * folder, the output location is shared (a new one is not created).
	 * 
	 * @param location project relative path to the source folder
	 * @return {@link IApiTypeContainer} or <code>null</code>
	 */
	private IApiTypeContainer getApiTypeContainer(String location, IApiComponent component) throws CoreException {
		if (this.fOutputLocationToContainer == null) {
			baselineDisposed(getBaseline());
		}
		IResource res = fProject.getProject().findMember(new Path(location));
		if (res != null) {
			IPackageFragmentRoot root = fProject.getPackageFragmentRoot(res);
			if (root.exists()) {
				if (root.getKind() == IPackageFragmentRoot.K_BINARY) {
					if (res.getType() == IResource.FOLDER) {
						// class file folder
						IPath location2 = res.getLocation();
						IApiTypeContainer cfc = (IApiTypeContainer) fOutputLocationToContainer.get(location2);
						if (cfc == null) {
							cfc = new FolderApiTypeContainer(component, (IContainer) res);
							fOutputLocationToContainer.put(location2, cfc);
						}
						return cfc;
					}
				} else {
					IClasspathEntry entry = root.getRawClasspathEntry();
					IPath outputLocation = entry.getOutputLocation();
					if (outputLocation == null) {
						outputLocation = fProject.getOutputLocation();
					}
					IApiTypeContainer cfc = (IApiTypeContainer) fOutputLocationToContainer.get(outputLocation);
					if (cfc == null) {
						IPath projectFullPath = fProject.getProject().getFullPath();
						IContainer container = null;
						if (projectFullPath.equals(outputLocation)) {
							// The project is its own output location
							container = fProject.getProject();
						} else {
							container = fProject.getProject().getWorkspace().getRoot().getFolder(outputLocation);
						}
						if (container.exists()) {
							cfc = new FolderApiTypeContainer(component, container);
							fOutputLocationToContainer.put(outputLocation, cfc);
						}
					}
					return cfc;
				}
			}
		}
		return null;
	}	
	
	/**
	 * Returns the Java project associated with this component.
	 * 
	 * @return associated Java project
	 */
	public IJavaProject getJavaProject() {
		return fProject;
	}
	
	/**
	 * Returns the cached API type container for the given package fragment root, or <code>null</code>
	 * if none. The given package fragment has to be a SOURCE package fragment - this method is only
	 * used by the project API description to obtain a class file corresponding to a compilation unit
	 * when tag scanning (to resolve signatures).
	 *  
	 * @param root source package fragment root
	 * @return API type container associated with the package fragment root, or <code>null</code> 
	 * 	if none
	 */
	public IApiTypeContainer getTypeContainer(IPackageFragmentRoot root) throws CoreException {
		if (root.getKind() == IPackageFragmentRoot.K_SOURCE) {
			getApiTypeContainers(); // ensure initialized
			IResource resource = root.getResource();
			if (resource != null) {
				String location = resource.getProjectRelativePath().toString();
				return getApiTypeContainer(location, this);
			}
		}
		return null;
	}
	
}




 * 
 * @since 1.0.0
 */
public class SystemLibraryApiComponent extends Component {
	
	/**
	 * Execution environment profile symbolic name.

	 * @see org.eclipse.pde.api.tools.internal.descriptors.AbstractApiComponent#createApiDescription()
	 */
	protected IApiDescription createApiDescription() throws CoreException {
		IApiDescription api = new ApiDescription(getSymbolicName());
		for (int i = 0; i < fSystemPackages.length; i++) {
			IPackageDescriptor pkg  = Factory.packageDescriptor(fSystemPackages[i]);
			api.setVisibility(pkg, VisibilityModifiers.API);

	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getId()
	 */
	public String getSymbolicName() {
		return fExecEnv[0];
	}
	




/*******************************************************************************
 * Copyright (c) 2009 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.pde.api.tools.internal.model;

import java.util.Arrays;
import java.util.HashSet;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.osgi.service.resolver.State;
import org.eclipse.pde.api.tools.internal.ApiBaselineManager;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.internal.core.PDECore;


/**
 * Describes the workspace baseline. Tracks the PDE model for the workspace
 * 
 * @since 1.1
 */
public class WorkspaceBaseline extends ApiBaseline {
	
	/**
	 * Constructor
	 */
	public WorkspaceBaseline() {
		super(ApiBaselineManager.WORKSPACE_API_BASELINE_ID);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.pde.api.tools.internal.model.ApiBaseline#getState()
	 */
	public State getState() {
		return PDECore.getDefault().getModelManager().getState().getState();
	}
	
	/* (non-Javadoc)
	 * @see IApiBaseline#addApiComponents(org.eclipse.pde.api.tools.model.component.IApiComponent[], boolean)
	 */
	public void addApiComponents(IApiComponent[] components) throws CoreException {
		HashSet ees = new HashSet();
		for (int i = 0; i < components.length; i++) {
			BundleComponent component = (BundleComponent) components[i];
			if (component.isSourceComponent()) {
				continue;
			}
			addComponent(component);
			ees.addAll(Arrays.asList(component.getExecutionEnvironments()));
		}
		resolveSystemLibrary(ees);
	}
}

Lines 43-49 Link Here

(-)src/org/eclipse/pde/api/tools/internal/provisional/ApiPlugin.java (-2 / +2 lines)
43	import org.eclipse.pde.api.tools.internal.builder.ReferenceResolver;	43	import org.eclipse.pde.api.tools.internal.builder.ReferenceResolver;
44	import org.eclipse.pde.api.tools.internal.comparator.ClassFileComparator;	44	import org.eclipse.pde.api.tools.internal.comparator.ClassFileComparator;
45	import org.eclipse.pde.api.tools.internal.descriptors.ElementDescriptorImpl;	45	import org.eclipse.pde.api.tools.internal.descriptors.ElementDescriptorImpl;
46	import org.eclipse.pde.api.tools.internal.model.PluginProjectApiComponent;	46	import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
47	import org.eclipse.pde.api.tools.internal.provisional.comparator.ApiComparator;	47	import org.eclipse.pde.api.tools.internal.provisional.comparator.ApiComparator;
48	import org.eclipse.pde.api.tools.internal.provisional.problems.IApiProblemTypes;	48	import org.eclipse.pde.api.tools.internal.provisional.problems.IApiProblemTypes;
49	import org.eclipse.pde.api.tools.internal.provisional.scanner.TagScanner;	49	import org.eclipse.pde.api.tools.internal.provisional.scanner.TagScanner;
Lines 587-593 Link Here
587	}	587	}
588	option = Platform.getDebugOption(PLUGIN_WORKSPACE_COMPONENT_DEBUG);	588	option = Platform.getDebugOption(PLUGIN_WORKSPACE_COMPONENT_DEBUG);
589	if(option != null) {	589	if(option != null) {
590	PluginProjectApiComponent.setDebug(option.equalsIgnoreCase(TRUE));	590	ProjectComponent.setDebug(option.equalsIgnoreCase(TRUE));
591	}	591	}
592	option = Platform.getDebugOption(API_PROFILE_MANAGER_DEBUG);	592	option = Platform.getDebugOption(API_PROFILE_MANAGER_DEBUG);
593	if(option != null) {	593	if(option != null) {




				Util.updateMonitor(localmonitor);
				IApiComponent apiComponent = apiComponents[i];
				if (!apiComponent.isSystemComponent()) {
					String id = apiComponent.getSymbolicName();
					IApiComponent apiComponent2 = baseline.getApiComponent(id);
					IDelta delta = null;
					if (apiComponent2 == null) {

				Util.updateMonitor(localmonitor);
				IApiComponent apiComponent = apiComponents2[i];
				if (!apiComponent.isSystemComponent()) {
					String id = apiComponent.getSymbolicName();
					if (!apiComponentsIds.contains(id)) {
						// addition of an API component
						globalDelta.add(

			Util.updateMonitor(localmonitor, 1);
			IDelta delta = null;
			if (!component.isSystemComponent()) {
				String id = component.getSymbolicName();
				IApiComponent apiComponent2 = referenceBaseline.getApiComponent(id);
				if (apiComponent2 == null) {
					// report addition of an API component

						IDelta.ADDED,
						IDelta.API_COMPONENT,
						null,
						component2.getSymbolicName(),
						Util.getComponentVersionsId(component2));
			} else if (component2 == null) {
				String referenceComponentId = referenceComponent.getSymbolicName();
				return new Delta(
						null,
						IDelta.API_PROFILE_ELEMENT_TYPE,

			if (referenceBaseline == null || baseline == null) {
				throw new IllegalArgumentException("The baselines cannot be null"); //$NON-NLS-1$
			}
			String referenceComponentId = referenceComponent.getSymbolicName();
			final Delta globalDelta = new Delta();
	
			// check the EE first

			}
			String typeName = typeRoot2.getTypeName();
			IApiTypeRoot typeRoot = null;
			String id = component.getSymbolicName();
			if (Util.ORG_ECLIPSE_SWT.equals(id)) {
				typeRoot = component.findTypeRoot(typeName);
			} else {

			final Delta globalDelta, 
			final IProgressMonitor monitor) throws CoreException {
		final Set typeRootBaseLineNames = new HashSet();
		final String id = component.getSymbolicName();
		IApiTypeContainer[] typeRootContainers = null;
		IApiTypeContainer[] typeRootContainers2 = null;
		final SubMonitor localmonitor = SubMonitor.convert(monitor, 4);

										Util.updateMonitor(localmonitor);
										IApiComponent p = providers[index];
										if (!p.equals(component2)) {
											String id2 = p.getSymbolicName();
											if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
												typeRoot2 = p.findTypeRoot(typeName);
											} else {

												while (typeRoot2 == null && index < providers.length) {
													IApiComponent p = providers[index];
													if (!p.equals(component2)) {
														String id2 = p.getSymbolicName();
														if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
															typeRoot2 = p.findTypeRoot(typeName);
														} else {

Lines 95-101 Link Here

(-)src/org/eclipse/pde/api/tools/internal/provisional/comparator/CompareApiScopeVisitor.java (-2 / +2 lines)
95	this.containsErrors = true;	95	this.containsErrors = true;
96	return false;	96	return false;
97	}	97	}
98	IApiComponent referenceComponent = this.referenceBaseline.getApiComponent(component.getId());	98	IApiComponent referenceComponent = this.referenceBaseline.getApiComponent(component.getSymbolicName());
99	if (referenceComponent != null && referenceComponent.getErrors() != null) {	99	if (referenceComponent != null && referenceComponent.getErrors() != null) {
100	this.containsErrors = true;	100	this.containsErrors = true;
101	return false;	101	return false;
Lines 140-146 Link Here
140	this.containsErrors = true;	140	this.containsErrors = true;
141	return;	141	return;
142	}	142	}
143	IApiComponent referenceComponent = this.referenceBaseline.getApiComponent(apiComponent.getId());	143	IApiComponent referenceComponent = this.referenceBaseline.getApiComponent(apiComponent.getSymbolicName());
144	if (referenceComponent == null) return;	144	if (referenceComponent == null) return;
145	if (referenceComponent.getErrors() != null) {	145	if (referenceComponent.getErrors() != null) {
146	this.containsErrors = true;	146	this.containsErrors = true;

Lines 30-40 Link Here

(-)src/org/eclipse/pde/api/tools/internal/provisional/model/IApiComponent.java (-2 / +2 lines)
30		30
31	/**	31	/**
32	* Returns this component's symbolic name. This is a handle-only	32	* Returns this component's symbolic name. This is a handle-only
33	* method - the component may not exist or ay be disposed.	33	* method - the component may not exist or may be disposed.
34	*	34	*
35	* @return component's symbolic name	35	* @return component's symbolic name
36	*/	36	*/
37	public String getId();	37	public String getSymbolicName();
38		38
39	/**	39	/**
40	* Returns this component's API description.	40	* Returns this component's API description.

Lines 304-314 Link Here

(-)src/org/eclipse/pde/api/tools/internal/provisional/search/ApiSearchEngine.java (-2 / +2 lines)
304	MultiStatus mstatus = null;	304	MultiStatus mstatus = null;
305	for (int i = 0; i < scopeelements.length; i++) {	305	for (int i = 0; i < scopeelements.length; i++) {
306	try {	306	try {
307	taskname = MessageFormat.format(SearchMessages.ApiSearchEngine_searching_project, new String[] {scopeelements[i].getApiComponent().getId(), fRequestorContext});	307	taskname = MessageFormat.format(SearchMessages.ApiSearchEngine_searching_project, new String[] {scopeelements[i].getApiComponent().getSymbolicName(), fRequestorContext});
308	localmonitor.setTaskName(taskname);	308	localmonitor.setTaskName(taskname);
309	if(DEBUG) {	309	if(DEBUG) {
310	loopstart = System.currentTimeMillis();	310	loopstart = System.currentTimeMillis();
311	System.out.println("Searching "+scopeelements[i].getApiComponent().getId()+"..."); //$NON-NLS-1$ //$NON-NLS-2$	311	System.out.println("Searching "+scopeelements[i].getApiComponent().getSymbolicName()+"..."); //$NON-NLS-1$ //$NON-NLS-2$
312	}	312	}
313	searchReferences(requestor, scopeelements[i], reporter, localmonitor.newChild(1));	313	searchReferences(requestor, scopeelements[i], reporter, localmonitor.newChild(1));
314	localmonitor.setTaskName(taskname);	314	localmonitor.setTaskName(taskname);

Lines 114-120 Link Here

(-)src/org/eclipse/pde/api/tools/internal/search/UseSearchRequestor.java (-2 / +2 lines)
114	if(pparts.length != 2) {	114	if(pparts.length != 2) {
115	continue;	115	continue;
116	}	116	}
117	if(container.getApiComponent().getId().equals(pparts[0])) {	117	if(container.getApiComponent().getSymbolicName().equals(pparts[0])) {
118	if(container.getName().endsWith(pparts[1])) {	118	if(container.getName().endsWith(pparts[1])) {
119	return false;	119	return false;
120	}	120	}
Lines 133-139 Link Here
133	IApiMember member = reference.getResolvedReference();	133	IApiMember member = reference.getResolvedReference();
134	if(member != null) {	134	if(member != null) {
135	IApiComponent component = member.getApiComponent();	135	IApiComponent component = member.getApiComponent();
136	if(!fComponentIds.contains(component.getId())) {	136	if(!fComponentIds.contains(component.getSymbolicName())) {
137	return false;	137	return false;
138	}	138	}
139	if(component.equals(reference.getMember().getApiComponent())) {	139	if(component.equals(reference.getMember().getApiComponent())) {

Lines 96-102 Link Here

(-)src/org/eclipse/pde/api/tools/internal/search/XmlSearchReporter.java (-1 / +1 lines)
96	*/	96	*/
97	String getId(IApiComponent component) throws CoreException {	97	String getId(IApiComponent component) throws CoreException {
98	StringBuffer buffer = new StringBuffer();	98	StringBuffer buffer = new StringBuffer();
99	buffer.append(component.getId()).append(" ").append('(').append(component.getVersion()).append(')'); //$NON-NLS-1$	99	buffer.append(component.getSymbolicName()).append(" ").append('(').append(component.getVersion()).append(')'); //$NON-NLS-1$
100	return buffer.toString();	100	return buffer.toString();
101	}	101	}
102		102




	 * @return API component + version identifier
	 */
	public static String getDeltaComponentVersionsId(IApiComponent component) {
		StringBuffer buffer = new StringBuffer(component.getSymbolicName());
		String version = component.getVersion();
		// remove the qualifier part
		if (version != null) {

	 * @return API component + version identifier
	 */
	public static String getComponentVersionsId(IApiComponent component) {
		StringBuffer buffer = new StringBuffer(component.getSymbolicName());
		String version = component.getVersion();
		// remove the qualifier part
		if (version != null) {

	public static final Comparator componentsorter = new Comparator(){
		public int compare(Object o1, Object o2) {
			if(o1 instanceof IApiComponent && o2 instanceof IApiComponent) {
				return ((IApiComponent)o1).getSymbolicName().compareTo(((IApiComponent)o2).getSymbolicName());
			}
			if(o1 instanceof SkippedComponent && o2 instanceof SkippedComponent) {
				return ((SkippedComponent)o1).getComponentId().compareTo(((SkippedComponent)o2).getComponentId());

				pattern = Pattern.compile(componentname);
				String componentid = null;
				for (int j = 0, max2 = components.length; j < max2; j++) {
					componentid = components[j].getSymbolicName();
					if (pattern.matcher(componentid).matches()) {
						list.add(componentid);
					}

Lines 259-265 Link Here

(-)src_ant/org/eclipse/pde/api/tools/internal/tasks/ApiMigrationTask.java (-2 / +2 lines)
259	if(!allowresolve) {	259	if(!allowresolve) {
260	ResolverError[] errors = component.getErrors();	260	ResolverError[] errors = component.getErrors();
261	if(errors != null) {	261	if(errors != null) {
262	this.notsearched.add(new SkippedComponent(component.getId(), component.getVersion(), errors));	262	this.notsearched.add(new SkippedComponent(component.getSymbolicName(), component.getVersion(), errors));
263	return false;	263	return false;
264	}	264	}
265	}	265	}
Lines 267-273 Link Here
267	return false;	267	return false;
268	}	268	}
269	if(pattern != null) {	269	if(pattern != null) {
270	return pattern.matcher(component.getId()).matches();	270	return pattern.matcher(component.getSymbolicName()).matches();
271	}	271	}
272	return true;	272	return true;
273	}	273	}




		if(!allowresolve) {
			ResolverError[] errors = component.getErrors();
			if(errors != null) {
				this.notsearched.add(new SkippedComponent(component.getSymbolicName(), component.getVersion(), errors)); 
				return false;
			}
		}

			return false;
		}
		if(pattern != null) {
			return pattern.matcher(component.getSymbolicName()).matches();
		}
		return true;
	}

		}
		for (int i = 0; i < components.length; i++) {
			if(acceptComponent(components[i], pattern, true)) {
				ids.add(components[i].getSymbolicName());
			}
			if(acceptComponent(components[i], pattern2, false)) {
				scope.add(components[i]);
			}
			else {
				this.notsearched.add(new SkippedComponent(components[i].getSymbolicName(), components[i].getVersion(), components[i].getErrors()));
			}
		}
	}

Lines 107-113 Link Here

(-)src_ant/org/eclipse/pde/api/tools/internal/tasks/CompareTask.java (-1 / +1 lines)
107	pattern = Pattern.compile(componentName);	107	pattern = Pattern.compile(componentName);
108	for (int j = 0, max2 = apiComponents.length; j < max2; j++) {	108	for (int j = 0, max2 = apiComponents.length; j < max2; j++) {
109	IApiComponent apiComponent = apiComponents[j];	109	IApiComponent apiComponent = apiComponents[j];
110	String componentId = apiComponent.getId();	110	String componentId = apiComponent.getSymbolicName();
111	Matcher matcher = pattern.matcher(componentId);	111	Matcher matcher = pattern.matcher(componentId);
112	if (matcher.matches()) {	112	if (matcher.matches()) {
113	scope.addElement(apiComponent);	113	scope.addElement(apiComponent);




	private void validateComponent(IApiBaseline baseline, String id, String name, String version, String environment, List<IRequiredComponentDescription> requiredComponents) throws CoreException {
		IApiComponent component = baseline.getApiComponent(id);
		
		assertEquals("Id: ", id , component.getSymbolicName());
		assertEquals("Name: ", name , component.getName());
		assertEquals("Version: ", version , component.getVersion());
		String[] envs = component.getExecutionEnvironments();

		IApiComponent[] prerequisiteComponents = baseline.getPrerequisiteComponents(new IApiComponent[]{component});
		for (int i = 0; i < prerequisiteComponents.length; i++) {
			IApiComponent apiComponent = prerequisiteComponents[i];
			if (apiComponent.getSymbolicName().equals("org.eclipse.osgi")) {
				// done
				return;
			}

		assertEquals("Wrong number of dependents", 2, dependents.length);
		for (int i = 0; i < dependents.length; i++) {
			IApiComponent apiComponent = dependents[i];
			if (apiComponent.getSymbolicName().equals("component.b")) {
				// done
				return;
			}




import org.eclipse.pde.api.tools.internal.ApiDescription;
import org.eclipse.pde.api.tools.internal.CompilationUnit;
import org.eclipse.pde.api.tools.internal.builder.Reference;
import org.eclipse.pde.api.tools.internal.model.Component;
import org.eclipse.pde.api.tools.internal.model.ApiBaseline;
import org.eclipse.pde.api.tools.internal.model.DirectoryApiTypeContainer;
import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;

	 */
	public void testSearchEngine() throws Exception {
		writePreamble("testSearchEngine()");
		final Component component = new Component(null) {
			public boolean isSystemComponent() {return false;}
			public boolean isSourceComponent() throws CoreException {return false;}
			public boolean isFragment() throws CoreException {return false;}

			public IRequiredComponentDescription[] getRequiredComponents() throws CoreException {return null;}
			public String[] getLowestEEs() throws CoreException {return null;}
			public String getLocation() {return null;}
			public String getSymbolicName() {return "test";}
			public String[] getExecutionEnvironments() throws CoreException {return null;}
			public ResolverError[] getErrors() throws CoreException {return null;}
			protected List createApiTypeContainers() throws CoreException {

Lines 53-59 Link Here

(-)src/org/eclipse/pde/api/tools/model/tests/ComponentManifestTests.java (-1 / +1 lines)
53	IApiBaseline baseline = TestSuiteHelper.newApiBaseline("test", TestSuiteHelper.getEEDescriptionFile());	53	IApiBaseline baseline = TestSuiteHelper.newApiBaseline("test", TestSuiteHelper.getEEDescriptionFile());
54	IApiComponent component = ApiModelFactory.newApiComponent(baseline, file.getAbsolutePath());	54	IApiComponent component = ApiModelFactory.newApiComponent(baseline, file.getAbsolutePath());
55	baseline.addApiComponents(new IApiComponent[] { component });	55	baseline.addApiComponents(new IApiComponent[] { component });
56	assertEquals("Id: ", "org.eclipse.debug.ui" , component.getId());	56	assertEquals("Id: ", "org.eclipse.debug.ui" , component.getSymbolicName());
57	assertEquals("Name: ", "Debug Platform UI" , component.getName());	57	assertEquals("Name: ", "Debug Platform UI" , component.getName());
58	assertEquals("Version: ", "3.3.100.qualifier" , component.getVersion());	58	assertEquals("Version: ", "3.3.100.qualifier" , component.getVersion());
59	String[] envs = component.getExecutionEnvironments();	59	String[] envs = component.getExecutionEnvironments();




			IApiComponent component = ApiModelFactory.newApiComponent(baseline, bundle.getAbsolutePath());
			if(component != null) {
				components.add(component);
				requiredComponents.add(component.getSymbolicName());
			}
		}
		// collect required components

			public String getLocation() {
				return null;
			}
			public String getSymbolicName() {
				return id;
			}
			public String[] getExecutionEnvironments() {

					IApiComponent component = ApiModelFactory.newApiComponent(baseline, bundle.getAbsolutePath());
					if(component != null) {
						components.add(component);
						requiredComponents.add(component.getSymbolicName());
					}
				}
			}

				} else {
					IApiComponent apiComponent = ApiModelFactory.newApiComponent(baseline, bundle.getAbsolutePath());
					collection.add(apiComponent);
					done.add(apiComponent.getSymbolicName());
					addAllRequired(baseline, done, apiComponent, collection);
				}
			}




		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			SkippedComponent scomp2 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertEquals("The components should be equal", scomp1, scomp2);
			assertTrue("The components should not be equal", !scomp1.equals(tcomp));
			assertTrue("The components should not be equal", !scomp2.equals(tcomp));

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			SkippedComponent scomp2 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertEquals("The component hashcodes should be equal", scomp1.hashCode(), scomp2.hashCode());
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			SkippedComponent scomp2 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertEquals("The component ids should be equal", scomp1.getComponentId(), scomp2.getComponentId());
			assertEquals("The component ids should be equal", scomp1.getComponentId(), tcomp.getSymbolicName());
			assertEquals("The component ids should be equal", scomp2.getComponentId(), tcomp.getSymbolicName());
		}
		catch(Exception e) {
			fail(e.getMessage());

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertFalse("The testing component was not excluded", scomp1.wasExcluded());
			scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), null);
			assertTrue("The testing component was excluded", scomp1.wasExcluded());
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), null);
			assertFalse("The testing component did have resolution errors", scomp1.hasResolutionErrors());
			scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertTrue("The testing component did not have resolution errors", scomp1.hasResolutionErrors());
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertNull("there should be no ancestors for SkippedComponents", scomp1.getAncestor(IApiElement.COMPONENT));
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertNull("there should be no IApiComponent object for SkippedComponents", scomp1.getApiComponent());
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertEquals("The names should be equal", tcomp.getSymbolicName(), scomp1.getName());
		}
		catch(Exception e) {
			fail(e.getMessage());

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertNull("there should be no parentt object for SkippedComponents", scomp1.getParent());
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertEquals("The type should be IApiElement.COMPONENT", IApiElement.COMPONENT, scomp1.getType());
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertEquals("The version should be 1.0.0", scomp1.getVersion(), DEFAULT_VERSION);
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertNotNull("There should be resolution errors for the testing component", scomp1.getErrors());
		}
		catch(Exception e) {

		try {
			IApiComponent tcomp = getTestingComponent();
			assertNotNull("The testing component should not be null", tcomp);
			SkippedComponent scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), tcomp.getErrors());
			assertNotNull("There should be resolution errors for the testing component", scomp1.getErrors());
			String reason = scomp1.getErrorDetails();
			assertTrue("The reason should be because of a unresolved constraint", reason.startsWith("Require-Bundle:"));
			scomp1 = new SkippedComponent(tcomp.getSymbolicName(), tcomp.getVersion(), null);
			assertNull("There should be no errors for the testing component", scomp1.getErrors());
			reason = scomp1.getErrorDetails();
			assertTrue("The reason should be because it was exclude", reason.startsWith("This component was excluded from the search by the search parameters."));

Lines 86-92 Link Here

(-)src/org/eclipse/pde/api/tools/search/tests/TestReporter.java (-1 / +1 lines)
86	* @see org.eclipse.pde.api.tools.internal.provisional.search.IApiSearchReporter#reportResults(org.eclipse.pde.api.tools.internal.provisional.model.IApiElement, org.eclipse.pde.api.tools.internal.provisional.builder.IReference[])	86	* @see org.eclipse.pde.api.tools.internal.provisional.search.IApiSearchReporter#reportResults(org.eclipse.pde.api.tools.internal.provisional.model.IApiElement, org.eclipse.pde.api.tools.internal.provisional.builder.IReference[])
87	*/	87	*/
88	public void reportResults(IApiElement element, IReference[] references) {	88	public void reportResults(IApiElement element, IReference[] references) {
89	String name = (element.getType() == IApiElement.COMPONENT ? ((IApiComponent)element).getId() : element.getName());	89	String name = (element.getType() == IApiElement.COMPONENT ? ((IApiComponent)element).getSymbolicName() : element.getName());
90	if(this.references == null) {	90	if(this.references == null) {
91	//expecting no references	91	//expecting no references
92	if(references.length > 0) {	92	if(references.length > 0) {




import java.util.HashSet;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
import org.eclipse.pde.api.tools.internal.provisional.IApiAnnotations;
import org.eclipse.pde.api.tools.internal.provisional.VisibilityModifiers;
import org.eclipse.pde.api.tools.internal.provisional.builder.IReference;

	 */
	private boolean acceptComponent0(IApiComponent component) throws CoreException {
		return component != null &&  
				!this.excluded.contains(component.getSymbolicName()) && 
				isApiComponent(component);
	}
	

	 * @return true if the project represented by the given component is API tools enabled false otherwise
	 */
	private boolean isApiComponent(IApiComponent component) {
		if(component instanceof ProjectComponent) {
			ProjectComponent comp = (ProjectComponent) component;
			return comp.hasApiDescription();
		}
		else {

Lines 1-7 Link Here

(-)test-xml/META-INF/MANIFEST.MF (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	Bundle-Name: test	2	Bundle-Name: test
3	Bundle-SymbolicName: test	3	Bundle-SymbolicName: test
4	Bundle-Version: test	4	Bundle-Version: 1.0
5	Export-Package: .,	5	Export-Package: .,
6	a.b.c,	6	a.b.c,
7	a.b.c.spi,	7	a.b.c.spi,

Lines 181-187 Link Here

(-)src/org/eclipse/pde/api/tools/ui/internal/ApiToolsLabelProvider.java (-1 / +1 lines)
181	public String getText(Object element) {	181	public String getText(Object element) {
182	if (element instanceof IApiComponent) {	182	if (element instanceof IApiComponent) {
183	IApiComponent comp = (IApiComponent) element;	183	IApiComponent comp = (IApiComponent) element;
184	return MessageFormat.format(Messages.ApiToolsLabelProvider_0, new String[]{comp.getId(), comp.getVersion()});	184	return MessageFormat.format(Messages.ApiToolsLabelProvider_0, new String[]{comp.getSymbolicName(), comp.getVersion()});
185	}	185	}
186	if (element instanceof File) {	186	if (element instanceof File) {
187	try {	187	try {




					if (apiComponent != null && (kind == IDelta.REMOVED)) {
						// need to handle reexported types
						IApiTypeRoot typeRoot = null;
						String id = apiComponent.getSymbolicName();
						switch(delta.getFlags()) {
							case IDelta.REEXPORTED_TYPE :
							case IDelta.REEXPORTED_API_TYPE :

								while (typeRoot == null && index < providers.length) {
									IApiComponent p = providers[index];
									if (!p.equals(apiComponent)) {
										String id2 = p.getSymbolicName();
										if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
											typeRoot = p.findTypeRoot(typeName);
										} else {

						IApiComponent apiComponent = baseline.getApiComponent(componentID);
						if (apiComponent != null) {
							IApiTypeRoot typeRoot = null;
							String id = apiComponent.getSymbolicName();
							switch(delta.getFlags()) {
								case IDelta.REEXPORTED_TYPE :
								case IDelta.REEXPORTED_API_TYPE :

									while (typeRoot == null && index < providers.length) {
										IApiComponent p = providers[index];
										if (!p.equals(apiComponent)) {
											String id2 = p.getSymbolicName();
											if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
												typeRoot = p.findTypeRoot(typeName);
											} else {




		localmonitor.setWorkRemaining(components.length);
		for (int i = 0; i < components.length; i++) {
			IApiComponent component = components[i];
			localmonitor.subTask(NLS.bind(Messages.ApiUseScanJob_checking_component, component.getSymbolicName()));
			Util.updateMonitor(localmonitor, 1);
			if (acceptComponent(component, pattern, true)) {
				ids.add(component.getSymbolicName());
			}
			if (acceptComponent(component, pattern2, false)) {
				scope.add(component);
			}
			else {
				localmonitor.subTask(NLS.bind(Messages.ApiUseScanJob_skipping_component, component.getSymbolicName()));
				this.notsearched.add(new SkippedComponent(component.getSymbolicName(), component.getVersion(), null));
			}
		}
	}

		if(!allowresolve) {
			ResolverError[] errors = component.getErrors();
			if(errors != null) {
				this.notsearched.add(new SkippedComponent(component.getSymbolicName(), component.getVersion(), errors)); 
				return false;
			}
		}

			return false;
		}
		if(pattern != null) {
			return pattern.matcher(component.getSymbolicName()).matches();
		}
		return true;
	}

Return to bug 233643

Lines 59-65 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/BaseApiAnalyzer.java (-18 / +18 lines)
59	import org.eclipse.pde.api.tools.internal.ApiFilterStore;	59	import org.eclipse.pde.api.tools.internal.ApiFilterStore;
60	import org.eclipse.pde.api.tools.internal.IApiCoreConstants;	60	import org.eclipse.pde.api.tools.internal.IApiCoreConstants;
61	import org.eclipse.pde.api.tools.internal.comparator.Delta;	61	import org.eclipse.pde.api.tools.internal.comparator.Delta;
62	import org.eclipse.pde.api.tools.internal.model.PluginProjectApiComponent;	62	import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
63	import org.eclipse.pde.api.tools.internal.problems.ApiProblemFactory;	63	import org.eclipse.pde.api.tools.internal.problems.ApiProblemFactory;
64	import org.eclipse.pde.api.tools.internal.problems.ApiProblemFilter;	64	import org.eclipse.pde.api.tools.internal.problems.ApiProblemFilter;
65	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;	65	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
Lines 218-231 Link Here
218	}	218	}
219	boolean checkfilters = false;	219	boolean checkfilters = false;
220	if(baseline != null) {	220	if(baseline != null) {
221	IApiComponent reference = baseline.getApiComponent(component.getId());	221	IApiComponent reference = baseline.getApiComponent(component.getSymbolicName());
222	this.fBuildState = state;	222	this.fBuildState = state;
223	if(fBuildState == null) {	223	if(fBuildState == null) {
224	fBuildState = getBuildState();	224	fBuildState = getBuildState();
225	}	225	}
226	//compatibility checks	226	//compatibility checks
227	if(reference != null) {	227	if(reference != null) {
228	localMonitor.subTask(NLS.bind(BuilderMessages.BaseApiAnalyzer_comparing_api_profiles, new String[] {reference.getId(), baseline.getName()}));	228	localMonitor.subTask(NLS.bind(BuilderMessages.BaseApiAnalyzer_comparing_api_profiles, new String[] {reference.getSymbolicName(), baseline.getName()}));
229	if(bcontext.hasChangedTypes()) {	229	if(bcontext.hasChangedTypes()) {
230	String[] changedtypes = bcontext.getStructurallyChangedTypes();	230	String[] changedtypes = bcontext.getStructurallyChangedTypes();
231	for(int i = 0; i < changedtypes.length; i++) {	231	for(int i = 0; i < changedtypes.length; i++) {
Lines 242-248 Link Here
242	}	242	}
243	this.fBuildState.setReexportedComponents(Util.getReexportedComponents(component));	243	this.fBuildState.setReexportedComponents(Util.getReexportedComponents(component));
244	} else {	244	} else {
245	localMonitor.subTask(NLS.bind(BuilderMessages.BaseApiAnalyzer_comparing_api_profiles, new String[] {component.getId(), baseline.getName()}));	245	localMonitor.subTask(NLS.bind(BuilderMessages.BaseApiAnalyzer_comparing_api_profiles, new String[] {component.getSymbolicName(), baseline.getName()}));
246	checkCompatibility(null, component, localMonitor.newChild(1));	246	checkCompatibility(null, component, localMonitor.newChild(1));
247	Util.updateMonitor(localMonitor);	247	Util.updateMonitor(localMonitor);
248	}	248	}
Lines 823-829 Link Here
823	}	823	}
824	scope = getSearchScope(component, (String[]) typenames.toArray(new String[typenames.size()]));	824	scope = getSearchScope(component, (String[]) typenames.toArray(new String[typenames.size()]));
825	}	825	}
826	SubMonitor localMonitor = SubMonitor.convert(monitor, MessageFormat.format(BuilderMessages.checking_api_usage, new String[] {component.getId()}), 2);	826	SubMonitor localMonitor = SubMonitor.convert(monitor, MessageFormat.format(BuilderMessages.checking_api_usage, new String[] {component.getSymbolicName()}), 2);
827	ReferenceAnalyzer analyzer = new ReferenceAnalyzer();	827	ReferenceAnalyzer analyzer = new ReferenceAnalyzer();
828	try {	828	try {
829	long start = System.currentTimeMillis();	829	long start = System.currentTimeMillis();
Lines 858-866 Link Here
858	* @param monitor	858	* @param monitor
859	*/	859	*/
860	private void checkCompatibility(final String typeName, final IApiComponent reference, final IApiComponent component, IProgressMonitor monitor) throws CoreException {	860	private void checkCompatibility(final String typeName, final IApiComponent reference, final IApiComponent component, IProgressMonitor monitor) throws CoreException {
861	String id = component.getId();	861	String id = component.getSymbolicName();
862	if (DEBUG) {	862	if (DEBUG) {
863	System.out.println("comparing profiles ["+reference.getId()+"] and ["+id+"] for type ["+typeName+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$	863	System.out.println("comparing profiles ["+reference.getSymbolicName()+"] and ["+id+"] for type ["+typeName+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
864	}	864	}
865	IApiTypeRoot classFile = null;	865	IApiTypeRoot classFile = null;
866	try {	866	try {
Lines 884-890 Link Here
884	while (classFile == null && index < providers.length) {	884	while (classFile == null && index < providers.length) {
885	IApiComponent p = providers[index];	885	IApiComponent p = providers[index];
886	if (!p.equals(component)) {	886	if (!p.equals(component)) {
887	String id2 = p.getId();	887	String id2 = p.getSymbolicName();
888	if (Util.ORG_ECLIPSE_SWT.equals(id2)) {	888	if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
889	classFile = p.findTypeRoot(typeName);	889	classFile = p.findTypeRoot(typeName);
890	} else {	890	} else {
Lines 1011-1025 Link Here
1011	IDelta.ADDED,	1011	IDelta.ADDED,
1012	IDelta.API_COMPONENT,	1012	IDelta.API_COMPONENT,
1013	null,	1013	null,
1014	component.getId(),	1014	component.getSymbolicName(),
1015	component.getId());	1015	component.getSymbolicName());
1016	Util.updateMonitor(localmonitor, 5);	1016	Util.updateMonitor(localmonitor, 5);
1017	} else {	1017	} else {
1018	try {	1018	try {
1019	delta = ApiComparator.compare(reference, component, VisibilityModifiers.API, localmonitor.newChild(1));	1019	delta = ApiComparator.compare(reference, component, VisibilityModifiers.API, localmonitor.newChild(1));
1020	} finally {	1020	} finally {
1021	if (DEBUG) {	1021	if (DEBUG) {
1022	System.out.println("Time spent for " + component.getId() + " : " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$	1022	System.out.println("Time spent for " + component.getSymbolicName() + " : " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
1023	}	1023	}
1024	fPendingDeltaInfos.clear();	1024	fPendingDeltaInfos.clear();
1025	}	1025	}
Lines 1350-1356 Link Here
1350	private void createApiComponentResolutionProblem(final IApiComponent component, final String message) throws CoreException {	1350	private void createApiComponentResolutionProblem(final IApiComponent component, final String message) throws CoreException {
1351	IApiProblem problem = ApiProblemFactory.newApiComponentResolutionProblem(	1351	IApiProblem problem = ApiProblemFactory.newApiComponentResolutionProblem(
1352	Path.EMPTY.toPortableString(),	1352	Path.EMPTY.toPortableString(),
1353	new String[] {component.getId(), message },	1353	new String[] {component.getSymbolicName(), message },
1354	new String[] {IApiMarkerConstants.API_MARKER_ATTR_ID},	1354	new String[] {IApiMarkerConstants.API_MARKER_ATTR_ID},
1355	new Object[] {new Integer(IApiMarkerConstants.API_COMPONENT_RESOLUTION_MARKER_ID)},	1355	new Object[] {new Integer(IApiMarkerConstants.API_COMPONENT_RESOLUTION_MARKER_ID)},
1356	IElementDescriptor.RESOURCE,	1356	IElementDescriptor.RESOURCE,
Lines 1377-1383 Link Here
1377	IApiTypeRoot typeRoot = null;	1377	IApiTypeRoot typeRoot = null;
1378	IApiType type = null;	1378	IApiType type = null;
1379	try {	1379	try {
1380	String id = component.getId();	1380	String id = component.getSymbolicName();
1381	if (Util.ORG_ECLIPSE_SWT.equals(id)) {	1381	if (Util.ORG_ECLIPSE_SWT.equals(id)) {
1382	typeRoot = component.findTypeRoot(typeName);	1382	typeRoot = component.findTypeRoot(typeName);
1383	} else {	1383	} else {
Lines 1391-1397 Link Here
1391	while (typeRoot == null && index < providers.length) {	1391	while (typeRoot == null && index < providers.length) {
1392	IApiComponent p = providers[index];	1392	IApiComponent p = providers[index];
1393	if (!p.equals(component)) {	1393	if (!p.equals(component)) {
1394	String id2 = p.getId();	1394	String id2 = p.getSymbolicName();
1395	if (Util.ORG_ECLIPSE_SWT.equals(id2)) {	1395	if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
1396	typeRoot = p.findTypeRoot(typeName);	1396	typeRoot = p.findTypeRoot(typeName);
1397	} else {	1397	} else {
Lines 1496-1503 Link Here
1496	Version compversion = new Version(compversionval);	1496	Version compversion = new Version(compversionval);
1497	Version newversion = null;	1497	Version newversion = null;
1498	if (DEBUG) {	1498	if (DEBUG) {
1499	System.out.println("reference version of " + reference.getId() + " : " + refversion); //$NON-NLS-1$ //$NON-NLS-2$	1499	System.out.println("reference version of " + reference.getSymbolicName() + " : " + refversion); //$NON-NLS-1$ //$NON-NLS-2$
1500	System.out.println("component version of " + component.getId() + " : " + compversion); //$NON-NLS-1$ //$NON-NLS-2$	1500	System.out.println("component version of " + component.getSymbolicName() + " : " + compversion); //$NON-NLS-1$ //$NON-NLS-2$
1501	}	1501	}
1502	IDelta[] breakingChanges = fBuildState.getBreakingChanges();	1502	IDelta[] breakingChanges = fBuildState.getBreakingChanges();
1503	if (breakingChanges.length != 0) {	1503	if (breakingChanges.length != 0) {
Lines 1835-1842 Link Here
1835	* @return Java project or <code>null</code>	1835	* @return Java project or <code>null</code>
1836	*/	1836	*/
1837	private IJavaProject getJavaProject(IApiComponent component) {	1837	private IJavaProject getJavaProject(IApiComponent component) {
1838	if (component instanceof PluginProjectApiComponent) {	1838	if (component instanceof ProjectComponent) {
1839	PluginProjectApiComponent pp = (PluginProjectApiComponent) component;	1839	ProjectComponent pp = (ProjectComponent) component;
1840	return pp.getJavaProject();	1840	return pp.getJavaProject();
1841	}	1841	}
1842	return null;	1842	return null;

Lines 92-98 Link Here

(-)src/org/eclipse/pde/api/tools/internal/comparator/ClassFileComparator.java (-5 / +5 lines)
92	if (result == null) {	92	if (result == null) {
93	// TODO should we report this failure ?	93	// TODO should we report this failure ?
94	if (Debug) {	94	if (Debug) {
95	System.err.println("CHECKED EXCEPTION LOOKUP: Could not find " + superName + " in profile " + profile.getName() + " from component " + apiComponent.getId()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$	95	System.err.println("CHECKED EXCEPTION LOOKUP: Could not find " + superName + " in profile " + profile.getName() + " from component " + apiComponent.getSymbolicName()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
96	}	96	}
97	break;	97	break;
98	}	98	}
Lines 3228-3247 Link Here
3228	String packageName = Signatures.getPackageName(typeName);	3228	String packageName = Signatures.getPackageName(typeName);
3229	IApiComponent[] components = profile.resolvePackage(component, packageName);	3229	IApiComponent[] components = profile.resolvePackage(component, packageName);
3230	if (components == null) {	3230	if (components == null) {
3231	String msg = MessageFormat.format(ComparatorMessages.ClassFileComparator_1, new String[] {packageName, profile.getName(), component.getId()});	3231	String msg = MessageFormat.format(ComparatorMessages.ClassFileComparator_1, new String[] {packageName, profile.getName(), component.getSymbolicName()});
3232	if (Debug) {	3232	if (Debug) {
3233	System.err.println("TYPE LOOKUP: "+msg); //$NON-NLS-1$	3233	System.err.println("TYPE LOOKUP: "+msg); //$NON-NLS-1$
3234	}	3234	}
3235	reportStatus(new Status(IStatus.ERROR, component.getId(), msg));	3235	reportStatus(new Status(IStatus.ERROR, component.getSymbolicName(), msg));
3236	return null;	3236	return null;
3237	}	3237	}
3238	IApiTypeRoot result = Util.getClassFile(components, typeName);	3238	IApiTypeRoot result = Util.getClassFile(components, typeName);
3239	if (result == null) {	3239	if (result == null) {
3240	String msg = MessageFormat.format(ComparatorMessages.ClassFileComparator_2, new String[] {typeName, profile.getName(), component.getId()});	3240	String msg = MessageFormat.format(ComparatorMessages.ClassFileComparator_2, new String[] {typeName, profile.getName(), component.getSymbolicName()});
3241	if (Debug) {	3241	if (Debug) {
3242	System.err.println("TYPE LOOKUP: "+msg); //$NON-NLS-1$	3242	System.err.println("TYPE LOOKUP: "+msg); //$NON-NLS-1$
3243	}	3243	}
3244	reportStatus(new Status(IStatus.ERROR, component.getId(), msg));	3244	reportStatus(new Status(IStatus.ERROR, component.getSymbolicName(), msg));
3245	return null;	3245	return null;
3246	}	3246	}
3247	return result;	3247	return result;

Lines 1965-1971 Link Here

(-)src/org/eclipse/pde/api/tools/internal/util/Util.java (-4 / +4 lines)
1965	* @return API component + version identifier	1965	* @return API component + version identifier
1966	*/	1966	*/
1967	public static String getDeltaComponentVersionsId(IApiComponent component) {	1967	public static String getDeltaComponentVersionsId(IApiComponent component) {
1968	StringBuffer buffer = new StringBuffer(component.getId());	1968	StringBuffer buffer = new StringBuffer(component.getSymbolicName());
1969	String version = component.getVersion();	1969	String version = component.getVersion();
1970	// remove the qualifier part	1970	// remove the qualifier part
1971	if (version != null) {	1971	if (version != null) {
Lines 1995-2001 Link Here
1995	* @return API component + version identifier	1995	* @return API component + version identifier
1996	*/	1996	*/
1997	public static String getComponentVersionsId(IApiComponent component) {	1997	public static String getComponentVersionsId(IApiComponent component) {
1998	StringBuffer buffer = new StringBuffer(component.getId());	1998	StringBuffer buffer = new StringBuffer(component.getSymbolicName());
1999	String version = component.getVersion();	1999	String version = component.getVersion();
2000	// remove the qualifier part	2000	// remove the qualifier part
2001	if (version != null) {	2001	if (version != null) {
Lines 2202-2208 Link Here
2202	public static final Comparator componentsorter = new Comparator(){	2202	public static final Comparator componentsorter = new Comparator(){
2203	public int compare(Object o1, Object o2) {	2203	public int compare(Object o1, Object o2) {
2204	if(o1 instanceof IApiComponent && o2 instanceof IApiComponent) {	2204	if(o1 instanceof IApiComponent && o2 instanceof IApiComponent) {
2205	return ((IApiComponent)o1).getId().compareTo(((IApiComponent)o2).getId());	2205	return ((IApiComponent)o1).getSymbolicName().compareTo(((IApiComponent)o2).getSymbolicName());
2206	}	2206	}
2207	if(o1 instanceof SkippedComponent && o2 instanceof SkippedComponent) {	2207	if(o1 instanceof SkippedComponent && o2 instanceof SkippedComponent) {
2208	return ((SkippedComponent)o1).getComponentId().compareTo(((SkippedComponent)o2).getComponentId());	2208	return ((SkippedComponent)o1).getComponentId().compareTo(((SkippedComponent)o2).getComponentId());
Lines 2289-2295 Link Here
2289	pattern = Pattern.compile(componentname);	2289	pattern = Pattern.compile(componentname);
2290	String componentid = null;	2290	String componentid = null;
2291	for (int j = 0, max2 = components.length; j < max2; j++) {	2291	for (int j = 0, max2 = components.length; j < max2; j++) {
2292	componentid = components[j].getId();	2292	componentid = components[j].getSymbolicName();
2293	if (pattern.matcher(componentid).matches()) {	2293	if (pattern.matcher(componentid).matches()) {
2294	list.add(componentid);	2294	list.add(componentid);
2295	}	2295	}

Lines 436-442 Link Here

(-)src/org/eclipse/pde/api/tools/ui/internal/actions/DeltaSession.java (-4 / +4 lines)
436	if (apiComponent != null && (kind == IDelta.REMOVED)) {	436	if (apiComponent != null && (kind == IDelta.REMOVED)) {
437	// need to handle reexported types	437	// need to handle reexported types
438	IApiTypeRoot typeRoot = null;	438	IApiTypeRoot typeRoot = null;
439	String id = apiComponent.getId();	439	String id = apiComponent.getSymbolicName();
440	switch(delta.getFlags()) {	440	switch(delta.getFlags()) {
441	case IDelta.REEXPORTED_TYPE :	441	case IDelta.REEXPORTED_TYPE :
442	case IDelta.REEXPORTED_API_TYPE :	442	case IDelta.REEXPORTED_API_TYPE :
Lines 452-458 Link Here
452	while (typeRoot == null && index < providers.length) {	452	while (typeRoot == null && index < providers.length) {
453	IApiComponent p = providers[index];	453	IApiComponent p = providers[index];
454	if (!p.equals(apiComponent)) {	454	if (!p.equals(apiComponent)) {
455	String id2 = p.getId();	455	String id2 = p.getSymbolicName();
456	if (Util.ORG_ECLIPSE_SWT.equals(id2)) {	456	if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
457	typeRoot = p.findTypeRoot(typeName);	457	typeRoot = p.findTypeRoot(typeName);
458	} else {	458	} else {
Lines 484-490 Link Here
484	IApiComponent apiComponent = baseline.getApiComponent(componentID);	484	IApiComponent apiComponent = baseline.getApiComponent(componentID);
485	if (apiComponent != null) {	485	if (apiComponent != null) {
486	IApiTypeRoot typeRoot = null;	486	IApiTypeRoot typeRoot = null;
487	String id = apiComponent.getId();	487	String id = apiComponent.getSymbolicName();
488	switch(delta.getFlags()) {	488	switch(delta.getFlags()) {
489	case IDelta.REEXPORTED_TYPE :	489	case IDelta.REEXPORTED_TYPE :
490	case IDelta.REEXPORTED_API_TYPE :	490	case IDelta.REEXPORTED_API_TYPE :
Lines 500-506 Link Here
500	while (typeRoot == null && index < providers.length) {	500	while (typeRoot == null && index < providers.length) {
501	IApiComponent p = providers[index];	501	IApiComponent p = providers[index];
502	if (!p.equals(apiComponent)) {	502	if (!p.equals(apiComponent)) {
503	String id2 = p.getId();	503	String id2 = p.getSymbolicName();
504	if (Util.ORG_ECLIPSE_SWT.equals(id2)) {	504	if (Util.ORG_ECLIPSE_SWT.equals(id2)) {
505	typeRoot = p.findTypeRoot(typeName);	505	typeRoot = p.findTypeRoot(typeName);
506	} else {	506	} else {

Lines 283-299 Link Here

(-)src/org/eclipse/pde/api/tools/ui/internal/use/ApiUseScanJob.java (-6 / +6 lines)
283	localmonitor.setWorkRemaining(components.length);	283	localmonitor.setWorkRemaining(components.length);
284	for (int i = 0; i < components.length; i++) {	284	for (int i = 0; i < components.length; i++) {
285	IApiComponent component = components[i];	285	IApiComponent component = components[i];
286	localmonitor.subTask(NLS.bind(Messages.ApiUseScanJob_checking_component, component.getId()));	286	localmonitor.subTask(NLS.bind(Messages.ApiUseScanJob_checking_component, component.getSymbolicName()));
287	Util.updateMonitor(localmonitor, 1);	287	Util.updateMonitor(localmonitor, 1);
288	if (acceptComponent(component, pattern, true)) {	288	if (acceptComponent(component, pattern, true)) {
289	ids.add(component.getId());	289	ids.add(component.getSymbolicName());
290	}	290	}
291	if (acceptComponent(component, pattern2, false)) {	291	if (acceptComponent(component, pattern2, false)) {
292	scope.add(component);	292	scope.add(component);
293	}	293	}
294	else {	294	else {
295	localmonitor.subTask(NLS.bind(Messages.ApiUseScanJob_skipping_component, component.getId()));	295	localmonitor.subTask(NLS.bind(Messages.ApiUseScanJob_skipping_component, component.getSymbolicName()));
296	this.notsearched.add(new SkippedComponent(component.getId(), component.getVersion(), null));	296	this.notsearched.add(new SkippedComponent(component.getSymbolicName(), component.getVersion(), null));
297	}	297	}
298	}	298	}
299	}	299	}
Lines 326-332 Link Here
326	if(!allowresolve) {	326	if(!allowresolve) {
327	ResolverError[] errors = component.getErrors();	327	ResolverError[] errors = component.getErrors();
328	if(errors != null) {	328	if(errors != null) {
329	this.notsearched.add(new SkippedComponent(component.getId(), component.getVersion(), errors));	329	this.notsearched.add(new SkippedComponent(component.getSymbolicName(), component.getVersion(), errors));
330	return false;	330	return false;
331	}	331	}
332	}	332	}
Lines 334-340 Link Here
334	return false;	334	return false;
335	}	335	}
336	if(pattern != null) {	336	if(pattern != null) {
337	return pattern.matcher(component.getId()).matches();	337	return pattern.matcher(component.getSymbolicName()).matches();
338	}	338	}
339	return true;	339	return true;
340	}	340	}

Lines 23-28 Link Here

(-)src/org/eclipse/pde/api/tools/internal/ApiBaselineManager.java (-7 / +15 lines)
23	import java.util.HashSet;	23	import java.util.HashSet;
24	import java.util.Iterator;	24	import java.util.Iterator;
25	import java.util.List;	25	import java.util.List;
		26	import java.util.Set;
26		27
27	import javax.xml.parsers.DocumentBuilder;	28	import javax.xml.parsers.DocumentBuilder;
28	import javax.xml.parsers.DocumentBuilderFactory;	29	import javax.xml.parsers.DocumentBuilderFactory;
Lines 59-64 Link Here
59	import org.eclipse.pde.api.tools.internal.model.ApiModelCache;	60	import org.eclipse.pde.api.tools.internal.model.ApiModelCache;
60	import org.eclipse.pde.api.tools.internal.model.ApiModelFactory;	61	import org.eclipse.pde.api.tools.internal.model.ApiModelFactory;
61	import org.eclipse.pde.api.tools.internal.model.StubApiComponent;	62	import org.eclipse.pde.api.tools.internal.model.StubApiComponent;
		63	import org.eclipse.pde.api.tools.internal.model.WorkspaceBaseline;
62	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;	64	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
63	import org.eclipse.pde.api.tools.internal.provisional.IApiBaselineManager;	65	import org.eclipse.pde.api.tools.internal.provisional.IApiBaselineManager;
64	import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;	66	import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
Lines 66-71 Link Here
66	import org.eclipse.pde.api.tools.internal.util.Util;	68	import org.eclipse.pde.api.tools.internal.util.Util;
67	import org.eclipse.pde.core.plugin.IPluginModelBase;	69	import org.eclipse.pde.core.plugin.IPluginModelBase;
68	import org.eclipse.pde.core.plugin.PluginRegistry;	70	import org.eclipse.pde.core.plugin.PluginRegistry;
		71	import org.eclipse.pde.internal.core.DependencyManager;
69	import org.w3c.dom.Document;	72	import org.w3c.dom.Document;
70	import org.w3c.dom.Element;	73	import org.w3c.dom.Element;
71	import org.w3c.dom.NodeList;	74	import org.w3c.dom.NodeList;
Lines 403-409 Link Here
403	IApiComponent comp = components[i];	406	IApiComponent comp = components[i];
404	if (!comp.isSystemComponent()) {	407	if (!comp.isSystemComponent()) {
405	celement = document.createElement(IApiXmlConstants.ELEMENT_APICOMPONENT);	408	celement = document.createElement(IApiXmlConstants.ELEMENT_APICOMPONENT);
406	celement.setAttribute(IApiXmlConstants.ATTR_ID, comp.getId());	409	celement.setAttribute(IApiXmlConstants.ATTR_ID, comp.getSymbolicName());
407	celement.setAttribute(IApiXmlConstants.ATTR_VERSION, comp.getVersion());	410	celement.setAttribute(IApiXmlConstants.ATTR_VERSION, comp.getVersion());
408	celement.setAttribute(IApiXmlConstants.ATTR_LOCATION, new Path(comp.getLocation()).toPortableString());	411	celement.setAttribute(IApiXmlConstants.ATTR_LOCATION, new Path(comp.getLocation()).toPortableString());
409	root.appendChild(celement);	412	root.appendChild(celement);
Lines 665-678 Link Here
665	long time = System.currentTimeMillis();	668	long time = System.currentTimeMillis();
666	IApiBaseline baseline = null;	669	IApiBaseline baseline = null;
667	try {	670	try {
668	baseline = ApiModelFactory.newApiBaseline(ApiBaselineManager.WORKSPACE_API_BASELINE_ID);	671	baseline = new WorkspaceBaseline();
669	// populate it with only projects that are API aware	672	// populate it with only projects that are API aware
670	IPluginModelBase[] models = PluginRegistry.getActiveModels();	673	Set ids = DependencyManager.getSelfandDependencies(PluginRegistry.getWorkspaceModels(), null);
671	List componentsList = new ArrayList(models.length);	674	List componentsList = new ArrayList(ids.size());
672	IApiComponent apiComponent = null;	675	IApiComponent apiComponent = null;
673	for (int i = 0, length = models.length; i < length; i++) {	676	IPluginModelBase model = null;
		677	for (Iterator iter = ids.iterator(); iter.hasNext();) {
		678	model = PluginRegistry.findModel((String) iter.next());
		679	if(model == null) {
		680	continue;
		681	}
674	try {	682	try {
675	apiComponent = ApiModelFactory.newApiComponent(baseline, models[i]);	683	apiComponent = ApiModelFactory.newApiComponent(baseline, model);
676	if (apiComponent != null) {	684	if (apiComponent != null) {
677	componentsList.add(apiComponent);	685	componentsList.add(apiComponent);
678	}	686	}
Lines 683-689 Link Here
683	baseline.addApiComponents((IApiComponent[]) componentsList.toArray(new IApiComponent[componentsList.size()]));	691	baseline.addApiComponents((IApiComponent[]) componentsList.toArray(new IApiComponent[componentsList.size()]));
684	} finally {	692	} finally {
685	if (DEBUG) {	693	if (DEBUG) {
686	System.out.println("Time to create a workspace profile : " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$	694	System.out.println("Time to create a workspace baseline : " + (System.currentTimeMillis() - time) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
687	}	695	}
688	}	696	}
689	return baseline;	697	return baseline;

Lines 33-40 Link Here

(-)src/org/eclipse/pde/api/tools/internal/ProjectApiDescription.java (-6 / +6 lines)
33	import org.eclipse.jdt.core.IPackageFragmentRoot;	33	import org.eclipse.jdt.core.IPackageFragmentRoot;
34	import org.eclipse.jdt.core.IType;	34	import org.eclipse.jdt.core.IType;
35	import org.eclipse.jdt.core.JavaModelException;	35	import org.eclipse.jdt.core.JavaModelException;
36	import org.eclipse.pde.api.tools.internal.model.BundleApiComponent;	36	import org.eclipse.pde.api.tools.internal.model.BundleComponent;
37	import org.eclipse.pde.api.tools.internal.model.PluginProjectApiComponent;	37	import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
38	import org.eclipse.pde.api.tools.internal.provisional.ApiDescriptionVisitor;	38	import org.eclipse.pde.api.tools.internal.provisional.ApiDescriptionVisitor;
39	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;	39	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
40	import org.eclipse.pde.api.tools.internal.provisional.Factory;	40	import org.eclipse.pde.api.tools.internal.provisional.Factory;
Lines 563-570 Link Here
563	for (int i = 0; i < fragments.length; i++) {	563	for (int i = 0; i < fragments.length; i++) {
564	names.add(fragments[i].getElementName());	564	names.add(fragments[i].getElementName());
565	}	565	}
566	PluginProjectApiComponent component = getApiComponent();	566	ProjectComponent component = getApiComponent();
567	BundleApiComponent.initializeApiDescription(this, component.getBundleDescription(), names);	567	BundleComponent.initializeApiDescription(this, component.getBundleDescription(), names);
568	fPackageTimeStamp = fManifestFile.getModificationStamp();	568	fPackageTimeStamp = fManifestFile.getModificationStamp();
569	} catch (CoreException e) {	569	} catch (CoreException e) {
570	ApiPlugin.log(e.getStatus());	570	ApiPlugin.log(e.getStatus());
Lines 712-720 Link Here
712	* @return API component	712	* @return API component
713	* @exception CoreException if the API component cannot be located	713	* @exception CoreException if the API component cannot be located
714	*/	714	*/
715	private PluginProjectApiComponent getApiComponent() throws CoreException {	715	private ProjectComponent getApiComponent() throws CoreException {
716	IApiBaseline baseline = ApiBaselineManager.getManager().getWorkspaceBaseline();	716	IApiBaseline baseline = ApiBaselineManager.getManager().getWorkspaceBaseline();
717	PluginProjectApiComponent component = (PluginProjectApiComponent) baseline.getApiComponent(getJavaProject().getProject());	717	ProjectComponent component = (ProjectComponent) baseline.getApiComponent(getJavaProject().getProject());
718	if (component == null) {	718	if (component == null) {
719	throw new CoreException(new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, "Unable to resolve project API component for API description")); //$NON-NLS-1$	719	throw new CoreException(new Status(IStatus.ERROR, ApiPlugin.PLUGIN_ID, "Unable to resolve project API component for API description")); //$NON-NLS-1$
720	}	720	}

Lines 643-654 Link Here

(-)src/org/eclipse/pde/api/tools/internal/builder/Reference.java (-2 / +2 lines)
643	visibility = annot.getVisibility();	643	visibility = annot.getVisibility();
644	if(annot.getVisibility() == VisibilityModifiers.PRIVATE) {	644	if(annot.getVisibility() == VisibilityModifiers.PRIVATE) {
645	IApiComponent host = mcomponent.getHost();	645	IApiComponent host = mcomponent.getHost();
646	if(host != null && host.getId().equals(rcomponent.getId())) {	646	if(host != null && host.getSymbolicName().equals(rcomponent.getSymbolicName())) {
647	visibility = UseReportConverter.FRAGMENT_PERMISSIBLE;	647	visibility = UseReportConverter.FRAGMENT_PERMISSIBLE;
648	}	648	}
649	else {	649	else {
650	IApiAccess access = description.resolveAccessLevel(	650	IApiAccess access = description.resolveAccessLevel(
651	Factory.componentDescriptor(mcomponent.getId()), // component descriptors in API description are not version qualified	651	Factory.componentDescriptor(mcomponent.getSymbolicName()), // component descriptors in API description are not version qualified
652	getResolvedReference().getHandle().getPackage());	652	getResolvedReference().getHandle().getPackage());
653	if(access != null && access.getAccessLevel() == IApiAccess.FRIEND) {	653	if(access != null && access.getAccessLevel() == IApiAccess.FRIEND) {
654	visibility = VisibilityModifiers.PRIVATE_PERMISSIBLE;	654	visibility = VisibilityModifiers.PRIVATE_PERMISSIBLE;

Removed Link Here

(-)src/org/eclipse/pde/api/tools/internal/model/AbstractApiComponent.java (-188 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 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.pde.api.tools.internal.model;
12
13	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.pde.api.tools.internal.problems.ApiProblemFilter;
15	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
16	import org.eclipse.pde.api.tools.internal.provisional.Factory;
17	import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;
18	import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;
19	import org.eclipse.pde.api.tools.internal.provisional.descriptors.IElementDescriptor;
20	import org.eclipse.pde.api.tools.internal.provisional.model.ApiTypeContainerVisitor;
21	import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
22	import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
23	import org.eclipse.pde.api.tools.internal.provisional.model.IApiElement;
24	import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
25	import org.eclipse.pde.api.tools.internal.provisional.problems.IApiProblem;
26	import org.eclipse.pde.api.tools.internal.provisional.problems.IApiProblemFilter;
27
28	/**
29	* Common implementation of an API component as a composite class file container.
30	*
31	* @since 1.0.0
32	*/
33	public abstract class AbstractApiComponent extends AbstractApiTypeContainer implements IApiComponent {
34	/**
35	* API description
36	*/
37	private IApiDescription fApiDescription = null;
38
39	/**
40	* Api Filter store
41	*/
42	private IApiFilterStore fFilterStore = null;
43
44	/**
45	* Constructs an API component in the given {@link IApiBaseline}.
46	*
47	* @param baseline the parent {@link IApiBaseline}
48	*/
49	public AbstractApiComponent(IApiBaseline baseline) {
50	super(baseline, IApiElement.COMPONENT, null);
51	}
52
53	/* (non-Javadoc)
54	* @see org.eclipse.pde.api.tools.model.component.IClassFileContainer#accept(org.eclipse.pde.api.tools.model.component.ClassFileContainerVisitor)
55	*/
56	public void accept(ApiTypeContainerVisitor visitor) throws CoreException {
57	if (visitor.visit(this)) {
58	super.accept(visitor);
59	}
60	visitor.end(this);
61	}
62
63	/**
64	* @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getHost()
65	*/
66	public IApiComponent getHost() throws CoreException {
67	return null;
68	}
69
70	/**
71	* @see org.eclipse.pde.api.tools.internal.provisional.IApiComponent#getBaseline()
72	*/
73	public IApiBaseline getBaseline() {
74	return (IApiBaseline) getAncestor(IApiElement.BASELINE);
75	}
76
77	/* (non-Javadoc)
78	* @see org.eclipse.pde.api.tools.model.component.IApiComponent#dispose()
79	*/
80	public void dispose() {
81	try {
82	close();
83	} catch (CoreException e) {
84	ApiPlugin.log(e);
85	}
86	fApiDescription = null;
87	}
88
89	/* (non-Javadoc)
90	* @see org.eclipse.pde.api.tools.internal.model.ApiElement#getApiComponent()
91	*/
92	public IApiComponent getApiComponent() {
93	return this;
94	}
95
96	/* (non-Javadoc)
97	* @see org.eclipse.pde.api.tools.model.component.IApiComponent#getApiDescription()
98	*/
99	public synchronized IApiDescription getApiDescription() throws CoreException {
100	if (fApiDescription == null) {
101	fApiDescription = createApiDescription();
102	}
103	return fApiDescription;
104	}
105
106	/**
107	* Returns whether this component has created an API description.
108	*
109	* @return whether this component has created an API description
110	*/
111	protected synchronized boolean isApiDescriptionInitialized() {
112	return fApiDescription != null;
113	}
114
115	/**
116	* Returns if this component has created an API filter store
117	*
118	* @return true if a store has been created, false other wise
119	*/
120	protected synchronized boolean hasApiFilterStore() {
121	return fFilterStore != null;
122	}
123
124	/* (non-Javadoc)
125	* @see org.eclipse.pde.api.tools.internal.model.AbstractApiTypeContainer#getApiTypeContainers()
126	*/
127	public synchronized IApiTypeContainer[] getApiTypeContainers() throws CoreException {
128	return super.getApiTypeContainers();
129	}
130
131	/* (non-Javadoc)
132	* @see org.eclipse.pde.api.tools.internal.model.AbstractApiTypeContainer#getApiTypeContainers()
133	*/
134	public synchronized IApiTypeContainer[] getApiTypeContainers(String id) throws CoreException {
135	if (this.hasFragments()) {
136	return super.getApiTypeContainers(id);
137	} else {
138	return super.getApiTypeContainers();
139	}
140	}
141
142	/**
143	* Creates and returns the API description for this component.
144	*
145	* @return newly created API description for this component
146	*/
147	protected abstract IApiDescription createApiDescription() throws CoreException;
148
149	/* (non-Javadoc)
150	* @see org.eclipse.pde.api.tools.IApiComponent#getFilterStore()
151	*/
152	public IApiFilterStore getFilterStore() throws CoreException {
153	if(fFilterStore == null) {
154	fFilterStore = createApiFilterStore();
155	}
156	return fFilterStore;
157	}
158
159	/* (non-Javadoc)
160	* @see org.eclipse.pde.api.tools.internal.provisional.IApiComponent#newProblemFilter(org.eclipse.pde.api.tools.internal.provisional.IApiProblem)
161	*/
162	public IApiProblemFilter newProblemFilter(IApiProblem problem) throws CoreException {
163	//TODO either expose a way to make problems or change the method to accept the parts of a problem
164	return new ApiProblemFilter(getId(), problem);
165	}
166
167	/* (non-Javadoc)
168	* @see org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent#getHandle()
169	*/
170	public IElementDescriptor getHandle() {
171	return Factory.componentDescriptor(this.getId(), this.getVersion());
172	}
173
174	/* (non-Javadoc)
175	* @see org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer#getContainerType()
176	*/
177	public int getContainerType() {
178	return IApiTypeContainer.COMPONENT;
179	}
180
181	/**
182	* Lazily creates a new {@link IApiFilterStore} when it is requested
183	*
184	* @return the current {@link IApiFilterStore} for this component
185	* @throws CoreException
186	*/
187	protected abstract IApiFilterStore createApiFilterStore() throws CoreException;
188	}

Lines 275-281 Link Here

(-)src/org/eclipse/pde/api/tools/internal/model/ApiBaseline.java (-11 / +11 lines)
275	getState().setPlatformProperties(dictionary);	275	getState().setPlatformProperties(dictionary);
276	// clean up previous system library	276	// clean up previous system library
277	if (fSystemLibraryComponent != null && fComponentsById != null) {	277	if (fSystemLibraryComponent != null && fComponentsById != null) {
278	fComponentsById.remove(fSystemLibraryComponent.getId());	278	fComponentsById.remove(fSystemLibraryComponent.getSymbolicName());
279	}	279	}
280	if(fSystemPackageNames != null) {	280	if(fSystemPackageNames != null) {
281	fSystemPackageNames.clear();	281	fSystemPackageNames.clear();
Lines 301-316 Link Here
301	* Adds an {@link IApiComponent} to the fComponentsById mapping	301	* Adds an {@link IApiComponent} to the fComponentsById mapping
302	* @param component	302	* @param component
303	*/	303	*/
304	private void addComponent(IApiComponent component) throws CoreException {	304	protected void addComponent(IApiComponent component) throws CoreException {
305	if(component == null) {	305	if(component == null) {
306	return;	306	return;
307	}	307	}
308	if(fComponentsById == null) {	308	if(fComponentsById == null) {
309	fComponentsById = new HashMap();	309	fComponentsById = new HashMap();
310	}	310	}
311	fComponentsById.put(component.getId(), component);	311	fComponentsById.put(component.getSymbolicName(), component);
312	if (component instanceof PluginProjectApiComponent) {	312	if (component instanceof ProjectComponent) {
313	PluginProjectApiComponent projectApiComponent = (PluginProjectApiComponent) component;	313	ProjectComponent projectApiComponent = (ProjectComponent) component;
314	if (this.fComponentsByProjectNames == null) {	314	if (this.fComponentsByProjectNames == null) {
315	this.fComponentsByProjectNames = new HashMap();	315	this.fComponentsByProjectNames = new HashMap();
316	}	316	}
Lines 324-330 Link Here
324	public void addApiComponents(IApiComponent[] components) throws CoreException {	324	public void addApiComponents(IApiComponent[] components) throws CoreException {
325	HashSet ees = new HashSet();	325	HashSet ees = new HashSet();
326	for (int i = 0; i < components.length; i++) {	326	for (int i = 0; i < components.length; i++) {
327	BundleApiComponent component = (BundleApiComponent) components[i];	327	BundleComponent component = (BundleComponent) components[i];
328	if (component.isSourceComponent()) {	328	if (component.isSourceComponent()) {
329	continue;	329	continue;
330	}	330	}
Lines 341-347 Link Here
341	* Resolves and initializes the system library to use based on API component requirements.	341	* Resolves and initializes the system library to use based on API component requirements.
342	* Only works when running in the framework. Has no effect if not running in the framework.	342	* Only works when running in the framework. Has no effect if not running in the framework.
343	*/	343	*/
344	private void resolveSystemLibrary(HashSet ees) {	344	protected void resolveSystemLibrary(HashSet ees) {
345	if (ApiPlugin.isRunningInFramework() && fAutoResolve) {	345	if (ApiPlugin.isRunningInFramework() && fAutoResolve) {
346	IStatus error = null;	346	IStatus error = null;
347	IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();	347	IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
Lines 526-533 Link Here
526	* @throws CoreException	526	* @throws CoreException
527	*/	527	*/
528	private void resolvePackage0(IApiComponent component, String packageName, List componentsList) throws CoreException {	528	private void resolvePackage0(IApiComponent component, String packageName, List componentsList) throws CoreException {
529	if (component instanceof BundleApiComponent) {	529	if (component instanceof BundleComponent) {
530	BundleDescription bundle = ((BundleApiComponent)component).getBundleDescription();	530	BundleDescription bundle = ((BundleComponent)component).getBundleDescription();
531	if (bundle != null) {	531	if (bundle != null) {
532	StateHelper helper = getState().getStateHelper();	532	StateHelper helper = getState().getStateHelper();
533	ExportPackageDescription[] visiblePackages = helper.getVisiblePackages(bundle);	533	ExportPackageDescription[] visiblePackages = helper.getVisiblePackages(bundle);
Lines 793-800 Link Here
793	ArrayList bundles = new ArrayList(components.length);	793	ArrayList bundles = new ArrayList(components.length);
794	for (int i = 0; i < components.length; i++) {	794	for (int i = 0; i < components.length; i++) {
795	IApiComponent component = components[i];	795	IApiComponent component = components[i];
796	if (component instanceof BundleApiComponent) {	796	if (component instanceof BundleComponent) {
797	bundles.add(((BundleApiComponent)component).getBundleDescription());	797	bundles.add(((BundleComponent)component).getBundleDescription());
798	}	798	}
799	}	799	}
800	return bundles;	800	return bundles;

Lines 117-123 Link Here

(-)src/org/eclipse/pde/api/tools/internal/model/ApiModelCache.java (-3 / +3 lines)
117	IApiComponent comp = element.getApiComponent();	117	IApiComponent comp = element.getApiComponent();
118	if(comp != null) {	118	if(comp != null) {
119	IApiBaseline baseline = comp.getBaseline();	119	IApiBaseline baseline = comp.getBaseline();
120	String id = comp.getId();	120	String id = comp.getSymbolicName();
121	if(id == null) {	121	if(id == null) {
122	return;	122	return;
123	}	123	}
Lines 129-135 Link Here
129	Cache typecache = (Cache) compcache.get(id);	129	Cache typecache = (Cache) compcache.get(id);
130	if(typecache == null) {	130	if(typecache == null) {
131	typecache = new Cache(DEFAULT_CACHE_SIZE, DEFAULT_OVERFLOW);	131	typecache = new Cache(DEFAULT_CACHE_SIZE, DEFAULT_OVERFLOW);
132	compcache.put(comp.getId(), typecache);	132	compcache.put(comp.getSymbolicName(), typecache);
133	}	133	}
134	ApiType type = (ApiType) element;	134	ApiType type = (ApiType) element;
135	if(type.isMemberType() \|\| isMemberType(type.getName()) /cache even a root type with a '$' in its name here as well/) {	135	if(type.isMemberType() \|\| isMemberType(type.getName()) /cache even a root type with a '$' in its name here as well/) {
Lines 314-320 Link Here
314	if(comp != null) {	314	if(comp != null) {
315	try {	315	try {
316	IApiBaseline baseline = comp.getBaseline();	316	IApiBaseline baseline = comp.getBaseline();
317	return removeElementInfo(baseline.getName(), comp.getId(), element.getName(), element.getType());	317	return removeElementInfo(baseline.getName(), comp.getSymbolicName(), element.getName(), element.getType());
318	}	318	}
319	catch(CoreException ce) {}	319	catch(CoreException ce) {}
320	}	320	}

Added Link Here

(-)src/org/eclipse/pde/api/tools/internal/model/WorkspaceBaseline.java (+59 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 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.pde.api.tools.internal.model;
12
13	import java.util.Arrays;
14	import java.util.HashSet;
15
16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.osgi.service.resolver.State;
18	import org.eclipse.pde.api.tools.internal.ApiBaselineManager;
19	import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
20	import org.eclipse.pde.internal.core.PDECore;
21
22
23	/**
24	* Describes the workspace baseline. Tracks the PDE model for the workspace
25	*
26	* @since 1.1
27	*/
28	public class WorkspaceBaseline extends ApiBaseline {
29
30	/**
31	* Constructor
32	*/
33	public WorkspaceBaseline() {
34	super(ApiBaselineManager.WORKSPACE_API_BASELINE_ID);
35	}
36
37	/* (non-Javadoc)
38	* @see org.eclipse.pde.api.tools.internal.model.ApiBaseline#getState()
39	*/
40	public State getState() {
41	return PDECore.getDefault().getModelManager().getState().getState();
42	}
43
44	/* (non-Javadoc)
45	* @see IApiBaseline#addApiComponents(org.eclipse.pde.api.tools.model.component.IApiComponent[], boolean)
46	*/
47	public void addApiComponents(IApiComponent[] components) throws CoreException {
48	HashSet ees = new HashSet();
49	for (int i = 0; i < components.length; i++) {
50	BundleComponent component = (BundleComponent) components[i];
51	if (component.isSourceComponent()) {
52	continue;
53	}
54	addComponent(component);
55	ees.addAll(Arrays.asList(component.getExecutionEnvironments()));
56	}
57	resolveSystemLibrary(ees);
58	}
59	}

Lines 598-604 Link Here

(-)src_ant/org/eclipse/pde/api/tools/internal/tasks/APIToolsAnalysisTask.java (-2 / +2 lines)
598	Set visitedApiComponentNames = new HashSet();	598	Set visitedApiComponentNames = new HashSet();
599	for (int i = 0; i < length; i++) {	599	for (int i = 0; i < length; i++) {
600	IApiComponent apiComponent = apiComponents[i];	600	IApiComponent apiComponent = apiComponents[i];
601	String name = apiComponent.getId();	601	String name = apiComponent.getSymbolicName();
602	visitedApiComponentNames.add(name);	602	visitedApiComponentNames.add(name);
603	if (apiComponent.isSystemComponent()) {	603	if (apiComponent.isSystemComponent()) {
604	continue;	604	continue;
Lines 644-650 Link Here
644	IApiComponent[] baselineApiComponents = referenceBaseline.getApiComponents();	644	IApiComponent[] baselineApiComponents = referenceBaseline.getApiComponents();
645	for (int i = 0, max = baselineApiComponents.length; i < max; i++) {	645	for (int i = 0, max = baselineApiComponents.length; i < max; i++) {
646	IApiComponent apiComponent = baselineApiComponents[i];	646	IApiComponent apiComponent = baselineApiComponents[i];
647	String id = apiComponent.getId();	647	String id = apiComponent.getSymbolicName();
648	if (!visitedApiComponentNames.remove(id)) {	648	if (!visitedApiComponentNames.remove(id)) {
649	//remove component in the current baseline	649	//remove component in the current baseline
650	IApiProblem problem = ApiProblemFactory.newApiProblem(id,	650	IApiProblem problem = ApiProblemFactory.newApiProblem(id,

Lines 148-154 Link Here

(-)src/org/eclipse/pde/api/tools/model/tests/ApiBaselineTests.java (-3 / +3 lines)
148	private void validateComponent(IApiBaseline baseline, String id, String name, String version, String environment, List<IRequiredComponentDescription> requiredComponents) throws CoreException {	148	private void validateComponent(IApiBaseline baseline, String id, String name, String version, String environment, List<IRequiredComponentDescription> requiredComponents) throws CoreException {
149	IApiComponent component = baseline.getApiComponent(id);	149	IApiComponent component = baseline.getApiComponent(id);
150		150
151	assertEquals("Id: ", id , component.getId());	151	assertEquals("Id: ", id , component.getSymbolicName());
152	assertEquals("Name: ", name , component.getName());	152	assertEquals("Name: ", name , component.getName());
153	assertEquals("Version: ", version , component.getVersion());	153	assertEquals("Version: ", version , component.getVersion());
154	String[] envs = component.getExecutionEnvironments();	154	String[] envs = component.getExecutionEnvironments();
Lines 273-279 Link Here
273	IApiComponent[] prerequisiteComponents = baseline.getPrerequisiteComponents(new IApiComponent[]{component});	273	IApiComponent[] prerequisiteComponents = baseline.getPrerequisiteComponents(new IApiComponent[]{component});
274	for (int i = 0; i < prerequisiteComponents.length; i++) {	274	for (int i = 0; i < prerequisiteComponents.length; i++) {
275	IApiComponent apiComponent = prerequisiteComponents[i];	275	IApiComponent apiComponent = prerequisiteComponents[i];
276	if (apiComponent.getId().equals("org.eclipse.osgi")) {	276	if (apiComponent.getSymbolicName().equals("org.eclipse.osgi")) {
277	// done	277	// done
278	return;	278	return;
279	}	279	}
Lines 293-299 Link Here
293	assertEquals("Wrong number of dependents", 2, dependents.length);	293	assertEquals("Wrong number of dependents", 2, dependents.length);
294	for (int i = 0; i < dependents.length; i++) {	294	for (int i = 0; i < dependents.length; i++) {
295	IApiComponent apiComponent = dependents[i];	295	IApiComponent apiComponent = dependents[i];
296	if (apiComponent.getId().equals("component.b")) {	296	if (apiComponent.getSymbolicName().equals("component.b")) {
297	// done	297	// done
298	return;	298	return;
299	}	299	}

Lines 25-31 Link Here

(-)src/org/eclipse/pde/api/tools/ui/internal/markers/RemoveFilterProblemResolution.java (-2 / +2 lines)
25	import org.eclipse.core.runtime.SubMonitor;	25	import org.eclipse.core.runtime.SubMonitor;
26	import org.eclipse.osgi.util.NLS;	26	import org.eclipse.osgi.util.NLS;
27	import org.eclipse.pde.api.tools.internal.ApiBaselineManager;	27	import org.eclipse.pde.api.tools.internal.ApiBaselineManager;
28	import org.eclipse.pde.api.tools.internal.model.PluginProjectApiComponent;	28	import org.eclipse.pde.api.tools.internal.model.ProjectComponent;
29	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;	29	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
30	import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;	30	import org.eclipse.pde.api.tools.internal.provisional.IApiFilterStore;
31	import org.eclipse.pde.api.tools.internal.provisional.IApiMarkerConstants;	31	import org.eclipse.pde.api.tools.internal.provisional.IApiMarkerConstants;
Lines 108-114 Link Here
108	}	108	}
109	resource = markers[i].getResource();	109	resource = markers[i].getResource();
110	component = ApiBaselineManager.getManager().getWorkspaceBaseline().getApiComponent(resource.getProject());	110	component = ApiBaselineManager.getManager().getWorkspaceBaseline().getApiComponent(resource.getProject());
111	if(component instanceof PluginProjectApiComponent) {	111	if(component instanceof ProjectComponent) {
112	filters = (HashSet) map.get(component);	112	filters = (HashSet) map.get(component);
113	if(filters == null) {	113	if(filters == null) {
114	filters = new HashSet();	114	filters = new HashSet();