update/org.eclipse.update.core/src/org/eclipse/update/internal/search/UpdatesSearchCategory.java - platform/eclipse.platform - Git at Google

 /*******************************************************************************
  *  Copyright (c) 2000, 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.update.internal.search;

 import java.util.ArrayList;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.PluginVersionIdentifier;
 import org.eclipse.core.runtime.Preferences;
 import org.eclipse.update.configuration.IConfiguredSite;
 import org.eclipse.update.configuration.IInstallConfiguration;
 import org.eclipse.update.configuration.ILocalSite;
 import org.eclipse.update.core.IFeature;
 import org.eclipse.update.core.IFeatureReference;
 import org.eclipse.update.core.IIncludedFeatureReference;
 import org.eclipse.update.core.ISite;
 import org.eclipse.update.core.ISiteFeatureReference;
 import org.eclipse.update.core.IURLEntry;
 import org.eclipse.update.core.IUpdateConstants;
 import org.eclipse.update.core.SiteManager;
 import org.eclipse.update.core.VersionedIdentifier;
 import org.eclipse.update.internal.core.Messages;
 import org.eclipse.update.internal.core.UpdateCore;
 import org.eclipse.update.internal.operations.FeatureHierarchyElement;
 import org.eclipse.update.internal.operations.UpdateUtils;
 import org.eclipse.update.operations.IInstallFeatureOperation;
 import org.eclipse.update.operations.OperationsManager;
 import org.eclipse.update.search.IQueryUpdateSiteAdapter;
 import org.eclipse.update.search.IUpdateSearchFilter;
 import org.eclipse.update.search.IUpdateSearchQuery;
 import org.eclipse.update.search.IUpdateSearchResultCollector;

 public class UpdatesSearchCategory extends BaseSearchCategory {
 	private static final String CATEGORY_ID =
 		"org.eclipse.update.core.new-updates"; //$NON-NLS-1$
 	private IFeature [] features;
 	private boolean automatic;

 	class Candidate {
 		ArrayList children;
 		Candidate parent;
 		IFeatureReference ref;
 		public Candidate(IFeatureReference ref) {
 			this.ref = ref;
 		}
 		public Candidate(IFeatureReference ref, Candidate parent) {
 			this(ref);
 			this.parent = parent;
 		}
 		public void add(Candidate child) {
 			if (children == null)
 				children = new ArrayList();
 			child.setParent(this);
 			children.add(child);
 		}
 		void setParent(Candidate parent) {
 			this.parent = parent;
 		}
 		public IFeatureReference getReference() {
 			return ref;
 		}
 		void setReference(IFeatureReference ref) {
 			this.ref = ref;
 		}
 		public IFeature getFeature(IProgressMonitor monitor) {
 			try {
 				return ref.getFeature(monitor);
 			} catch (CoreException e) {
 				return null;
 			}
 		}
 		public Candidate getParent() {
 			return parent;
 		}
 		public Candidate getRoot() {
 			Candidate root = this;

 			while (root.getParent() != null) {
 				root = root.getParent();
 			}
 			return root;
 		}
 		public IURLEntry getUpdateEntry() {
 			int location = IUpdateConstants.SEARCH_ROOT;

 			if (ref instanceof IIncludedFeatureReference)
 				location =
 					((IIncludedFeatureReference) ref).getSearchLocation();
 			if (parent == null || location == IUpdateConstants.SEARCH_SELF) {
 				return getFeature(null).getUpdateSiteEntry();
 			}
 			return getRoot().getUpdateEntry();
 		}
 		public String toString() {
 			return ref.toString();
 		}
 		public boolean equals(Object source) {
 			if (source instanceof Candidate) {
 				return this.ref.equals(((Candidate) source).getReference());
 			}
 			if (source instanceof IFeatureReference) {
 				return this.ref.equals(source);
 			}
 			return false;
 		}
 		public void addToFlatList(ArrayList list, boolean updatableOnly) {
 			// add itself
 			if (!updatableOnly || isUpdatable())
 				list.add(this);
 			// add children
 			if (children != null) {
 				for (int i = 0; i < children.size(); i++) {
 					Candidate child = (Candidate) children.get(i);
 					child.addToFlatList(list, updatableOnly);
 				}
 			}
 		}
 		public boolean isUpdatable() {
 			return (parent == null);
 		}
 	}

 	private static class Hit {
 		IFeatureReference ref;
 		IInstallFeatureOperation patchFor;
 		boolean patch;
 		IInstallFeatureOperation job;

 		public Hit(IFeature candidate, IFeatureReference ref) {
 			this.ref = ref;
 		}
 		public Hit(IFeature candidate, IFeatureReference ref, boolean patch) {
 			this(candidate, ref);
 			this.patch = patch;
 		}

 		public Hit(IFeature candidate, IFeatureReference ref, IInstallFeatureOperation patchFor) {
 			this(candidate, ref, true);
 			this.patchFor = patchFor;
 		}

 		public IInstallFeatureOperation getJob() {
 			if (job == null) {
 				try {
 					IFeature feature = ref.getFeature(null);
 					job = OperationsManager.getOperationFactory().createInstallOperation(null, feature, null, null, null);
 				} catch (CoreException e) {
 					UpdateCore.log(e);
 				}
 			}
 			return job;
 		}

 		public boolean isPatch() {
 			return patch;
 		}
 		public IInstallFeatureOperation getPatchedJob() {
 			return patchFor;
 		}
 	}

 	public class UpdateQuery implements IUpdateSearchQuery {
 		IFeature candidate;
 		IQueryUpdateSiteAdapter adapter;

 		public UpdateQuery(
 			IFeature candidate,
 			IURLEntry updateEntry) {
 			this.candidate = candidate;
 			if (updateEntry != null && updateEntry.getURL() != null)
 				adapter =
 					new QueryUpdateSiteAdapter(
 						getLabelForEntry(updateEntry),
 						updateEntry.getURL(),
 						candidate.getVersionedIdentifier().getIdentifier());
 		}
 		private String getLabelForEntry(IURLEntry entry) {
 			String label = entry.getAnnotation();
 			if (label == null || label.length() == 0)
 				label = entry.getURL().toString();
 			return label;
 		}

 		public IQueryUpdateSiteAdapter getQuerySearchSite() {
 			return adapter;
 		}
 		private boolean isBroken() {
 			try {
 				IStatus status =
 					SiteManager.getLocalSite().getFeatureStatus(candidate);
 				return status.getSeverity() == IStatus.ERROR;
 			} catch (CoreException e) {
 				return false;
 			}
 		}
 		private boolean isMissingOptionalChildren(IFeature feature) {
 			try {
 				IIncludedFeatureReference[] children =
 					feature.getIncludedFeatureReferences();
 				for (int i = 0; i < children.length; i++) {
 					IIncludedFeatureReference ref = children[i];
 					try {
 						IFeature child = ref.getFeature(null);
 						// If we are here, the child is not missing.
 						// Check it's children recursively.
 						if (isMissingOptionalChildren(child))
 							return true;
 					} catch (CoreException e) {
 						// Missing child. Return true if optional,
 						// otherwise it is a broken feature that we
 						// do not care about.
 						if (ref.isOptional()) {
 							return FeatureHierarchyElement.hasOlderVersion(ref);
 						}
 					}
 				}
 			} catch (CoreException e) {
 			}
 			return false;
 		}
 		public void run(
 			ISite site,
 			String[] categoriesToSkip,
 			IUpdateSearchFilter filter,
 			IUpdateSearchResultCollector collector,
 			IProgressMonitor monitor) {
 			ArrayList hits = new ArrayList();
 			boolean broken = isBroken();
 			boolean missingOptionalChildren = false;

 			// Don't bother to compute missing optional children
 			// if the feature is broken - all we want is to
 			// see if we should allow same-version re-install.
 			if (!broken)
 				missingOptionalChildren = isMissingOptionalChildren(candidate);
 			ISiteFeatureReference[] refs = site.getFeatureReferences();
 			monitor.beginTask("", refs.length + 1); //$NON-NLS-1$
 			ArrayList updateJobs = new ArrayList();
 			for (int i = 0; i < refs.length; i++) {
 				ISiteFeatureReference ref = refs[i];
 				try {
 					if (isNewerVersion(candidate.getVersionedIdentifier(),ref.getVersionedIdentifier())) {
 						Hit h = new Hit(candidate, ref);
 						hits.add(h);
 						IInstallFeatureOperation job = h.getJob();
 						if (job != null)
 							updateJobs.add(job);
 					} else {
 						// accept the same feature if the installed
 						// feature is broken
 						if ((broken || missingOptionalChildren)
 							&& candidate.getVersionedIdentifier().equals(
 								ref.getVersionedIdentifier())){
 							hits.add(new Hit(candidate, ref));
 							continue;
 						}
 						else {
 							// check for patches
 							if (isPatch(candidate, ref)){
 								hits.add(new Hit(candidate, ref, true));
 								continue;
 							}
 						}
 					}
 				} catch (CoreException e) {
 				}
 				monitor.worked(1);
 				if (monitor.isCanceled()){
 					return;
 				}

 			}
 			// accept patches for updated features
 			for (int n = 0; n < updateJobs.size(); n++) {
 				IInstallFeatureOperation job = (IInstallFeatureOperation) updateJobs
 						.get(n);
 					IFeature newCandidate = job.getFeature();
 					for (int i = 0; i < refs.length; i++) {
 						ISiteFeatureReference ref = refs[i];
 						if (isPatch(newCandidate, ref)) {
 							Hit h = new Hit(newCandidate, ref, job);
 							hits.add(h);
 							continue;
 						}
 						//monitor.worked(1);
 						if (monitor.isCanceled()) {
 							return;
 						}
 					}
 			}
 			if (hits.size() > 0) {
 				collectValidHits(hits, filter, collector);
 			}
 			monitor.worked(1);
 			monitor.done();
 		}

 		/**
 		 * Returns IFeature associated with the IUpdateSearchQuery
 		 */
 		public IFeature getFeature() {
 			return candidate;
 		}
 	}

 	private ArrayList candidates;

 	public UpdatesSearchCategory() {
 		this(true);
 	}

 	public UpdatesSearchCategory(boolean automatic) {
 		super(CATEGORY_ID);
 		this.automatic = automatic;
 	}

 	private void collectValidHits(
 		ArrayList hits,
 		IUpdateSearchFilter filter,
 		IUpdateSearchResultCollector collector) {
 		//Object[] array = hits.toArray();
 		IFeature topHit = null;
 		for (int i = 0; i < hits.size(); i++) {
 			Hit hit = (Hit) hits.get(i);
 			IInstallFeatureOperation job = hit.getJob();
 			if (job == null)
 				continue;
 			// do not accept updates without a license
 			if (!UpdateUtils.hasLicense(job.getFeature())) {
 				UpdateCore.log(job.getFeature().getVersionedIdentifier() + ": " + Messages.DefaultFeatureParser_NoLicenseText, null);  //$NON-NLS-1$
 				continue;
 			}
 			IStatus status = null;

 			// Fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=132450
 			// Only validate for automatic updates because
 			// non-automatic once will arrive in the review wizard
 			// where additional validation will be performed
 			if (automatic) {
 				if( hit.getPatchedJob()==null){
 					status = OperationsManager.getValidator().validatePendingInstall(job.getOldFeature(), job.getFeature());
 				}else{
 					status = OperationsManager.getValidator().validatePendingChanges(new IInstallFeatureOperation[]{hit.getPatchedJob(), job});
 				}
 			}
 			if (status == null || status.getCode() == IStatus.WARNING) {
 				if (hit.isPatch()) {
 					IFeature patch = job.getFeature();
 					// Do not add the patch if already installed
 					IFeature[] sameId = UpdateUtils.getInstalledFeatures(patch, false);
 					if (sameId.length==0) {
 						if (filter.accept(patch))
 							collector.accept(patch);
 					}
 				}
 				else  {
 					topHit = job.getFeature();
 					if (filter.accept(topHit))
 						collector.accept(topHit);
 				}
 			}
 		}
 	}

 	private void initialize() {
 		candidates = new ArrayList();
 		try {
 			ILocalSite localSite = SiteManager.getLocalSite();
 			IInstallConfiguration config = localSite.getCurrentConfiguration();
 			IConfiguredSite[] isites = config.getConfiguredSites();
 			for (int i = 0; i < isites.length; i++) {
 				contributeCandidates(isites[i]);
 			}
 		} catch (CoreException e) {
 			UpdateCore.log(
 				Messages.UpdatesSearchCategory_errorSearchingForUpdates,
 				e);
 		}
 	}

 	private void contributeCandidates(IConfiguredSite isite)
 		throws CoreException {
 		IFeatureReference[] refs = isite.getConfiguredFeatures();
 		ArrayList candidatesPerSite = new ArrayList();
 		for (int i = 0; i < refs.length; i++) {
 			IFeatureReference ref = refs[i];
 			// Don't waste time searching for updates to
 			// patches.
 			try {
 				if (UpdateUtils.isPatch(ref.getFeature(null)))
 					continue;
 			}
 			catch (CoreException e) {
 				continue;
 			}
 			Candidate c = new Candidate(ref);
 			candidatesPerSite.add(c);
 		}
 		// Create a tree from a flat list
 		buildHierarchy(candidatesPerSite);
 		// Add the remaining root candidates to
 		// the global list of candidates.
 		candidates.addAll(candidatesPerSite);
 	}

 	private void buildHierarchy(ArrayList candidates) throws CoreException {
 		Candidate[] array =
 			(Candidate[]) candidates.toArray(new Candidate[candidates.size()]);
 		// filter out included features so that only top-level features remain on the list
 		for (int i = 0; i < array.length; i++) {
 			Candidate parent = array[i];
 			IFeature feature = parent.getFeature(null);
 			IFeatureReference[] included =
 				feature.getIncludedFeatureReferences();
 			for (int j = 0; j < included.length; j++) {
 				IFeatureReference fref = included[j];
 				Candidate child = findCandidate(candidates, fref);
 				if (child != null) {
 					parent.add(child);
 					child.setReference(fref);
 					candidates.remove(child);
 				}
 			}
 		}
 	}
 	private Candidate findCandidate(ArrayList list, IFeatureReference ref) {
 		for (int i = 0; i < list.size(); i++) {
 			Candidate c = (Candidate) list.get(i);
 			if (c.ref.equals(ref))
 				return c;
 		}
 		return null;
 	}

 	public IUpdateSearchQuery[] getQueries() {
 		initialize();
 		ArrayList allCandidates = getAllCandidates();

 		IUpdateSearchQuery[] queries =
 			new IUpdateSearchQuery[allCandidates.size()];
 		for (int i = 0; i < queries.length; i++) {
 			Candidate candidate = (Candidate) allCandidates.get(i);
 			IFeature feature = candidate.getFeature(null);
 			IURLEntry updateEntry = candidate.getUpdateEntry();
 			if (feature == null) {
 				queries[i] = null;
 			} else {
 				queries[i] = new UpdateQuery(feature, updateEntry);
 			}
 		}
 		return queries;
 	}

 /**
  * Sets the features for which new updates need to be found. If
  * not set, updates will be searched for all the installed
  * and configured features.
  * @param features the features to search updates for
  */
 	public void setFeatures(IFeature [] features) {
 		this.features = features;
 	}

 /**
  * Returns an array of features for which updates need to
  * be found.
  * @return an array of features or <samp>null</samp> if not
  * set.
  */
 	public IFeature [] getFeatures() {
 		return features;
 	}
 	/**
 	 * @param fvi
 	 * @param cvi
 	 * @return fvi < cvi
 	 */
 	private boolean isNewerVersion(
 		VersionedIdentifier fvi,
 		VersionedIdentifier cvi) {
 		if (!fvi.getIdentifier().equals(cvi.getIdentifier()))
 			return false;
 		PluginVersionIdentifier fv = fvi.getVersion();
 		PluginVersionIdentifier cv = cvi.getVersion();
 		String mode = getUpdateVersionsMode();
 		boolean greater = cv.isGreaterThan(fv);
 		if (!greater)
 			return false;
 		if (mode.equals(UpdateCore.EQUIVALENT_VALUE))
 			return cv.isEquivalentTo(fv);
 		else if (mode.equals(UpdateCore.COMPATIBLE_VALUE))
 			return cv.isCompatibleWith(fv);
 		else
 			return false;
 	}

 	private boolean isPatch(IFeature candidate, ISiteFeatureReference ref) {
 		if (ref.isPatch() == false)
 			return false;
 		try {
 			IFeature feature = ref.getFeature(null);
 			if( UpdateUtils.isPatch(candidate, feature))
 				return true;
 			// Check if patch is for children
 			try {
 				IIncludedFeatureReference[] children =
 					candidate.getIncludedFeatureReferences();
 				for (int i = 0; i < children.length; i++) {
 					IIncludedFeatureReference cref = children[i];
 					try {
 						IFeature child = cref.getFeature(null);
 						if (isPatch(child, ref))
 							return true;
 					} catch (CoreException e) {
 					}
 				}
 			} catch (CoreException e) {
 			}
 			return false;
 		} catch (CoreException e) {
 			return false;
 		}
 	}

 	private String getUpdateVersionsMode() {
 		Preferences store = UpdateCore.getPlugin().getPluginPreferences();
 		return store.getString(UpdateCore.P_UPDATE_VERSIONS);
 	}
 /*
  * This method recursively walks the list of candidates
  * building the flat that starts with the roots but
  * also includes all the children that are updatable
  * (use 'include' clause with a match that is not 'perfect').
  */
 	private ArrayList getAllCandidates() {
 		ArrayList selected = new ArrayList();
 		for (int i=0; i<candidates.size(); i++) {
 			Candidate c = (Candidate)candidates.get(i);
 			if (isOnTheList(c))
 				c.addToFlatList(selected, true);
 		}
 		return selected;
 	}

 	private boolean isOnTheList(Candidate c) {
 		if (features==null) return true;
 		VersionedIdentifier vid;
 		try {
 			vid = c.getReference().getVersionedIdentifier();
 		}
 		catch (CoreException e) {
 			return false;
 		}
 		for (int i=0; i<features.length; i++) {
 			IFeature feature = features[i];
 			VersionedIdentifier fvid = feature.getVersionedIdentifier();
 			if (fvid.equals(vid))
 				return true;
 		}
 		return false;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 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.update.internal.search;

	import java.util.ArrayList;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.PluginVersionIdentifier;
	import org.eclipse.core.runtime.Preferences;
	import org.eclipse.update.configuration.IConfiguredSite;
	import org.eclipse.update.configuration.IInstallConfiguration;
	import org.eclipse.update.configuration.ILocalSite;
	import org.eclipse.update.core.IFeature;
	import org.eclipse.update.core.IFeatureReference;
	import org.eclipse.update.core.IIncludedFeatureReference;
	import org.eclipse.update.core.ISite;
	import org.eclipse.update.core.ISiteFeatureReference;
	import org.eclipse.update.core.IURLEntry;
	import org.eclipse.update.core.IUpdateConstants;
	import org.eclipse.update.core.SiteManager;
	import org.eclipse.update.core.VersionedIdentifier;
	import org.eclipse.update.internal.core.Messages;
	import org.eclipse.update.internal.core.UpdateCore;
	import org.eclipse.update.internal.operations.FeatureHierarchyElement;
	import org.eclipse.update.internal.operations.UpdateUtils;
	import org.eclipse.update.operations.IInstallFeatureOperation;
	import org.eclipse.update.operations.OperationsManager;
	import org.eclipse.update.search.IQueryUpdateSiteAdapter;
	import org.eclipse.update.search.IUpdateSearchFilter;
	import org.eclipse.update.search.IUpdateSearchQuery;
	import org.eclipse.update.search.IUpdateSearchResultCollector;

	public class UpdatesSearchCategory extends BaseSearchCategory {
	private static final String CATEGORY_ID =
	"org.eclipse.update.core.new-updates"; //$NON-NLS-1$
	private IFeature [] features;
	private boolean automatic;

	class Candidate {
	ArrayList children;
	Candidate parent;
	IFeatureReference ref;
	public Candidate(IFeatureReference ref) {
	this.ref = ref;
	}
	public Candidate(IFeatureReference ref, Candidate parent) {
	this(ref);
	this.parent = parent;
	}
	public void add(Candidate child) {
	if (children == null)
	children = new ArrayList();
	child.setParent(this);
	children.add(child);
	}
	void setParent(Candidate parent) {
	this.parent = parent;
	}
	public IFeatureReference getReference() {
	return ref;
	}
	void setReference(IFeatureReference ref) {
	this.ref = ref;
	}
	public IFeature getFeature(IProgressMonitor monitor) {
	try {
	return ref.getFeature(monitor);
	} catch (CoreException e) {
	return null;
	}
	}
	public Candidate getParent() {
	return parent;
	}
	public Candidate getRoot() {
	Candidate root = this;

	while (root.getParent() != null) {
	root = root.getParent();
	}
	return root;
	}
	public IURLEntry getUpdateEntry() {
	int location = IUpdateConstants.SEARCH_ROOT;

	if (ref instanceof IIncludedFeatureReference)
	location =
	((IIncludedFeatureReference) ref).getSearchLocation();
	if (parent == null \|\| location == IUpdateConstants.SEARCH_SELF) {
	return getFeature(null).getUpdateSiteEntry();
	}
	return getRoot().getUpdateEntry();
	}
	public String toString() {
	return ref.toString();
	}
	public boolean equals(Object source) {
	if (source instanceof Candidate) {
	return this.ref.equals(((Candidate) source).getReference());
	}
	if (source instanceof IFeatureReference) {
	return this.ref.equals(source);
	}
	return false;
	}
	public void addToFlatList(ArrayList list, boolean updatableOnly) {
	// add itself
	if (!updatableOnly \|\| isUpdatable())
	list.add(this);
	// add children
	if (children != null) {
	for (int i = 0; i < children.size(); i++) {
	Candidate child = (Candidate) children.get(i);
	child.addToFlatList(list, updatableOnly);
	}
	}
	}
	public boolean isUpdatable() {
	return (parent == null);
	}
	}

	private static class Hit {
	IFeatureReference ref;
	IInstallFeatureOperation patchFor;
	boolean patch;
	IInstallFeatureOperation job;

	public Hit(IFeature candidate, IFeatureReference ref) {
	this.ref = ref;
	}
	public Hit(IFeature candidate, IFeatureReference ref, boolean patch) {
	this(candidate, ref);
	this.patch = patch;
	}

	public Hit(IFeature candidate, IFeatureReference ref, IInstallFeatureOperation patchFor) {
	this(candidate, ref, true);
	this.patchFor = patchFor;
	}

	public IInstallFeatureOperation getJob() {
	if (job == null) {
	try {
	IFeature feature = ref.getFeature(null);
	job = OperationsManager.getOperationFactory().createInstallOperation(null, feature, null, null, null);
	} catch (CoreException e) {
	UpdateCore.log(e);
	}
	}
	return job;
	}

	public boolean isPatch() {
	return patch;
	}
	public IInstallFeatureOperation getPatchedJob() {
	return patchFor;
	}
	}

	public class UpdateQuery implements IUpdateSearchQuery {
	IFeature candidate;
	IQueryUpdateSiteAdapter adapter;

	public UpdateQuery(
	IFeature candidate,
	IURLEntry updateEntry) {
	this.candidate = candidate;
	if (updateEntry != null && updateEntry.getURL() != null)
	adapter =
	new QueryUpdateSiteAdapter(
	getLabelForEntry(updateEntry),
	updateEntry.getURL(),
	candidate.getVersionedIdentifier().getIdentifier());
	}
	private String getLabelForEntry(IURLEntry entry) {
	String label = entry.getAnnotation();
	if (label == null \|\| label.length() == 0)
	label = entry.getURL().toString();
	return label;
	}

	public IQueryUpdateSiteAdapter getQuerySearchSite() {
	return adapter;
	}
	private boolean isBroken() {
	try {
	IStatus status =
	SiteManager.getLocalSite().getFeatureStatus(candidate);
	return status.getSeverity() == IStatus.ERROR;
	} catch (CoreException e) {
	return false;
	}
	}
	private boolean isMissingOptionalChildren(IFeature feature) {
	try {
	IIncludedFeatureReference[] children =
	feature.getIncludedFeatureReferences();
	for (int i = 0; i < children.length; i++) {
	IIncludedFeatureReference ref = children[i];
	try {
	IFeature child = ref.getFeature(null);
	// If we are here, the child is not missing.
	// Check it's children recursively.
	if (isMissingOptionalChildren(child))
	return true;
	} catch (CoreException e) {
	// Missing child. Return true if optional,
	// otherwise it is a broken feature that we
	// do not care about.
	if (ref.isOptional()) {
	return FeatureHierarchyElement.hasOlderVersion(ref);
	}
	}
	}
	} catch (CoreException e) {
	}
	return false;
	}
	public void run(
	ISite site,
	String[] categoriesToSkip,
	IUpdateSearchFilter filter,
	IUpdateSearchResultCollector collector,
	IProgressMonitor monitor) {
	ArrayList hits = new ArrayList();
	boolean broken = isBroken();
	boolean missingOptionalChildren = false;

	// Don't bother to compute missing optional children
	// if the feature is broken - all we want is to
	// see if we should allow same-version re-install.
	if (!broken)
	missingOptionalChildren = isMissingOptionalChildren(candidate);
	ISiteFeatureReference[] refs = site.getFeatureReferences();
	monitor.beginTask("", refs.length + 1); //$NON-NLS-1$
	ArrayList updateJobs = new ArrayList();
	for (int i = 0; i < refs.length; i++) {
	ISiteFeatureReference ref = refs[i];
	try {
	if (isNewerVersion(candidate.getVersionedIdentifier(),ref.getVersionedIdentifier())) {
	Hit h = new Hit(candidate, ref);
	hits.add(h);
	IInstallFeatureOperation job = h.getJob();
	if (job != null)
	updateJobs.add(job);
	} else {
	// accept the same feature if the installed
	// feature is broken
	if ((broken \|\| missingOptionalChildren)
	&& candidate.getVersionedIdentifier().equals(
	ref.getVersionedIdentifier())){
	hits.add(new Hit(candidate, ref));
	continue;
	}
	else {
	// check for patches
	if (isPatch(candidate, ref)){
	hits.add(new Hit(candidate, ref, true));
	continue;
	}
	}
	}
	} catch (CoreException e) {
	}
	monitor.worked(1);
	if (monitor.isCanceled()){
	return;
	}

	}
	// accept patches for updated features
	for (int n = 0; n < updateJobs.size(); n++) {
	IInstallFeatureOperation job = (IInstallFeatureOperation) updateJobs
	.get(n);
	IFeature newCandidate = job.getFeature();
	for (int i = 0; i < refs.length; i++) {
	ISiteFeatureReference ref = refs[i];
	if (isPatch(newCandidate, ref)) {
	Hit h = new Hit(newCandidate, ref, job);
	hits.add(h);
	continue;
	}
	//monitor.worked(1);
	if (monitor.isCanceled()) {
	return;
	}
	}
	}
	if (hits.size() > 0) {
	collectValidHits(hits, filter, collector);
	}
	monitor.worked(1);
	monitor.done();
	}

	/**
	* Returns IFeature associated with the IUpdateSearchQuery
	*/
	public IFeature getFeature() {
	return candidate;
	}
	}

	private ArrayList candidates;

	public UpdatesSearchCategory() {
	this(true);
	}

	public UpdatesSearchCategory(boolean automatic) {
	super(CATEGORY_ID);
	this.automatic = automatic;
	}

	private void collectValidHits(
	ArrayList hits,
	IUpdateSearchFilter filter,
	IUpdateSearchResultCollector collector) {
	//Object[] array = hits.toArray();
	IFeature topHit = null;
	for (int i = 0; i < hits.size(); i++) {
	Hit hit = (Hit) hits.get(i);
	IInstallFeatureOperation job = hit.getJob();
	if (job == null)
	continue;
	// do not accept updates without a license
	if (!UpdateUtils.hasLicense(job.getFeature())) {
	UpdateCore.log(job.getFeature().getVersionedIdentifier() + ": " + Messages.DefaultFeatureParser_NoLicenseText, null); //$NON-NLS-1$
	continue;
	}
	IStatus status = null;

	// Fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=132450
	// Only validate for automatic updates because
	// non-automatic once will arrive in the review wizard
	// where additional validation will be performed
	if (automatic) {
	if( hit.getPatchedJob()==null){
	status = OperationsManager.getValidator().validatePendingInstall(job.getOldFeature(), job.getFeature());
	}else{
	status = OperationsManager.getValidator().validatePendingChanges(new IInstallFeatureOperation[]{hit.getPatchedJob(), job});
	}
	}
	if (status == null \|\| status.getCode() == IStatus.WARNING) {
	if (hit.isPatch()) {
	IFeature patch = job.getFeature();
	// Do not add the patch if already installed
	IFeature[] sameId = UpdateUtils.getInstalledFeatures(patch, false);
	if (sameId.length==0) {
	if (filter.accept(patch))
	collector.accept(patch);
	}
	}
	else {
	topHit = job.getFeature();
	if (filter.accept(topHit))
	collector.accept(topHit);
	}
	}
	}
	}

	private void initialize() {
	candidates = new ArrayList();
	try {
	ILocalSite localSite = SiteManager.getLocalSite();
	IInstallConfiguration config = localSite.getCurrentConfiguration();
	IConfiguredSite[] isites = config.getConfiguredSites();
	for (int i = 0; i < isites.length; i++) {
	contributeCandidates(isites[i]);
	}
	} catch (CoreException e) {
	UpdateCore.log(
	Messages.UpdatesSearchCategory_errorSearchingForUpdates,
	e);
	}
	}

	private void contributeCandidates(IConfiguredSite isite)
	throws CoreException {
	IFeatureReference[] refs = isite.getConfiguredFeatures();
	ArrayList candidatesPerSite = new ArrayList();
	for (int i = 0; i < refs.length; i++) {
	IFeatureReference ref = refs[i];
	// Don't waste time searching for updates to
	// patches.
	try {
	if (UpdateUtils.isPatch(ref.getFeature(null)))
	continue;
	}
	catch (CoreException e) {
	continue;
	}
	Candidate c = new Candidate(ref);
	candidatesPerSite.add(c);
	}
	// Create a tree from a flat list
	buildHierarchy(candidatesPerSite);
	// Add the remaining root candidates to
	// the global list of candidates.
	candidates.addAll(candidatesPerSite);
	}

	private void buildHierarchy(ArrayList candidates) throws CoreException {
	Candidate[] array =
	(Candidate[]) candidates.toArray(new Candidate[candidates.size()]);
	// filter out included features so that only top-level features remain on the list
	for (int i = 0; i < array.length; i++) {
	Candidate parent = array[i];
	IFeature feature = parent.getFeature(null);
	IFeatureReference[] included =
	feature.getIncludedFeatureReferences();
	for (int j = 0; j < included.length; j++) {
	IFeatureReference fref = included[j];
	Candidate child = findCandidate(candidates, fref);
	if (child != null) {
	parent.add(child);
	child.setReference(fref);
	candidates.remove(child);
	}
	}
	}
	}
	private Candidate findCandidate(ArrayList list, IFeatureReference ref) {
	for (int i = 0; i < list.size(); i++) {
	Candidate c = (Candidate) list.get(i);
	if (c.ref.equals(ref))
	return c;
	}
	return null;
	}

	public IUpdateSearchQuery[] getQueries() {
	initialize();
	ArrayList allCandidates = getAllCandidates();

	IUpdateSearchQuery[] queries =
	new IUpdateSearchQuery[allCandidates.size()];
	for (int i = 0; i < queries.length; i++) {
	Candidate candidate = (Candidate) allCandidates.get(i);
	IFeature feature = candidate.getFeature(null);
	IURLEntry updateEntry = candidate.getUpdateEntry();
	if (feature == null) {
	queries[i] = null;
	} else {
	queries[i] = new UpdateQuery(feature, updateEntry);
	}
	}
	return queries;
	}

	/**
	* Sets the features for which new updates need to be found. If
	* not set, updates will be searched for all the installed
	* and configured features.
	* @param features the features to search updates for
	*/
	public void setFeatures(IFeature [] features) {
	this.features = features;
	}

	/**
	* Returns an array of features for which updates need to
	* be found.
	* @return an array of features or <samp>null</samp> if not
	* set.
	*/
	public IFeature [] getFeatures() {
	return features;
	}
	/**
	* @param fvi
	* @param cvi
	* @return fvi < cvi
	*/
	private boolean isNewerVersion(
	VersionedIdentifier fvi,
	VersionedIdentifier cvi) {
	if (!fvi.getIdentifier().equals(cvi.getIdentifier()))
	return false;
	PluginVersionIdentifier fv = fvi.getVersion();
	PluginVersionIdentifier cv = cvi.getVersion();
	String mode = getUpdateVersionsMode();
	boolean greater = cv.isGreaterThan(fv);
	if (!greater)
	return false;
	if (mode.equals(UpdateCore.EQUIVALENT_VALUE))
	return cv.isEquivalentTo(fv);
	else if (mode.equals(UpdateCore.COMPATIBLE_VALUE))
	return cv.isCompatibleWith(fv);
	else
	return false;
	}

	private boolean isPatch(IFeature candidate, ISiteFeatureReference ref) {
	if (ref.isPatch() == false)
	return false;
	try {
	IFeature feature = ref.getFeature(null);
	if( UpdateUtils.isPatch(candidate, feature))
	return true;
	// Check if patch is for children
	try {
	IIncludedFeatureReference[] children =
	candidate.getIncludedFeatureReferences();
	for (int i = 0; i < children.length; i++) {
	IIncludedFeatureReference cref = children[i];
	try {
	IFeature child = cref.getFeature(null);
	if (isPatch(child, ref))
	return true;
	} catch (CoreException e) {
	}
	}
	} catch (CoreException e) {
	}
	return false;
	} catch (CoreException e) {
	return false;
	}
	}

	private String getUpdateVersionsMode() {
	Preferences store = UpdateCore.getPlugin().getPluginPreferences();
	return store.getString(UpdateCore.P_UPDATE_VERSIONS);
	}
	/*
	* This method recursively walks the list of candidates
	* building the flat that starts with the roots but
	* also includes all the children that are updatable
	* (use 'include' clause with a match that is not 'perfect').
	*/
	private ArrayList getAllCandidates() {
	ArrayList selected = new ArrayList();
	for (int i=0; i<candidates.size(); i++) {
	Candidate c = (Candidate)candidates.get(i);
	if (isOnTheList(c))
	c.addToFlatList(selected, true);
	}
	return selected;
	}

	private boolean isOnTheList(Candidate c) {
	if (features==null) return true;
	VersionedIdentifier vid;
	try {
	vid = c.getReference().getVersionedIdentifier();
	}
	catch (CoreException e) {
	return false;
	}
	for (int i=0; i<features.length; i++) {
	IFeature feature = features[i];
	VersionedIdentifier fvid = feature.getVersionedIdentifier();
	if (fvid.equals(vid))
	return true;
	}
	return false;
	}
	}