Attachment #150886 for bug #293339




import org.eclipse.equinox.internal.provisional.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQueryable;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
import org.eclipse.osgi.util.NLS;
import org.osgi.framework.BundleContext;
import org.xml.sax.InputSource;

		return profileFile;
	}

	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
		return profile.query(query, collector, monitor);
	}


		}
	}

	public Collector available(IQuery query, Collector collector, IProgressMonitor monitor) {
		return profile.available(query, collector, monitor);
	}


Lines 13-19 Link Here

(-)src/org/eclipse/equinox/internal/p2/ui/analysis/model/ForeignProfiles.java (-2 / +2 lines)
13	import org.eclipse.equinox.internal.provisional.p2.engine.ProfileEvent;	13	import org.eclipse.equinox.internal.provisional.p2.engine.ProfileEvent;
14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
15	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQueryable;	15	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQueryable;
16	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	16	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
17		17
18	public class ForeignProfiles implements IQueryable {	18	public class ForeignProfiles implements IQueryable {
19		19
Lines 39-45 Link Here
39	return (ForeignProfile) profileMap.get(profileid);	39	return (ForeignProfile) profileMap.get(profileid);
40	}	40	}
41		41
42	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	42	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
43	List profiles = new ArrayList(profileMap.size());	43	List profiles = new ArrayList(profileMap.size());
44	Iterator keys = profileMap.keySet().iterator();	44	Iterator keys = profileMap.keySet().iterator();
45		45

Lines 238-244 Link Here

(-)src/org/eclipse/equinox/internal/p2/console/ProvCommandProvider.java (-1 / +1 lines)
238	if (queryable == null)	238	if (queryable == null)
239	return;	239	return;
240	}	240	}
241	Query query = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_GROUP, Boolean.TRUE.toString());	241	IQuery query = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_GROUP, Boolean.TRUE.toString());
242	IInstallableUnit[] units = sort(queryable.query(query, new Collector(), null));	242	IInstallableUnit[] units = sort(queryable.query(query, new Collector(), null));
243	for (int i = 0; i < units.length; i++)	243	for (int i = 0; i < units.length; i++)
244	println(interpreter, units[i]);	244	println(interpreter, units[i]);

Lines 151-161 Link Here

(-)src/org/eclipse/equinox/internal/p2/console/ProvisioningHelper.java (-2 / +2 lines)
151	* @param monitor A progress monitor, or <code>null</code>	151	* @param monitor A progress monitor, or <code>null</code>
152	* @return The IUs that match the query	152	* @return The IUs that match the query
153	*/	153	*/
154	public static Collector getInstallableUnits(URI location, Query query, IProgressMonitor monitor) {	154	public static Collector getInstallableUnits(URI location, IQuery query, IProgressMonitor monitor) {
155	return getInstallableUnits(location, query, new Collector(), monitor);	155	return getInstallableUnits(location, query, new Collector(), monitor);
156	}	156	}
157		157
158	public static Collector getInstallableUnits(URI location, Query query, Collector collector, IProgressMonitor monitor) {	158	public static Collector getInstallableUnits(URI location, IQuery query, Collector collector, IProgressMonitor monitor) {
159	IQueryable queryable = null;	159	IQueryable queryable = null;
160	if (location == null) {	160	if (location == null) {
161	queryable = (IQueryable) ServiceHelper.getService(Activator.getContext(), IMetadataRepositoryManager.class.getName());	161	queryable = (IQueryable) ServiceHelper.getService(Activator.getContext(), IMetadataRepositoryManager.class.getName());

Lines 34-40 Link Here

(-)src/org/eclipse/equinox/internal/p2/director/QueryableArray.java (-1 / +1 lines)
34	dataSet = Arrays.asList(ius);	34	dataSet = Arrays.asList(ius);
35	}	35	}
36		36
37	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	37	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
38	if (query instanceof CapabilityQuery)	38	if (query instanceof CapabilityQuery)
39	return queryCapability((CapabilityQuery) query, collector, monitor);	39	return queryCapability((CapabilityQuery) query, collector, monitor);
40	return query.perform(dataSet.iterator(), collector);	40	return query.perform(dataSet.iterator(), collector);




	}

	public static IInstallableUnit[] findPlannerMarkedIUs(final IProfile profile) {
		IQuery markerQuery = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				if (!(candidate instanceof IInstallableUnit))
					return false;

			profile = p;
		}

		public Collector available(IQuery query, Collector collector, IProgressMonitor monitor) {
			return profile.available(query, collector, monitor);
		}


			return profile.isRootProfile();
		}

		public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
			return profile.query(query, collector, monitor);
		}
	}

Lines 96-102 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/director/ProvisioningPlan.java (-1 / +1 lines)
96	this.addition = add;	96	this.addition = add;
97	}	97	}
98		98
99	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	99	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
100	if (operands == null \|\| status.getSeverity() == IStatus.ERROR)	100	if (operands == null \|\| status.getSeverity() == IStatus.ERROR)
101	return collector;	101	return collector;
102	Collection list = new ArrayList();	102	Collection list = new ArrayList();





					IProfile profile = initializeProfile();
					query = new InstallableUnitQuery(root, version == null ? VersionRange.emptyRange : new VersionRange(version, true, version, true));
					roots = collectRootIUs(metadataRepositoryLocations, new PipedQuery(new IQuery[] {query, new LatestIUVersionQuery()}), new Collector());
					if (roots.size() <= 0)
						roots = profile.query(query, roots, new NullProgressMonitor());
					if (roots.size() <= 0) {

			this.location = location;
		}

		public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
			return ProvisioningHelper.getInstallableUnits(location, query, collector, monitor);
		}
	}

	private Collector collectRootIUs(URI[] locations, IQuery query, Collector collector) {
		IProgressMonitor nullMonitor = new NullProgressMonitor();

		if (locations == null || locations.length == 0)




			Assert.isNotNull(location);
		}

		public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
			return getInstallableUnits(location, query, collector, monitor);
		}
	}

		}
	}

	private Collector collectRootIUs(IQuery query, Collector collector) {
		IProgressMonitor nullMonitor = new NullProgressMonitor();

		int top = metadataRepositoryLocations.size();

		for (int i = 0; i < top; ++i) {
			IVersionedId rootName = (IVersionedId) rootNames.get(i);
			Version v = rootName.getVersion();
			IQuery query = new InstallableUnitQuery(rootName.getId(), Version.emptyVersion.equals(v) ? VersionRange.emptyRange : new VersionRange(v, true, v, true));
			Collector roots;
			if (forInstall)
				roots = collectRootIUs(new PipedQuery(new IQuery[] {query, new LatestIUVersionQuery()}), new Collector());
			else
				roots = new Collector();
			if (roots.size() <= 0)

			while (r.hasNext()) {
				IVersionedId rootName = (IVersionedId) r.next();
				Version v = rootName.getVersion();
				IQuery query = new InstallableUnitQuery(rootName.getId(), Version.emptyVersion.equals(v) ? VersionRange.emptyRange : new VersionRange(v, true, v, true));
				Collector roots = collectRootIUs(query, null);
				allRoots.addAll(roots.toCollection());
			}

			strm.print(' ');
	}

	Collector getInstallableUnits(URI location, IQuery query, Collector collector, IProgressMonitor monitor) {
		IQueryable queryable = null;
		if (location == null) {
			queryable = metadataManager;

Lines 157-163 Link Here

(-)src/org/eclipse/equinox/internal/p2/engine/Profile.java (-2 / +2 lines)
157	/* (non-Javadoc)	157	/* (non-Javadoc)
158	* @see org.eclipse.equinox.internal.provisional.p2.engine.IProfile#query(org.eclipse.equinox.internal.provisional.p2.query.Query, org.eclipse.equinox.internal.provisional.p2.query.Collector, org.eclipse.core.runtime.IProgressMonitor)	158	* @see org.eclipse.equinox.internal.provisional.p2.engine.IProfile#query(org.eclipse.equinox.internal.provisional.p2.query.Query, org.eclipse.equinox.internal.provisional.p2.query.Collector, org.eclipse.core.runtime.IProgressMonitor)
159	*/	159	*/
160	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	160	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
161	if (query instanceof IUProfilePropertyQuery) {	161	if (query instanceof IUProfilePropertyQuery) {
162	((IUProfilePropertyQuery) query).setProfile(this);	162	((IUProfilePropertyQuery) query).setProfile(this);
163	return query.perform(iuProperties.keySet().iterator(), collector);	163	return query.perform(iuProperties.keySet().iterator(), collector);
Lines 165-171 Link Here
165	return query.perform(ius.iterator(), collector);	165	return query.perform(ius.iterator(), collector);
166	}	166	}
167		167
168	public Collector available(Query query, Collector collector, IProgressMonitor monitor) {	168	public Collector available(IQuery query, Collector collector, IProgressMonitor monitor) {
169	if (surrogateProfileHandler != null)	169	if (surrogateProfileHandler != null)
170	return surrogateProfileHandler.queryProfile(this, query, collector, monitor);	170	return surrogateProfileHandler.queryProfile(this, query, collector, monitor);
171	return query(query, collector, monitor);	171	return query(query, collector, monitor);

Lines 22-28 Link Here

(-)src/org/eclipse/equinox/internal/p2/engine/ProfileMetadataRepository.java (-2 / +2 lines)
22	import org.eclipse.equinox.internal.provisional.p2.core.eventbus.IProvisioningEventBus;	22	import org.eclipse.equinox.internal.provisional.p2.core.eventbus.IProvisioningEventBus;
23	import org.eclipse.equinox.internal.provisional.p2.engine.IProfile;	23	import org.eclipse.equinox.internal.provisional.p2.engine.IProfile;
24	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	24	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
25	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	25	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
26	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;	26	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;
27	import org.eclipse.equinox.internal.provisional.p2.repository.RepositoryEvent;	27	import org.eclipse.equinox.internal.provisional.p2.repository.RepositoryEvent;
28	import org.eclipse.equinox.internal.provisional.spi.p2.metadata.repository.AbstractMetadataRepository;	28	import org.eclipse.equinox.internal.provisional.spi.p2.metadata.repository.AbstractMetadataRepository;
Lines 155-161 Link Here
155	// nothing to do	155	// nothing to do
156	}	156	}
157		157
158	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	158	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
159	return profile.query(query, collector, monitor);	159	return profile.query(query, collector, monitor);
160	}	160	}
161		161




	private SoftReference cachedProfile;

	private static void addSharedProfileBaseIUs(final IProfile sharedProfile, final Profile userProfile) {
		IQuery rootIUQuery = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				if (candidate instanceof IInstallableUnit) {
					IInstallableUnit iu = (IInstallableUnit) candidate;

	}

	private static void removeUserProfileBaseIUs(final Profile userProfile) {
		IQuery rootIUQuery = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				if (candidate instanceof IInstallableUnit) {
					IInstallableUnit iu = (IInstallableUnit) candidate;

	}

	private static void markRootsOptional(final Profile userProfile) {
		IQuery rootIUQuery = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				if (candidate instanceof IInstallableUnit) {
					IInstallableUnit iu = (IInstallableUnit) candidate;

	/* (non-Javadoc)
	 * @see org.eclipse.equinox.internal.p2.engine.ISurrogateProfileHandler#queryProfile(org.eclipse.equinox.internal.provisional.p2.engine.IProfile, org.eclipse.equinox.internal.provisional.p2.query.Query, org.eclipse.equinox.internal.provisional.p2.query.Collector, org.eclipse.core.runtime.IProgressMonitor)
	 */
	public Collector queryProfile(IProfile profile, IQuery query, Collector collector, IProgressMonitor monitor) {
		IProfile sharedProfile = getSharedProfile(profile.getProfileId());
		if (sharedProfile != null)
			sharedProfile.query(query, collector, monitor);

Lines 126-131 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/engine/IProfile.java (-1 / +1 lines)
126		126
127	public long getTimestamp();	127	public long getTimestamp();
128		128
129	public Collector available(Query query, Collector collector, IProgressMonitor monitor);	129	public Collector available(IQuery query, Collector collector, IProgressMonitor monitor);
130		130
131	}	131	}

Lines 12-18 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/engine/ISurrogateProfileHandler.java (-2 / +2 lines)
12		12
13	import org.eclipse.core.runtime.IProgressMonitor;	13	import org.eclipse.core.runtime.IProgressMonitor;
14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
15	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	15	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
16		16
17	public interface ISurrogateProfileHandler {	17	public interface ISurrogateProfileHandler {
18		18
Lines 20-26 Link Here
20		20
21	public abstract boolean isSurrogate(IProfile profile);	21	public abstract boolean isSurrogate(IProfile profile);
22		22
23	public abstract Collector queryProfile(IProfile profile, Query query, Collector collector, IProgressMonitor monitor);	23	public abstract Collector queryProfile(IProfile profile, IQuery query, Collector collector, IProgressMonitor monitor);
24		24
25	public abstract boolean updateProfile(IProfile selfProfile);	25	public abstract boolean updateProfile(IProfile selfProfile);
26		26

Lines 150-156 Link Here

(-)src/org/eclipse/equinox/internal/p2/installer/InstallUpdateProductOperation.java (-1 / +1 lines)
150	VersionRange range = VersionRange.emptyRange;	150	VersionRange range = VersionRange.emptyRange;
151	if (version != null && !version.equals(Version.emptyVersion))	151	if (version != null && !version.equals(Version.emptyVersion))
152	range = new VersionRange(version, true, version, true);	152	range = new VersionRange(version, true, version, true);
153	Query query = new InstallableUnitQuery(id, range);	153	IQuery query = new InstallableUnitQuery(id, range);
154	Collector collector = new Collector();	154	Collector collector = new Collector();
155	Iterator matches = metadataRepoMan.query(query, collector, null).iterator();	155	Iterator matches = metadataRepoMan.query(query, collector, null).iterator();
156	// pick the newest match	156	// pick the newest match

Lines 121-127 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/metadata/query/Collector.java (-1 / +1 lines)
121	/**	121	/**
122	* Performs a query on this results of this collector.	122	* Performs a query on this results of this collector.
123	*/	123	*/
124	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	124	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
125	Iterator iter = collector == this ? toCollection().iterator() : iterator();	125	Iterator iter = collector == this ? toCollection().iterator() : iterator();
126	if (monitor == null)	126	if (monitor == null)
127	monitor = new NullProgressMonitor();	127	monitor = new NullProgressMonitor();




 * In a CompoundQuery each sub-query is executed and the results are combined using
 * either logical AND or logical OR operations. <P>
 * 
 * Clients are expected to call {@link CompoundQuery#createCompoundQuery(IQuery[], boolean)}
 * to create a concrete instance of a CompoundQuery.  If all Queries are instances of 
 * {@link IMatchQuery} then the resulting compound query will be a MatchCompoundQuery, otherwise the
 * resulting compound query will be a {@link ContextQuery}.
 * 
 * @noextend This class is not intended to be subclassed by clients.
 */
public abstract class CompoundQuery implements IQuery {
	protected IQuery[] queries;
	protected boolean and;

	/**

	 * @param and <code>true</code> if this query represents a logical 'and', and
	 * <code>false</code> if this query represents a logical 'or'.
	 */
	public static CompoundQuery createCompoundQuery(IQuery[] queries, boolean and) {
		if (isMatchQueries(queries)) {
			return new CompoundQuery.MatchCompoundQuery(queries, and);
		}

	/**
	 * Returns the queries that make up this compound query
	 */
	public IQuery[] getQueries() {
		return queries;
	}


		return and;
	}

	protected CompoundQuery(IQuery[] queries, boolean and) {
		this.queries = queries;
		this.and = and;
	}

	/**
	 * @param queries
	 */
	private static boolean isMatchQueries(IQuery[] queries) {
		for (int i = 0; i < queries.length; i++) {
			if (!(queries[i] instanceof IMatchQuery)) {
				return false;

	 */
	private static class MatchCompoundQuery extends CompoundQuery implements IMatchQuery {

		protected MatchCompoundQuery(IQuery[] queries, boolean and) {
			super(queries, and);
		}


	 */
	private static class ContextCompoundQuery extends CompoundQuery {

		protected ContextCompoundQuery(IQuery[] queries, boolean and) {
			super(queries, and);
		}


Lines 31-37 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/metadata/query/ContextQuery.java (-1 / +1 lines)
31	* execution of the query. <P>	31	* execution of the query. <P>
32	*	32	*
33	*/	33	*/
34	public abstract class ContextQuery implements Query {	34	public abstract class ContextQuery implements IQuery {
35		35
36	/**	36	/**
37	* Evaluates the query for a specific input.	37	* Evaluates the query for a specific input.




******************************************************************************/
package org.eclipse.equinox.internal.provisional.p2.metadata.query;


import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * Static helper methods for the Query API.
 * 
 * The methods on this class are not intended to be referenced by clients. 
 */
public class QueryHelpers {
	/**
	 * Gets the ID for a Query. 
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public static String getId(IQuery query) {
		return query.getClass().getName();
	}


	 * Gets a particular property of a query.
	 * @param query The query to retrieve the property from
	 * @param property The property to retrieve 
	 * 
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public static Object getProperty(IQuery query, String property) {
		Class clazz = query.getClass();
		Object result = null;
		try {

Lines 12-17 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/metadata/query/UpdateQuery.java (+4 lines)
12		12
13	import org.eclipse.equinox.internal.provisional.p2.metadata.*;	13	import org.eclipse.equinox.internal.provisional.p2.metadata.*;
14		14
		15	/**
		16	* A query that finds all IUs that are considered an "Update" of the
		17	* specified IU.
		18	*/
15	public class UpdateQuery extends MatchQuery {	19	public class UpdateQuery extends MatchQuery {
16	private IInstallableUnit updateFrom;	20	private IInstallableUnit updateFrom;
17		21

Lines 520-526 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/metadata/generator/Generator.java (-2 / +2 lines)
520	}	520	}
521		521
522	//Query the repo	522	//Query the repo
523	Query query = new InstallableUnitQuery(name);	523	IQuery query = new InstallableUnitQuery(name);
524	Collector collector = new Collector();	524	Collector collector = new Collector();
525	Iterator matches = info.getMetadataRepository().query(query, collector, null).iterator();	525	Iterator matches = info.getMetadataRepository().query(query, collector, null).iterator();
526	//pick the newest match	526	//pick the newest match
Lines 635-641 Link Here
635	if (configuredIU == null) {	635	if (configuredIU == null) {
636	if (!generateRootIU && data == null)	636	if (!generateRootIU && data == null)
637	continue;	637	continue;
638	Query query = new InstallableUnitQuery(bundle.getSymbolicName());	638	IQuery query = new InstallableUnitQuery(bundle.getSymbolicName());
639	Collector collector = new Collector();	639	Collector collector = new Collector();
640	IMetadataRepository metadataRepository = info.getMetadataRepository();	640	IMetadataRepository metadataRepository = info.getMetadataRepository();
641	if (metadataRepository == null)	641	if (metadataRepository == null)

Lines 118-124 Link Here

(-)src/org/eclipse/equinox/internal/p2/metadata/repository/CompositeMetadataRepository.java (-2 / +2 lines)
118	return result;	118	return result;
119	}	119	}
120		120
121	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	121	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
122	if (monitor == null)	122	if (monitor == null)
123	monitor = new NullProgressMonitor();	123	monitor = new NullProgressMonitor();
124	try {	124	try {
Lines 200-206 Link Here
200	throw new UnsupportedOperationException("Cannot remove IUs to a composite repository");	200	throw new UnsupportedOperationException("Cannot remove IUs to a composite repository");
201	}	201	}
202		202
203	public synchronized boolean removeInstallableUnits(Query query, IProgressMonitor monitor) {	203	public synchronized boolean removeInstallableUnits(IQuery query, IProgressMonitor monitor) {
204	throw new UnsupportedOperationException("Cannot remove IUs to a composite repository");	204	throw new UnsupportedOperationException("Cannot remove IUs to a composite repository");
205	}	205	}
206		206

Lines 112-118 Link Here

(-)src/org/eclipse/equinox/internal/p2/metadata/repository/MetadataRepositoryManager.java (-1 / +1 lines)
112	* reporting is not desired	112	* reporting is not desired
113	* @return The collector argument	113	* @return The collector argument
114	*/	114	*/
115	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	115	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
116	URI[] locations = getKnownRepositories(REPOSITORIES_ALL);	116	URI[] locations = getKnownRepositories(REPOSITORIES_ALL);
117	List queryables = new ArrayList(locations.length); // use a list since we don't know exactly how many will load	117	List queryables = new ArrayList(locations.length); // use a list since we don't know exactly how many will load
118	SubMonitor sub = SubMonitor.convert(monitor, locations.length * 10);	118	SubMonitor sub = SubMonitor.convert(monitor, locations.length * 10);

Lines 13-19 Link Here

(-)src/org/eclipse/equinox/internal/p2/metadata/repository/URLMetadataRepository.java (-2 / +2 lines)
13		13
14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
15		15
16	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	16	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
17		17
18	import java.net.URI;	18	import java.net.URI;
19	import java.util.*;	19	import java.util.*;
Lines 79-85 Link Here
79	return false;	79	return false;
80	}	80	}
81		81
82	public synchronized Collector query(Query query, Collector collector, IProgressMonitor monitor) {	82	public synchronized Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
83	return query.perform(units.iterator(), collector);	83	return query.perform(units.iterator(), collector);
84	}	84	}
85	}	85	}

Lines 11-17 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/metadata/repository/IMetadataRepository.java (-2 / +2 lines)
11	package org.eclipse.equinox.internal.provisional.p2.metadata.repository;	11	package org.eclipse.equinox.internal.provisional.p2.metadata.repository;
12		12
13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQueryable;	13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQueryable;
14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
15		15
16	import java.net.URI;	16	import java.net.URI;
17	import org.eclipse.core.runtime.IProgressMonitor;	17	import org.eclipse.core.runtime.IProgressMonitor;
Lines 70-76 Link Here
70	* @return <code>true</code> if any units were actually removed, and	70	* @return <code>true</code> if any units were actually removed, and
71	* <code>false</code> otherwise	71	* <code>false</code> otherwise
72	*/	72	*/
73	public boolean removeInstallableUnits(Query query, IProgressMonitor monitor);	73	public boolean removeInstallableUnits(IQuery query, IProgressMonitor monitor);
74		74
75	/**	75	/**
76	* Remove all installable units from this repository.	76	* Remove all installable units from this repository.

Lines 12-18 Link Here

(-)src/org/eclipse/equinox/internal/provisional/spi/p2/metadata/repository/AbstractMetadataRepository.java (-2 / +2 lines)
12		12
13	import org.eclipse.equinox.internal.provisional.p2.metadata.Version;	13	import org.eclipse.equinox.internal.provisional.p2.metadata.Version;
14		14
15	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	15	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
16		16
17	import org.eclipse.equinox.internal.provisional.spi.p2.repository.AbstractRepository;	17	import org.eclipse.equinox.internal.provisional.spi.p2.repository.AbstractRepository;
18		18
Lines 66-72 Link Here
66	assertModifiable();	66	assertModifiable();
67	}	67	}
68		68
69	public boolean removeInstallableUnits(Query query, IProgressMonitor monitor) {	69	public boolean removeInstallableUnits(IQuery query, IProgressMonitor monitor) {
70	assertModifiable();	70	assertModifiable();
71	return false;	71	return false;
72	}	72	}




	 * @return the first matching IU or <code>null</code> if none.
	 */
	protected IInstallableUnit queryForIU(IPublisherResult publisherResult, String iuId, Version version) {
		IQuery query = null;
		Collector collector = null;
		if (version != null && !Version.emptyVersion.equals(version)) {
			query = new InstallableUnitQuery(iuId, version);
			collector = new SingleElementCollector();
		} else {
			query = new PipedQuery(new IQuery[] {new InstallableUnitQuery(iuId), new LatestIUVersionQuery()});
			collector = new Collector();
		}


	 * @return The the IUs with the matching ids in the given range
	 */
	protected IInstallableUnit[] queryForIUs(IPublisherResult publisherResult, String iuId, VersionRange versionRange) {
		IQuery query = null;
		Collector collector = new Collector();
		query = new InstallableUnitQuery(iuId, versionRange);
		NullProgressMonitor progress = new NullProgressMonitor();

Lines 129-135 Link Here

(-)src/org/eclipse/equinox/p2/publisher/PublisherResult.java (-2 / +2 lines)
129	this.map = map;	129	this.map = map;
130	}	130	}
131		131
132	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	132	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
133	return query.perform(flatten(this.map.values()).iterator(), collector);	133	return query.perform(flatten(this.map.values()).iterator(), collector);
134	}	134	}
135	}	135	}
Lines 137-143 Link Here
137	/**	137	/**
138	* Queries both the root and non root IUs	138	* Queries both the root and non root IUs
139	*/	139	*/
140	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	140	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
141	IQueryable nonRootQueryable = new QueryableMap(nonRootIUs);	141	IQueryable nonRootQueryable = new QueryableMap(nonRootIUs);
142	IQueryable rootQueryable = new QueryableMap(rootIUs);	142	IQueryable rootQueryable = new QueryableMap(rootIUs);
143	return new CompoundQueryable(new IQueryable[] {nonRootQueryable, rootQueryable}).query(query, collector, monitor);	143	return new CompoundQueryable(new IQueryable[] {nonRootQueryable, rootQueryable}).query(query, collector, monitor);





import java.util.Collection;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
import org.eclipse.equinox.p2.publisher.AbstractAdvice;
import org.eclipse.equinox.p2.publisher.IPublisherResult;

public class RootIUResultFilterAdvice extends AbstractAdvice implements IRootIUAdvice {
	private IQuery query;

	public RootIUResultFilterAdvice(IQuery query) {
		this.query = query;
	}


Lines 12-18 Link Here

(-)src_ant/org/eclipse/equinox/p2/internal/repository/tools/tasks/AbstractRepositoryTask.java (-2 / +2 lines)
12		12
13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
14		14
15	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	15	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
16		16
17	import java.io.File;	17	import java.io.File;
18	import java.net.URI;	18	import java.net.URI;
Lines 168-174 Link Here
168	List result = new ArrayList();	168	List result = new ArrayList();
169	for (Iterator iter = iuTasks.iterator(); iter.hasNext();) {	169	for (Iterator iter = iuTasks.iterator(); iter.hasNext();) {
170	IUDescription iu = (IUDescription) iter.next();	170	IUDescription iu = (IUDescription) iter.next();
171	Query iuQuery = iu.createQuery();	171	IQuery iuQuery = iu.createQuery();
172	Collector collector = new Collector();	172	Collector collector = new Collector();
173		173
174	repository.query(iuQuery, collector, null);	174	repository.query(iuQuery, collector, null);




		return buffer.toString();
	}

	public IQuery createQuery() {
		List queries = new ArrayList();
		if (id != null) {
			if (version == null || version.length() == 0) {

			}
		}

		IQuery iuQuery = processQueryString();
		if (iuQuery != null)
			queries.add(iuQuery);

		if (queries.size() == 1)
			return (IQuery) queries.get(0);
		return new PipedQuery((IQuery[]) queries.toArray(new IQuery[queries.size()]));
	}

	private IQuery processQueryString() {
		if (queryString == null)
			return null;
		int startIdx = queryString.indexOf('[');

Lines 62-68 Link Here

(-)src_ant/org/eclipse/equinox/p2/internal/repository/tools/tasks/RemoveIUTask.java (-2 / +2 lines)
62	final Set toRemove = new HashSet();	62	final Set toRemove = new HashSet();
63	for (Iterator iter = iuTasks.iterator(); iter.hasNext();) {	63	for (Iterator iter = iuTasks.iterator(); iter.hasNext();) {
64	IUDescription iu = (IUDescription) iter.next();	64	IUDescription iu = (IUDescription) iter.next();
65	Query iuQuery = iu.createQuery();	65	IQuery iuQuery = iu.createQuery();
66		66
67	Collector collector = new Collector();	67	Collector collector = new Collector();
68	repository.query(iuQuery, collector, null);	68	repository.query(iuQuery, collector, null);
Lines 104-110 Link Here
104	}	104	}
105		105
106	if (toRemove.size() > 0) {	106	if (toRemove.size() > 0) {
107	Query removeQuery = new MatchQuery() {	107	IQuery removeQuery = new MatchQuery() {
108	public boolean isMatch(Object candidate) {	108	public boolean isMatch(Object candidate) {
109	return toRemove.contains(candidate);	109	return toRemove.contains(candidate);
110	}	110	}

Lines 35-41 Link Here

(-)src/org/eclipse/equinox/p2/tests/MockQueryable.java (-1 / +1 lines)
35		35
36	}	36	}
37		37
38	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	38	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
39	return query.perform(items.iterator(), collector);	39	return query.perform(items.iterator(), collector);
40	}	40	}
41		41

Lines 68-74 Link Here

(-)src/org/eclipse/equinox/p2/tests/TestMetadataRepository.java (-1 / +1 lines)
68	return null;	68	return null;
69	}	69	}
70		70
71	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	71	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
72	return query.perform(units.iterator(), collector);	72	return query.perform(units.iterator(), collector);
73	}	73	}
74		74




	}

	public void testEmptyCompositeQuery() {
		PipedQuery query = new PipedQuery(new IQuery[0]);
		query.perform(getABCDE().iterator(), new Collector());
		// We should not throw an exception.  No guarantee on what perform
		// will return in this case
	}

	public void testSymmetry() {
		IQuery getLatest = new ContextQuery() {

			public Collector perform(Iterator iterator, Collector result) {
				List list = new ArrayList();

			}
		};

		IQuery getAllBut3 = new ContextQuery() {

			public Collector perform(Iterator iterator, Collector result) {
				while (iterator.hasNext()) {

			}
		};

		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getLatest, getAllBut3}, true);
		Collector result = compoundQuery.perform(get123().iterator(), new Collector());
		assertEquals(0, result.size());

		compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getAllBut3, getLatest}, true);
		result = compoundQuery.perform(get123().iterator(), new Collector());
		assertEquals(0, result.size());

		compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getLatest, getAllBut3}, false);
		result = compoundQuery.perform(get123().iterator(), new Collector());
		assertEquals(3, result.size());

		compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getAllBut3, getLatest}, false);
		result = compoundQuery.perform(get123().iterator(), new Collector());
		assertEquals(3, result.size());


	 * This method tests that
	 */
	public void testNonSymmetry() {
		IQuery getLatest = new ContextQuery() {

			public Collector perform(Iterator iterator, Collector result) {
				List list = new ArrayList();

			}
		};

		IQuery getAllBut3 = new ContextQuery() {

			public Collector perform(Iterator iterator, Collector result) {
				while (iterator.hasNext()) {

			}
		};

		PipedQuery compoundQuery = new PipedQuery(new IQuery[] {getLatest, getAllBut3});
		Collector result = compoundQuery.perform(get123().iterator(), new Collector());
		assertEquals(0, result.size());

		compoundQuery = new PipedQuery(new IQuery[] {getAllBut3, getLatest});
		result = compoundQuery.perform(get123().iterator(), new Collector());
		assertEquals(1, result.size());
		assertEquals("2", result.toCollection().iterator().next());

	}

	public void testCompoundAllMatchQueries() {
		IQuery A = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				return false;
			}
		};
		IQuery B = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				return false;
			}
		};
		IQuery C = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				return false;
			}
		};
		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
		assertTrue("1.0", compoundQuery instanceof IMatchQuery);
		assertEquals("1.1", 3, compoundQuery.getQueries().length);
		assertEquals("1.2", A, compoundQuery.getQueries()[0]);

	}

	public void testCompoundSomeMatchQueries() {
		IQuery A = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				return false;
			}
		};
		IQuery B = new ContextQuery() {
			public Collector perform(Iterator iterator, Collector result) {
				// TODO Auto-generated method stub
				return null;
			}
		};
		IQuery C = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				return false;
			}
		};
		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
		assertTrue("1.0", !(compoundQuery instanceof IMatchQuery));
		assertEquals("1.1", 3, compoundQuery.getQueries().length);
		assertEquals("1.2", A, compoundQuery.getQueries()[0]);

	}

	public void testCompoundNoMatchQueries() {
		IQuery A = new ContextQuery() {
			public Collector perform(Iterator iterator, Collector result) {
				// TODO Auto-generated method stub
				return null;
			}
		};
		IQuery B = new ContextQuery() {
			public Collector perform(Iterator iterator, Collector result) {
				// TODO Auto-generated method stub
				return null;
			}
		};
		IQuery C = new ContextQuery() {
			public Collector perform(Iterator iterator, Collector result) {
				// TODO Auto-generated method stub
				return null;
			}
		};
		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
		assertTrue("1.0", !(compoundQuery instanceof IMatchQuery));
		assertEquals("1.1", 3, compoundQuery.getQueries().length);
		assertEquals("1.2", A, compoundQuery.getQueries()[0]);

	}

	public void testIntersection() {
		IQuery ABC = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				if (candidate.equals("A") || candidate.equals("B") || candidate.equals("C"))
					return true;

			}
		};

		IQuery BCDE = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				if (candidate.equals("B") || candidate.equals("C") || candidate.equals("D") || candidate.equals("E"))
					return true;

			}
		};

		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, true);
		Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
		assertEquals("1.0", result.size(), 2);
		assertTrue("1.1", result.toCollection().contains("B"));

	}

	public void testIntersection2() {
		IQuery ABC = new ContextQuery() {
			public Collector perform(Iterator iterator, Collector result) {
				while (iterator.hasNext()) {
					Object o = iterator.next();

			}
		};

		IQuery BCDE = new ContextQuery() {
			public Collector perform(Iterator iterator, Collector result) {
				while (iterator.hasNext()) {
					Object o = iterator.next();

			}
		};

		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, true);
		Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
		assertEquals("1.0", result.size(), 2);
		assertTrue("1.1", result.toCollection().contains("B"));

	}

	public void testUnion() {
		IQuery ABC = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				if (candidate.equals("A") || candidate.equals("B") || candidate.equals("C"))
					return true;

			}
		};

		IQuery BCDE = new MatchQuery() {
			public boolean isMatch(Object candidate) {
				if (candidate.equals("B") || candidate.equals("C") || candidate.equals("D") || candidate.equals("E"))
					return true;

			}
		};

		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, false);
		Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
		assertEquals("1.0", result.size(), 5);
		assertTrue("1.1", result.toCollection().contains("A"));

	}

	public void testUnion2() {
		IQuery ABC = new ContextQuery() {
			public Collector perform(Iterator iterator, Collector result) {
				while (iterator.hasNext()) {
					Object o = iterator.next();

			}
		};

		IQuery BCDE = new ContextQuery() {
			public Collector perform(Iterator iterator, Collector result) {
				while (iterator.hasNext()) {
					Object o = iterator.next();

			}
		};

		CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, false);
		Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
		assertEquals("1.0", result.size(), 5);
		assertTrue("1.1", result.toCollection().contains("A"));

Lines 473-482 Link Here

(-)src/org/eclipse/equinox/p2/tests/director/DirectorAppTest.java (-2 / +2 lines)
473	URI metadataRepo1 = getTestData("10.1", "/testData/metadataRepo/good").toURI();	473	URI metadataRepo1 = getTestData("10.1", "/testData/metadataRepo/good").toURI();
474	URI metadataRepo2 = getTestData("10.1", "/testData/metadataRepo/multipleversions1").toURI();	474	URI metadataRepo2 = getTestData("10.1", "/testData/metadataRepo/multipleversions1").toURI();
475	Application application = new Application();	475	Application application = new Application();
476	Method method = application.getClass().getDeclaredMethod("collectRootIUs", URI[].class, Query.class, Collector.class);	476	Method method = application.getClass().getDeclaredMethod("collectRootIUs", URI[].class, IQuery.class, Collector.class);
477	method.setAccessible(true);	477	method.setAccessible(true);
478	URI[] uris = new URI[] {metadataRepo1, metadataRepo2};	478	URI[] uris = new URI[] {metadataRepo1, metadataRepo2};
479	Query query = new MatchQuery() {	479	IQuery query = new MatchQuery() {
480	public boolean isMatch(Object candidate) {	480	public boolean isMatch(Object candidate) {
481	if (candidate instanceof IInstallableUnit) {	481	if (candidate instanceof IInstallableUnit) {
482	IInstallableUnit iu = (IInstallableUnit) candidate;	482	IInstallableUnit iu = (IInstallableUnit) candidate;

Lines 526-535 Link Here

(-)src/org/eclipse/equinox/p2/tests/director/DirectorApplicationTest.java (-2 / +2 lines)
526	URI metadataRepo1 = getTestData("10.1", "/testData/metadataRepo/good").toURI();	526	URI metadataRepo1 = getTestData("10.1", "/testData/metadataRepo/good").toURI();
527	URI metadataRepo2 = getTestData("10.1", "/testData/metadataRepo/multipleversions1").toURI();	527	URI metadataRepo2 = getTestData("10.1", "/testData/metadataRepo/multipleversions1").toURI();
528	Application application = new Application();	528	Application application = new Application();
529	Method method = application.getClass().getDeclaredMethod("collectRootIUs", URI[].class, Query.class, Collector.class);	529	Method method = application.getClass().getDeclaredMethod("collectRootIUs", URI[].class, IQuery.class, Collector.class);
530	method.setAccessible(true);	530	method.setAccessible(true);
531	URI[] uris = new URI[] {metadataRepo1, metadataRepo2};	531	URI[] uris = new URI[] {metadataRepo1, metadataRepo2};
532	Query query = new MatchQuery() {	532	IQuery query = new MatchQuery() {
533	public boolean isMatch(Object candidate) {	533	public boolean isMatch(Object candidate) {
534	if (candidate instanceof IInstallableUnit) {	534	if (candidate instanceof IInstallableUnit) {
535	IInstallableUnit iu = (IInstallableUnit) candidate;	535	IInstallableUnit iu = (IInstallableUnit) candidate;

Lines 139-145 Link Here

(-)src/org/eclipse/equinox/p2/tests/engine/ProfileTest.java (-1 / +1 lines)
139	return false;	139	return false;
140	}	140	}
141		141
142	public Collector queryProfile(IProfile profile, Query query, Collector collector, IProgressMonitor monitor) {	142	public Collector queryProfile(IProfile profile, IQuery query, Collector collector, IProgressMonitor monitor) {
143	return collector;	143	return collector;
144	}	144	}
145		145

Lines 53-59 Link Here

(-)src/org/eclipse/equinox/p2/tests/full/RepoValidator.java (-1 / +1 lines)
53	properties.put("osgi.arch", "x86");	53	properties.put("osgi.arch", "x86");
54	IProfile p = createProfile("repoValidator", null, properties);	54	IProfile p = createProfile("repoValidator", null, properties);
55		55
56	Query q;	56	IQuery q;
57		57
58	q = new InstallableUnitQuery("org.eclipse.rcp.feature.group");	58	q = new InstallableUnitQuery("org.eclipse.rcp.feature.group");
59		59

Lines 475-481 Link Here

(-)src/org/eclipse/equinox/p2/tests/metadata/repository/CompositeMetadataRepositoryTest.java (-1 / +1 lines)
475	CompositeMetadataRepository compositeRepo = createRepo(false);	475	CompositeMetadataRepository compositeRepo = createRepo(false);
476	compositeRepo.addChild(location1);	476	compositeRepo.addChild(location1);
477	compositeRepo.addChild(location2);	477	compositeRepo.addChild(location2);
478	PipedQuery cQuery = new PipedQuery(new Query[] {new MatchQuery() {	478	PipedQuery cQuery = new PipedQuery(new IQuery[] {new MatchQuery() {
479	public boolean isMatch(Object candidate) {	479	public boolean isMatch(Object candidate) {
480	if (candidate instanceof IInstallableUnit) {	480	if (candidate instanceof IInstallableUnit) {
481	IInstallableUnit iInstallableUnit = (IInstallableUnit) candidate;	481	IInstallableUnit iInstallableUnit = (IInstallableUnit) candidate;

Lines 22-28 Link Here

(-)src/org/eclipse/equinox/p2/tests/publisher/actions/RootIUActionTest.java (-2 / +2 lines)
22	import org.eclipse.equinox.internal.provisional.p2.metadata.IInstallableUnit;	22	import org.eclipse.equinox.internal.provisional.p2.metadata.IInstallableUnit;
23	import org.eclipse.equinox.internal.provisional.p2.metadata.IRequiredCapability;	23	import org.eclipse.equinox.internal.provisional.p2.metadata.IRequiredCapability;
24	import org.eclipse.equinox.internal.provisional.p2.metadata.query.MatchQuery;	24	import org.eclipse.equinox.internal.provisional.p2.metadata.query.MatchQuery;
25	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	25	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
26	import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepository;	26	import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepository;
27	import org.eclipse.equinox.p2.publisher.IPublisherResult;	27	import org.eclipse.equinox.p2.publisher.IPublisherResult;
28	import org.eclipse.equinox.p2.publisher.actions.*;	28	import org.eclipse.equinox.p2.publisher.actions.*;
Lines 230-236 Link Here
230	}	230	}
231		231
232	private void setupFilterAdvice(int testSpec) {	232	private void setupFilterAdvice(int testSpec) {
233	Query query = null;	233	IQuery query = null;
234	rootIUAdviceCollection = new ArrayList();	234	rootIUAdviceCollection = new ArrayList();
235	if ((testSpec & CONTAINS_A) > 0) {	235	if ((testSpec & CONTAINS_A) > 0) {
236	query = new MatchQuery() {	236	query = new MatchQuery() {

Lines 39-45 Link Here

(-)src/org/eclipse/equinox/p2/tests/updatesite/LocalUpdatesiteTest.java (-1 / +1 lines)
39	}	39	}
40		40
41	public void testCategoryQualifier() throws IOException, ProvisionException {	41	public void testCategoryQualifier() throws IOException, ProvisionException {
42	Query categoryQuery = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_CATEGORY, Boolean.toString(true));	42	IQuery categoryQuery = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_CATEGORY, Boolean.toString(true));
43	File siteSource = TestData.getFile("updatesite", "SiteXMLActionTest");	43	File siteSource = TestData.getFile("updatesite", "SiteXMLActionTest");
44	UpdateSitePublisherApplication application = new UpdateSitePublisherApplication();	44	UpdateSitePublisherApplication application = new UpdateSitePublisherApplication();
45	try {	45	try {

Lines 49-55 Link Here

(-)src/org/eclipse/equinox/p2/tests/updatesite/SiteXMLActionTest.java (-1 / +1 lines)
49	}	49	}
50		50
51	public void testQualifier() {	51	public void testQualifier() {
52	Query categoryQuery = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_CATEGORY, Boolean.toString(true));	52	IQuery categoryQuery = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_CATEGORY, Boolean.toString(true));
53	Collector results = actionResult.query(categoryQuery, new Collector(), new NullProgressMonitor());	53	Collector results = actionResult.query(categoryQuery, new Collector(), new NullProgressMonitor());
54	Iterator iter = results.iterator();	54	Iterator iter = results.iterator();
55	while (iter.hasNext()) {	55	while (iter.hasNext()) {

Lines 11-17 Link Here

(-)src/org/eclipse/equinox/p2/tests/ui/query/AbstractQueryTest.java (-2 / +2 lines)
11	package org.eclipse.equinox.p2.tests.ui.query;	11	package org.eclipse.equinox.p2.tests.ui.query;
12		12
13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.MatchQuery;	13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.MatchQuery;
14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
15	import org.eclipse.equinox.internal.provisional.p2.repository.IRepositoryManager;	15	import org.eclipse.equinox.internal.provisional.p2.repository.IRepositoryManager;
16	import org.eclipse.equinox.internal.provisional.p2.ui.policy.IUViewQueryContext;	16	import org.eclipse.equinox.internal.provisional.p2.ui.policy.IUViewQueryContext;
17	import org.eclipse.equinox.internal.provisional.p2.ui.policy.Policy;	17	import org.eclipse.equinox.internal.provisional.p2.ui.policy.Policy;
Lines 43-49 Link Here
43	Policy.getDefault().setQueryContext(null);	43	Policy.getDefault().setQueryContext(null);
44	}	44	}
45		45
46	protected Query getMockQuery() {	46	protected IQuery getMockQuery() {
47	return new MatchQuery() {	47	return new MatchQuery() {
48	public boolean isMatch(Object candidate) {	48	public boolean isMatch(Object candidate) {
49	return true;	49	return true;

Lines 149-155 Link Here

(-)src/org/eclipse/equinox/p2/tests/ui/query/AvailableIUWrapperTest.java (-1 / +1 lines)
149	assertEquals("1.2", notInstalled, getIU(iuElement));	149	assertEquals("1.2", notInstalled, getIU(iuElement));
150	}	150	}
151		151
152	protected Query getMockQuery() {	152	protected IQuery getMockQuery() {
153	return new IUPropertyQuery("key", "value");	153	return new IUPropertyQuery("key", "value");
154	}	154	}
155	}	155	}




	class SimpleQueryable implements IQueryable {
		List elements = Arrays.asList(new String[] {"a", "b", "c", "d", "e"});

		public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
			return query.perform(elements.iterator(), collector);
		}
	}

	}

	public void testCompoundDescriptorAND() {
		IQuery query = CompoundQuery.createCompoundQuery(new IQuery[] {new SimpleMatchQuery(), new SimpleMatchQuery2()}, true);
		ElementQueryDescriptor eqDescriptor = new ElementQueryDescriptor(new SimpleQueryable(), query, new Collector(), new StringWrapper());
		Collection collection = eqDescriptor.performQuery(null);
		assertEquals("1.0", 1, collection.size());

	}

	public void testCompoundDescriptorOR() {
		IQuery query = CompoundQuery.createCompoundQuery(new IQuery[] {new SimpleMatchQuery(), new SimpleMatchQuery2()}, false);
		ElementQueryDescriptor eqDescriptor = new ElementQueryDescriptor(new SimpleQueryable(), query, new Collector(), new StringWrapper());
		Collection collection = eqDescriptor.performQuery(null);
		assertEquals("1.0", 3, collection.size());

Lines 13-19 Link Here

(-)src/org/eclipse/equinox/internal/p2/tools/mirror/RepositoryMirroring.java (-2 / +2 lines)
13		13
14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
15		15
16	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	16	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
17		17
18	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;	18	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;
19		19
Lines 92-98 Link Here
92	}	92	}
93	}	93	}
94		94
95	public void mirrorMetadata(Query query) throws ProvisionException {	95	public void mirrorMetadata(IQuery query) throws ProvisionException {
96	Collector result = metadataSourceRepository.query(query, new Collector(), null);	96	Collector result = metadataSourceRepository.query(query, new Collector(), null);
97	mirrorMetadata((IInstallableUnit[]) result.toArray(IInstallableUnit.class));	97	mirrorMetadata((IInstallableUnit[]) result.toArray(IInstallableUnit.class));
98	}	98	}





	private Policy policy;

	private IQuery allQuery = new MatchQuery() {
		public boolean isMatch(Object candidate) {
			return true;
		}

					}
				}

				IQuery topLevelQuery = new IUPropertyQuery(context.getVisibleAvailableIUProperty(), Boolean.TRUE.toString());
				IQuery categoryQuery = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_CATEGORY, Boolean.toString(true));

				// Showing child IU's of a group of repositories, or of a single repository
				if (element instanceof MetadataRepositories || element instanceof MetadataRepositoryElement) {
					if (context.getViewType() == IUViewQueryContext.AVAILABLE_VIEW_FLAT || !context.getUseCategories()) {
						AvailableIUWrapper wrapper = new AvailableIUWrapper(queryable, element, false, context.getShowAvailableChildren());
						if (showLatest)
							topLevelQuery = new PipedQuery(new IQuery[] {topLevelQuery, new LatestIUVersionQuery()});
						if (targetProfile != null)
							wrapper.markInstalledIUs(targetProfile, hideInstalled);
						return new ElementQueryDescriptor(queryable, topLevelQuery, new Collector(), wrapper);

					// children of a category should drill down according to the context.  If we aren't in a category, we are already drilling down and
					// continue to do so.
					boolean drillDown = element instanceof CategoryElement ? context.getShowAvailableChildren() : true;
					IQuery meetsAnyRequirementQuery = new AnyRequiredCapabilityQuery(((IIUElement) element).getRequirements());
					availableIUWrapper = new AvailableIUWrapper(queryable, element, true, drillDown);
					if (targetProfile != null)
						availableIUWrapper.markInstalledIUs(targetProfile, hideInstalled);

					// be visible in the category.
					if (element instanceof CategoryElement) {
						if (showLatest)
							meetsAnyRequirementQuery = new PipedQuery(new IQuery[] {meetsAnyRequirementQuery, new LatestIUVersionQuery()});
						return new ElementQueryDescriptor(queryable, meetsAnyRequirementQuery, new Collector(), availableIUWrapper);
					}
					IQuery query = CompoundQuery.createCompoundQuery(new IQuery[] {topLevelQuery, meetsAnyRequirementQuery}, true);
					if (showLatest)
						query = new PipedQuery(new IQuery[] {query, new LatestIUVersionQuery()});
					// If it's not a category, these are generic requirements and should be filtered by the visibility property (topLevelQuery)
					return new ElementQueryDescriptor(queryable, query, new Collector(), availableIUWrapper);
				}

			case QueryProvider.INSTALLED_IUS :
				// Querying of IU's.  We are drilling down into the requirements.
				if (element instanceof IIUElement && context.getShowInstallChildren()) {
					IQuery meetsAnyRequirementQuery = new AnyRequiredCapabilityQuery(((IIUElement) element).getRequirements());
					IQuery visibleAsAvailableQuery = new IUPropertyQuery(context.getVisibleAvailableIUProperty(), Boolean.TRUE.toString());
					return new ElementQueryDescriptor(queryable, CompoundQuery.createCompoundQuery(new IQuery[] {visibleAsAvailableQuery, meetsAnyRequirementQuery}, true), new Collector(), new InstalledIUElementWrapper(queryable, element));
				}
				profile = (IProfile) ProvUI.getAdapter(element, IProfile.class);
				if (profile == null)

Lines 34-40 Link Here

(-)src/org/eclipse/equinox/internal/p2/ui/query/QueryableUpdates.java (-1 / +1 lines)
34	this.iusToUpdate = iusToUpdate;	34	this.iusToUpdate = iusToUpdate;
35	}	35	}
36		36
37	public Collector query(Query query, Collector result, IProgressMonitor monitor) {	37	public Collector query(IQuery query, Collector result, IProgressMonitor monitor) {
38	if (monitor == null)	38	if (monitor == null)
39	monitor = new NullProgressMonitor();	39	monitor = new NullProgressMonitor();
40	int totalWork = 2000;	40	int totalWork = 2000;




 */
public class ElementQueryDescriptor {

	private IQuery query;
	private Collector collector;
	private IQueryable queryable;
	private ElementWrapper wrapper;

	 * Creates an ElementQueryDescriptor to represent a Query, its collector the queryable
	 * on which it will run.
	 */
	public ElementQueryDescriptor(IQueryable queryable, IQuery query, Collector collector) {
		this(queryable, query, collector, null);
	}


	 * Creates an ElementQueryDescriptor to represent a Query, its collector the queryable
	 * on which it will run, and the transformer used to transform the results.
	 */
	public ElementQueryDescriptor(IQueryable queryable, IQuery query, Collector collector, ElementWrapper wrapper) {
		this.query = query;
		this.collector = collector;
		this.queryable = queryable;

Lines 20-26 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/ui/QueryableArtifactRepositoryManager.java (-2 / +2 lines)
20	import org.eclipse.equinox.internal.provisional.p2.artifact.repository.IArtifactRepositoryManager;	20	import org.eclipse.equinox.internal.provisional.p2.artifact.repository.IArtifactRepositoryManager;
21	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;	21	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
22	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	22	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
23	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	23	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
24	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;	24	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;
25	import org.eclipse.equinox.internal.provisional.p2.repository.IRepositoryManager;	25	import org.eclipse.equinox.internal.provisional.p2.repository.IRepositoryManager;
26	import org.eclipse.equinox.internal.provisional.p2.ui.policy.IUViewQueryContext;	26	import org.eclipse.equinox.internal.provisional.p2.ui.policy.IUViewQueryContext;
Lines 59-65 Link Here
59	return null;	59	return null;
60	}	60	}
61		61
62	protected Collector query(URI[] uris, Query query, Collector collector, IProgressMonitor monitor) {	62	protected Collector query(URI[] uris, IQuery query, Collector collector, IProgressMonitor monitor) {
63	SubMonitor sub = SubMonitor.convert(monitor, uris.length * 100);	63	SubMonitor sub = SubMonitor.convert(monitor, uris.length * 100);
64		64
65	if (sub.isCanceled())	65	if (sub.isCanceled())

Lines 57-63 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/ui/QueryableMetadataRepositoryManager.java (-1 / +1 lines)
57	return null;	57	return null;
58	}	58	}
59		59
60	protected Collector query(URI uris[], Query query, Collector collector, IProgressMonitor monitor) {	60	protected Collector query(URI uris[], IQuery query, Collector collector, IProgressMonitor monitor) {
61	if (query instanceof RepositoryLocationQuery) {	61	if (query instanceof RepositoryLocationQuery) {
62	query.perform(Arrays.asList(uris).iterator(), collector);	62	query.perform(Arrays.asList(uris).iterator(), collector);
63	monitor.done();	63	monitor.done();

Lines 71-77 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/ui/QueryableRepositoryManager.java (-2 / +2 lines)
71	* reporting is not desired	71	* reporting is not desired
72	* @return The collector argument	72	* @return The collector argument
73	*/	73	*/
74	public Collector query(Query query, Collector result, IProgressMonitor monitor) {	74	public Collector query(IQuery query, Collector result, IProgressMonitor monitor) {
75	IRepositoryManager manager = getRepositoryManager();	75	IRepositoryManager manager = getRepositoryManager();
76	if (manager == null) {	76	if (manager == null) {
77	ProvUI.reportStatus(new Status(IStatus.ERROR, ProvUIActivator.PLUGIN_ID, ProvUIMessages.ProvisioningUtil_NoRepositoryManager), StatusManager.SHOW \| StatusManager.LOG);	77	ProvUI.reportStatus(new Status(IStatus.ERROR, ProvUIActivator.PLUGIN_ID, ProvUIMessages.ProvisioningUtil_NoRepositoryManager), StatusManager.SHOW \| StatusManager.LOG);
Lines 229-235 Link Here
229	*/	229	*/
230	protected abstract IRepository doLoadRepository(IRepositoryManager manager, URI location, IProgressMonitor monitor) throws ProvisionException;	230	protected abstract IRepository doLoadRepository(IRepositoryManager manager, URI location, IProgressMonitor monitor) throws ProvisionException;
231		231
232	protected abstract Collector query(URI[] uris, Query query, Collector collector, IProgressMonitor monitor);	232	protected abstract Collector query(URI[] uris, IQuery query, Collector collector, IProgressMonitor monitor);
233		233
234	public void setQueryContext(IUViewQueryContext queryContext) {	234	public void setQueryContext(IUViewQueryContext queryContext) {
235	this.queryContext = queryContext;	235	this.queryContext = queryContext;

Lines 16-22 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/ui/RepositoryLocationQuery.java (-2 / +2 lines)
16	import java.net.URI;	16	import java.net.URI;
17	import java.util.Iterator;	17	import java.util.Iterator;
18	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	18	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
19	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	19	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
20	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;	20	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;
21		21
22	/**	22	/**
Lines 27-33 Link Here
27	*	27	*
28	* @since 3.5	28	* @since 3.5
29	*/	29	*/
30	public class RepositoryLocationQuery implements Query {	30	public class RepositoryLocationQuery implements IQuery {
31		31
32	/**	32	/**
33	* Gets the ID for this Query.	33	* Gets the ID for this Query.

Lines 10-16 Link Here

(-)src/org/eclipse/equinox/internal/p2/ui/sdk/scheduler/AutomaticUpdateScheduler.java (-2 / +2 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.equinox.internal.p2.ui.sdk.scheduler;	11	package org.eclipse.equinox.internal.p2.ui.sdk.scheduler;
12		12
13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
14		14
15	import com.ibm.icu.util.Calendar;	15	import com.ibm.icu.util.Calendar;
16	import com.ibm.icu.util.ULocale;	16	import com.ibm.icu.util.ULocale;
Lines 166-172 Link Here
166		166
167	}	167	}
168		168
169	private Query getProfileQuery() {	169	private IQuery getProfileQuery() {
170	// We specifically avoid going through the default policy's query provider or	170	// We specifically avoid going through the default policy's query provider or
171	// through the sdk ui bundle, so that we don't load all the p2 UI classes in doing so.	171	// through the sdk ui bundle, so that we don't load all the p2 UI classes in doing so.
172	return new IUProfilePropertyByIdQuery(IInstallableUnit.PROP_PROFILE_ROOT_IU, Boolean.toString(true));	172	return new IUProfilePropertyByIdQuery(IInstallableUnit.PROP_PROFILE_ROOT_IU, Boolean.toString(true));





import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;

import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;

import java.net.URI;
import java.text.SimpleDateFormat;

		long poll, delay;
		IUpdateListener listener;
		String profileId;
		IQuery query;

		UpdateCheckThread(String profileId, IQuery query, long delay, long poll, IUpdateListener listener) {
			this.poll = poll;
			this.delay = delay;
			this.profileId = profileId;

	/* (non-Javadoc)
	 * @see org.eclipse.equinox.internal.provisional.p2.updatechecker.IUpdateChecker#addUpdateCheck(java.lang.String, long, long, org.eclipse.equinox.internal.provisional.p2.updatechecker.IUpdateListener)
	 */
	public void addUpdateCheck(String profileId, IQuery query, long delay, long poll, IUpdateListener listener) {
		if (checkers.containsKey(listener))
			return;
		trace("Adding update checker for " + profileId + " at " + getTimeStamp()); //$NON-NLS-1$ //$NON-NLS-2$

	 * Return the array of ius in the profile that have updates
	 * available.
	 */
	IInstallableUnit[] checkForUpdates(String profileId, IQuery query) {
		IProfile profile = getProfileRegistry().getProfile(profileId);
		ArrayList iusWithUpdates = new ArrayList();
		if (profile == null)




 *******************************************************************************/
package org.eclipse.equinox.internal.provisional.p2.updatechecker;

import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;

/**
 * An update checker periodically polls for updates to specified profiles and

	 * @param listener The listener to be notified of updates
	 * @see #removeUpdateCheck(IUpdateListener)
	 */
	public abstract void addUpdateCheck(String profileId, IQuery iusToCheckQuery, long delay, long poll, IUpdateListener listener);

	/**
	 * Removes an update listener from the set of listeners registered with this update

	 * no effect.
	 * 
	 * @param listener The listener to remove
	 * @see #addUpdateCheck(String, IQuery, long, long, IUpdateListener)
	 */
	public abstract void removeUpdateCheck(IUpdateListener listener);





		String id = feature.getFeatureIdentifier() + ".feature.group"; //$NON-NLS-1$
		String versionString = feature.getFeatureVersion();
		Version version = versionString != null && versionString.length() > 0 ? Version.create(versionString) : Version.emptyVersion;
		IQuery query = null;
		Collector collector = null;
		if (version.equals(Version.emptyVersion)) {
			query = new PipedQuery(new IQuery[] {new InstallableUnitQuery(id), new LatestIUVersionQuery()});
			collector = new Collector();
		} else if (version.getQualifier() != null && version.getQualifier().endsWith(QUALIFIER)) {
			final String v = versionString.substring(0, versionString.indexOf(QUALIFIER));
			IQuery qualifierQuery = new InstallableUnitQuery(id) {
				private String qualifierVersion = v.endsWith(".") ? v.substring(0, v.length() - 1) : v; //$NON-NLS-1$

				public boolean isMatch(Object object) {

					return false;
				}
			};
			query = new PipedQuery(new IQuery[] {qualifierQuery, new LatestIUVersionQuery()});
			collector = new Collector();
		} else {
			query = new InstallableUnitQuery(id, version);




import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.equinox.internal.provisional.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepository;

public class UpdateSiteMetadataRepository implements IMetadataRepository {

		throw new UnsupportedOperationException("Repository not modifiable: " + location); //$NON-NLS-1$
	}

	public boolean removeInstallableUnits(IQuery query, IProgressMonitor monitor) {
		throw new UnsupportedOperationException("Repository not modifiable: " + location); //$NON-NLS-1$
	}


		return delegate.getAdapter(adapter);
	}

	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
		return delegate.query(query, collector, monitor);
	}
}

Return to bug 293339

Lines 405-411 Link Here

(-)src/org/eclipse/equinox/internal/p2/director/app/Application.java (-3 / +3 lines)
405		405
406	IProfile profile = initializeProfile();	406	IProfile profile = initializeProfile();
407	query = new InstallableUnitQuery(root, version == null ? VersionRange.emptyRange : new VersionRange(version, true, version, true));	407	query = new InstallableUnitQuery(root, version == null ? VersionRange.emptyRange : new VersionRange(version, true, version, true));
408	roots = collectRootIUs(metadataRepositoryLocations, new PipedQuery(new Query[] {query, new LatestIUVersionQuery()}), new Collector());	408	roots = collectRootIUs(metadataRepositoryLocations, new PipedQuery(new IQuery[] {query, new LatestIUVersionQuery()}), new Collector());
409	if (roots.size() <= 0)	409	if (roots.size() <= 0)
410	roots = profile.query(query, roots, new NullProgressMonitor());	410	roots = profile.query(query, roots, new NullProgressMonitor());
411	if (roots.size() <= 0) {	411	if (roots.size() <= 0) {
Lines 484-495 Link Here
484	this.location = location;	484	this.location = location;
485	}	485	}
486		486
487	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	487	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
488	return ProvisioningHelper.getInstallableUnits(location, query, collector, monitor);	488	return ProvisioningHelper.getInstallableUnits(location, query, collector, monitor);
489	}	489	}
490	}	490	}
491		491
492	private Collector collectRootIUs(URI[] locations, Query query, Collector collector) {	492	private Collector collectRootIUs(URI[] locations, IQuery query, Collector collector) {
493	IProgressMonitor nullMonitor = new NullProgressMonitor();	493	IProgressMonitor nullMonitor = new NullProgressMonitor();
494		494
495	if (locations == null \|\| locations.length == 0)	495	if (locations == null \|\| locations.length == 0)

Lines 201-207 Link Here

(-)src/org/eclipse/equinox/internal/p2/director/SimplePlanner.java (-3 / +3 lines)
201	}	201	}
202		202
203	public static IInstallableUnit[] findPlannerMarkedIUs(final IProfile profile) {	203	public static IInstallableUnit[] findPlannerMarkedIUs(final IProfile profile) {
204	Query markerQuery = new MatchQuery() {	204	IQuery markerQuery = new MatchQuery() {
205	public boolean isMatch(Object candidate) {	205	public boolean isMatch(Object candidate) {
206	if (!(candidate instanceof IInstallableUnit))	206	if (!(candidate instanceof IInstallableUnit))
207	return false;	207	return false;
Lines 718-724 Link Here
718	profile = p;	718	profile = p;
719	}	719	}
720		720
721	public Collector available(Query query, Collector collector, IProgressMonitor monitor) {	721	public Collector available(IQuery query, Collector collector, IProgressMonitor monitor) {
722	return profile.available(query, collector, monitor);	722	return profile.available(query, collector, monitor);
723	}	723	}
724		724
Lines 772-778 Link Here
772	return profile.isRootProfile();	772	return profile.isRootProfile();
773	}	773	}
774		774
775	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	775	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
776	return profile.query(query, collector, monitor);	776	return profile.query(query, collector, monitor);
777	}	777	}
778	}	778	}

Lines 51-57 Link Here

(-)src/org/eclipse/equinox/internal/p2/director/app/DirectorApplication.java (-6 / +6 lines)
51	Assert.isNotNull(location);	51	Assert.isNotNull(location);
52	}	52	}
53		53
54	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	54	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
55	return getInstallableUnits(location, query, collector, monitor);	55	return getInstallableUnits(location, query, collector, monitor);
56	}	56	}
57	}	57	}
Lines 225-231 Link Here
225	}	225	}
226	}	226	}
227		227
228	private Collector collectRootIUs(Query query, Collector collector) {	228	private Collector collectRootIUs(IQuery query, Collector collector) {
229	IProgressMonitor nullMonitor = new NullProgressMonitor();	229	IProgressMonitor nullMonitor = new NullProgressMonitor();
230		230
231	int top = metadataRepositoryLocations.size();	231	int top = metadataRepositoryLocations.size();
Lines 245-254 Link Here
245	for (int i = 0; i < top; ++i) {	245	for (int i = 0; i < top; ++i) {
246	IVersionedId rootName = (IVersionedId) rootNames.get(i);	246	IVersionedId rootName = (IVersionedId) rootNames.get(i);
247	Version v = rootName.getVersion();	247	Version v = rootName.getVersion();
248	Query query = new InstallableUnitQuery(rootName.getId(), Version.emptyVersion.equals(v) ? VersionRange.emptyRange : new VersionRange(v, true, v, true));	248	IQuery query = new InstallableUnitQuery(rootName.getId(), Version.emptyVersion.equals(v) ? VersionRange.emptyRange : new VersionRange(v, true, v, true));
249	Collector roots;	249	Collector roots;
250	if (forInstall)	250	if (forInstall)
251	roots = collectRootIUs(new PipedQuery(new Query[] {query, new LatestIUVersionQuery()}), new Collector());	251	roots = collectRootIUs(new PipedQuery(new IQuery[] {query, new LatestIUVersionQuery()}), new Collector());
252	else	252	else
253	roots = new Collector();	253	roots = new Collector();
254	if (roots.size() <= 0)	254	if (roots.size() <= 0)
Lines 471-477 Link Here
471	while (r.hasNext()) {	471	while (r.hasNext()) {
472	IVersionedId rootName = (IVersionedId) r.next();	472	IVersionedId rootName = (IVersionedId) r.next();
473	Version v = rootName.getVersion();	473	Version v = rootName.getVersion();
474	Query query = new InstallableUnitQuery(rootName.getId(), Version.emptyVersion.equals(v) ? VersionRange.emptyRange : new VersionRange(v, true, v, true));	474	IQuery query = new InstallableUnitQuery(rootName.getId(), Version.emptyVersion.equals(v) ? VersionRange.emptyRange : new VersionRange(v, true, v, true));
475	Collector roots = collectRootIUs(query, null);	475	Collector roots = collectRootIUs(query, null);
476	allRoots.addAll(roots.toCollection());	476	allRoots.addAll(roots.toCollection());
477	}	477	}
Lines 773-779 Link Here
773	strm.print(' ');	773	strm.print(' ');
774	}	774	}
775		775
776	Collector getInstallableUnits(URI location, Query query, Collector collector, IProgressMonitor monitor) {	776	Collector getInstallableUnits(URI location, IQuery query, Collector collector, IProgressMonitor monitor) {
777	IQueryable queryable = null;	777	IQueryable queryable = null;
778	if (location == null) {	778	if (location == null) {
779	queryable = metadataManager;	779	queryable = metadataManager;

Lines 44-50 Link Here

(-)src/org/eclipse/equinox/internal/p2/engine/SurrogateProfileHandler.java (-4 / +4 lines)
44	private SoftReference cachedProfile;	44	private SoftReference cachedProfile;
45		45
46	private static void addSharedProfileBaseIUs(final IProfile sharedProfile, final Profile userProfile) {	46	private static void addSharedProfileBaseIUs(final IProfile sharedProfile, final Profile userProfile) {
47	Query rootIUQuery = new MatchQuery() {	47	IQuery rootIUQuery = new MatchQuery() {
48	public boolean isMatch(Object candidate) {	48	public boolean isMatch(Object candidate) {
49	if (candidate instanceof IInstallableUnit) {	49	if (candidate instanceof IInstallableUnit) {
50	IInstallableUnit iu = (IInstallableUnit) candidate;	50	IInstallableUnit iu = (IInstallableUnit) candidate;
Lines 67-73 Link Here
67	}	67	}
68		68
69	private static void removeUserProfileBaseIUs(final Profile userProfile) {	69	private static void removeUserProfileBaseIUs(final Profile userProfile) {
70	Query rootIUQuery = new MatchQuery() {	70	IQuery rootIUQuery = new MatchQuery() {
71	public boolean isMatch(Object candidate) {	71	public boolean isMatch(Object candidate) {
72	if (candidate instanceof IInstallableUnit) {	72	if (candidate instanceof IInstallableUnit) {
73	IInstallableUnit iu = (IInstallableUnit) candidate;	73	IInstallableUnit iu = (IInstallableUnit) candidate;
Lines 85-91 Link Here
85	}	85	}
86		86
87	private static void markRootsOptional(final Profile userProfile) {	87	private static void markRootsOptional(final Profile userProfile) {
88	Query rootIUQuery = new MatchQuery() {	88	IQuery rootIUQuery = new MatchQuery() {
89	public boolean isMatch(Object candidate) {	89	public boolean isMatch(Object candidate) {
90	if (candidate instanceof IInstallableUnit) {	90	if (candidate instanceof IInstallableUnit) {
91	IInstallableUnit iu = (IInstallableUnit) candidate;	91	IInstallableUnit iu = (IInstallableUnit) candidate;
Lines 195-201 Link Here
195	/* (non-Javadoc)	195	/* (non-Javadoc)
196	* @see org.eclipse.equinox.internal.p2.engine.ISurrogateProfileHandler#queryProfile(org.eclipse.equinox.internal.provisional.p2.engine.IProfile, org.eclipse.equinox.internal.provisional.p2.query.Query, org.eclipse.equinox.internal.provisional.p2.query.Collector, org.eclipse.core.runtime.IProgressMonitor)	196	* @see org.eclipse.equinox.internal.p2.engine.ISurrogateProfileHandler#queryProfile(org.eclipse.equinox.internal.provisional.p2.engine.IProfile, org.eclipse.equinox.internal.provisional.p2.query.Query, org.eclipse.equinox.internal.provisional.p2.query.Collector, org.eclipse.core.runtime.IProgressMonitor)
197	*/	197	*/
198	public Collector queryProfile(IProfile profile, Query query, Collector collector, IProgressMonitor monitor) {	198	public Collector queryProfile(IProfile profile, IQuery query, Collector collector, IProgressMonitor monitor) {
199	IProfile sharedProfile = getSharedProfile(profile.getProfileId());	199	IProfile sharedProfile = getSharedProfile(profile.getProfileId());
200	if (sharedProfile != null)	200	if (sharedProfile != null)
201	sharedProfile.query(query, collector, monitor);	201	sharedProfile.query(query, collector, monitor);

Lines 20-34 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/metadata/query/CompoundQuery.java (-9 / +9 lines)
20	* In a CompoundQuery each sub-query is executed and the results are combined using	20	* In a CompoundQuery each sub-query is executed and the results are combined using
21	* either logical AND or logical OR operations. <P>	21	* either logical AND or logical OR operations. <P>
22	*	22	*
23	* Clients are expected to call {@link CompoundQuery#createCompoundQuery(Query[], boolean)}	23	* Clients are expected to call {@link CompoundQuery#createCompoundQuery(IQuery[], boolean)}
24	* to create a concrete instance of a CompoundQuery. If all Queries are instances of	24	* to create a concrete instance of a CompoundQuery. If all Queries are instances of
25	* {@link IMatchQuery} then the resulting compound query will be a MatchCompoundQuery, otherwise the	25	* {@link IMatchQuery} then the resulting compound query will be a MatchCompoundQuery, otherwise the
26	* resulting compound query will be a {@link ContextQuery}.	26	* resulting compound query will be a {@link ContextQuery}.
27	*	27	*
28	* @noextend This class is not intended to be subclassed by clients.	28	* @noextend This class is not intended to be subclassed by clients.
29	*/	29	*/
30	public abstract class CompoundQuery implements Query {	30	public abstract class CompoundQuery implements IQuery {
31	protected Query[] queries;	31	protected IQuery[] queries;
32	protected boolean and;	32	protected boolean and;
33		33
34	/**	34	/**
Lines 45-51 Link Here
45	* @param and <code>true</code> if this query represents a logical 'and', and	45	* @param and <code>true</code> if this query represents a logical 'and', and
46	* <code>false</code> if this query represents a logical 'or'.	46	* <code>false</code> if this query represents a logical 'or'.
47	*/	47	*/
48	public static CompoundQuery createCompoundQuery(Query[] queries, boolean and) {	48	public static CompoundQuery createCompoundQuery(IQuery[] queries, boolean and) {
49	if (isMatchQueries(queries)) {	49	if (isMatchQueries(queries)) {
50	return new CompoundQuery.MatchCompoundQuery(queries, and);	50	return new CompoundQuery.MatchCompoundQuery(queries, and);
51	}	51	}
Lines 55-61 Link Here
55	/**	55	/**
56	* Returns the queries that make up this compound query	56	* Returns the queries that make up this compound query
57	*/	57	*/
58	public Query[] getQueries() {	58	public IQuery[] getQueries() {
59	return queries;	59	return queries;
60	}	60	}
61		61
Lines 69-75 Link Here
69	return and;	69	return and;
70	}	70	}
71		71
72	protected CompoundQuery(Query[] queries, boolean and) {	72	protected CompoundQuery(IQuery[] queries, boolean and) {
73	this.queries = queries;	73	this.queries = queries;
74	this.and = and;	74	this.and = and;
75	}	75	}
Lines 77-83 Link Here
77	/**	77	/**
78	* @param queries	78	* @param queries
79	*/	79	*/
80	private static boolean isMatchQueries(Query[] queries) {	80	private static boolean isMatchQueries(IQuery[] queries) {
81	for (int i = 0; i < queries.length; i++) {	81	for (int i = 0; i < queries.length; i++) {
82	if (!(queries[i] instanceof IMatchQuery)) {	82	if (!(queries[i] instanceof IMatchQuery)) {
83	return false;	83	return false;
Lines 106-112 Link Here
106	*/	106	*/
107	private static class MatchCompoundQuery extends CompoundQuery implements IMatchQuery {	107	private static class MatchCompoundQuery extends CompoundQuery implements IMatchQuery {
108		108
109	protected MatchCompoundQuery(Query[] queries, boolean and) {	109	protected MatchCompoundQuery(IQuery[] queries, boolean and) {
110	super(queries, and);	110	super(queries, and);
111	}	111	}
112		112
Lines 164-170 Link Here
164	*/	164	*/
165	private static class ContextCompoundQuery extends CompoundQuery {	165	private static class ContextCompoundQuery extends CompoundQuery {
166		166
167	protected ContextCompoundQuery(Query[] queries, boolean and) {	167	protected ContextCompoundQuery(IQuery[] queries, boolean and) {
168	super(queries, and);	168	super(queries, and);
169	}	169	}
170		170

Lines 499-511 Link Here

(-)src/org/eclipse/equinox/p2/publisher/AbstractPublisherAction.java (-3 / +3 lines)
499	* @return the first matching IU or <code>null</code> if none.	499	* @return the first matching IU or <code>null</code> if none.
500	*/	500	*/
501	protected IInstallableUnit queryForIU(IPublisherResult publisherResult, String iuId, Version version) {	501	protected IInstallableUnit queryForIU(IPublisherResult publisherResult, String iuId, Version version) {
502	Query query = null;	502	IQuery query = null;
503	Collector collector = null;	503	Collector collector = null;
504	if (version != null && !Version.emptyVersion.equals(version)) {	504	if (version != null && !Version.emptyVersion.equals(version)) {
505	query = new InstallableUnitQuery(iuId, version);	505	query = new InstallableUnitQuery(iuId, version);
506	collector = new SingleElementCollector();	506	collector = new SingleElementCollector();
507	} else {	507	} else {
508	query = new PipedQuery(new Query[] {new InstallableUnitQuery(iuId), new LatestIUVersionQuery()});	508	query = new PipedQuery(new IQuery[] {new InstallableUnitQuery(iuId), new LatestIUVersionQuery()});
509	collector = new Collector();	509	collector = new Collector();
510	}	510	}
511		511
Lines 530-536 Link Here
530	* @return The the IUs with the matching ids in the given range	530	* @return The the IUs with the matching ids in the given range
531	*/	531	*/
532	protected IInstallableUnit[] queryForIUs(IPublisherResult publisherResult, String iuId, VersionRange versionRange) {	532	protected IInstallableUnit[] queryForIUs(IPublisherResult publisherResult, String iuId, VersionRange versionRange) {
533	Query query = null;	533	IQuery query = null;
534	Collector collector = new Collector();	534	Collector collector = new Collector();
535	query = new InstallableUnitQuery(iuId, versionRange);	535	query = new InstallableUnitQuery(iuId, versionRange);
536	NullProgressMonitor progress = new NullProgressMonitor();	536	NullProgressMonitor progress = new NullProgressMonitor();

Lines 11-24 Link Here

(-)src/org/eclipse/equinox/p2/publisher/actions/RootIUResultFilterAdvice.java (-3 / +3 lines)
11		11
12	import java.util.Collection;	12	import java.util.Collection;
13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;	13	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Collector;
14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.Query;	14	import org.eclipse.equinox.internal.provisional.p2.metadata.query.IQuery;
15	import org.eclipse.equinox.p2.publisher.AbstractAdvice;	15	import org.eclipse.equinox.p2.publisher.AbstractAdvice;
16	import org.eclipse.equinox.p2.publisher.IPublisherResult;	16	import org.eclipse.equinox.p2.publisher.IPublisherResult;
17		17
18	public class RootIUResultFilterAdvice extends AbstractAdvice implements IRootIUAdvice {	18	public class RootIUResultFilterAdvice extends AbstractAdvice implements IRootIUAdvice {
19	private Query query;	19	private IQuery query;
20		20
21	public RootIUResultFilterAdvice(Query query) {	21	public RootIUResultFilterAdvice(IQuery query) {
22	this.query = query;	22	this.query = query;
23	}	23	}
24		24

Lines 100-106 Link Here

(-)src_ant/org/eclipse/equinox/p2/internal/repository/tools/tasks/IUDescription.java (-5 / +5 lines)
100	return buffer.toString();	100	return buffer.toString();
101	}	101	}
102		102
103	public Query createQuery() {	103	public IQuery createQuery() {
104	List queries = new ArrayList();	104	List queries = new ArrayList();
105	if (id != null) {	105	if (id != null) {
106	if (version == null \|\| version.length() == 0) {	106	if (version == null \|\| version.length() == 0) {
Lines 113-128 Link Here
113	}	113	}
114	}	114	}
115		115
116	Query iuQuery = processQueryString();	116	IQuery iuQuery = processQueryString();
117	if (iuQuery != null)	117	if (iuQuery != null)
118	queries.add(iuQuery);	118	queries.add(iuQuery);
119		119
120	if (queries.size() == 1)	120	if (queries.size() == 1)
121	return (Query) queries.get(0);	121	return (IQuery) queries.get(0);
122	return new PipedQuery((Query[]) queries.toArray(new Query[queries.size()]));	122	return new PipedQuery((IQuery[]) queries.toArray(new IQuery[queries.size()]));
123	}	123	}
124		124
125	private Query processQueryString() {	125	private IQuery processQueryString() {
126	if (queryString == null)	126	if (queryString == null)
127	return null;	127	return null;
128	int startIdx = queryString.indexOf('[');	128	int startIdx = queryString.indexOf('[');

Lines 28-41 Link Here

(-)src/org/eclipse/equinox/p2/tests/core/AggregateQueryTest.java (-35 / +35 lines)
28	}	28	}
29		29
30	public void testEmptyCompositeQuery() {	30	public void testEmptyCompositeQuery() {
31	PipedQuery query = new PipedQuery(new Query[0]);	31	PipedQuery query = new PipedQuery(new IQuery[0]);
32	query.perform(getABCDE().iterator(), new Collector());	32	query.perform(getABCDE().iterator(), new Collector());
33	// We should not throw an exception. No guarantee on what perform	33	// We should not throw an exception. No guarantee on what perform
34	// will return in this case	34	// will return in this case
35	}	35	}
36		36
37	public void testSymmetry() {	37	public void testSymmetry() {
38	Query getLatest = new ContextQuery() {	38	IQuery getLatest = new ContextQuery() {
39		39
40	public Collector perform(Iterator iterator, Collector result) {	40	public Collector perform(Iterator iterator, Collector result) {
41	List list = new ArrayList();	41	List list = new ArrayList();
Lines 48-54 Link Here
48	}	48	}
49	};	49	};
50		50
51	Query getAllBut3 = new ContextQuery() {	51	IQuery getAllBut3 = new ContextQuery() {
52		52
53	public Collector perform(Iterator iterator, Collector result) {	53	public Collector perform(Iterator iterator, Collector result) {
54	while (iterator.hasNext()) {	54	while (iterator.hasNext()) {
Lines 60-78 Link Here
60	}	60	}
61	};	61	};
62		62
63	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {getLatest, getAllBut3}, true);	63	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getLatest, getAllBut3}, true);
64	Collector result = compoundQuery.perform(get123().iterator(), new Collector());	64	Collector result = compoundQuery.perform(get123().iterator(), new Collector());
65	assertEquals(0, result.size());	65	assertEquals(0, result.size());
66		66
67	compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {getAllBut3, getLatest}, true);	67	compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getAllBut3, getLatest}, true);
68	result = compoundQuery.perform(get123().iterator(), new Collector());	68	result = compoundQuery.perform(get123().iterator(), new Collector());
69	assertEquals(0, result.size());	69	assertEquals(0, result.size());
70		70
71	compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {getLatest, getAllBut3}, false);	71	compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getLatest, getAllBut3}, false);
72	result = compoundQuery.perform(get123().iterator(), new Collector());	72	result = compoundQuery.perform(get123().iterator(), new Collector());
73	assertEquals(3, result.size());	73	assertEquals(3, result.size());
74		74
75	compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {getAllBut3, getLatest}, false);	75	compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {getAllBut3, getLatest}, false);
76	result = compoundQuery.perform(get123().iterator(), new Collector());	76	result = compoundQuery.perform(get123().iterator(), new Collector());
77	assertEquals(3, result.size());	77	assertEquals(3, result.size());
78		78
Lines 83-89 Link Here
83	* This method tests that	83	* This method tests that
84	*/	84	*/
85	public void testNonSymmetry() {	85	public void testNonSymmetry() {
86	Query getLatest = new ContextQuery() {	86	IQuery getLatest = new ContextQuery() {
87		87
88	public Collector perform(Iterator iterator, Collector result) {	88	public Collector perform(Iterator iterator, Collector result) {
89	List list = new ArrayList();	89	List list = new ArrayList();
Lines 96-102 Link Here
96	}	96	}
97	};	97	};
98		98
99	Query getAllBut3 = new ContextQuery() {	99	IQuery getAllBut3 = new ContextQuery() {
100		100
101	public Collector perform(Iterator iterator, Collector result) {	101	public Collector perform(Iterator iterator, Collector result) {
102	while (iterator.hasNext()) {	102	while (iterator.hasNext()) {
Lines 108-118 Link Here
108	}	108	}
109	};	109	};
110		110
111	PipedQuery compoundQuery = new PipedQuery(new Query[] {getLatest, getAllBut3});	111	PipedQuery compoundQuery = new PipedQuery(new IQuery[] {getLatest, getAllBut3});
112	Collector result = compoundQuery.perform(get123().iterator(), new Collector());	112	Collector result = compoundQuery.perform(get123().iterator(), new Collector());
113	assertEquals(0, result.size());	113	assertEquals(0, result.size());
114		114
115	compoundQuery = new PipedQuery(new Query[] {getAllBut3, getLatest});	115	compoundQuery = new PipedQuery(new IQuery[] {getAllBut3, getLatest});
116	result = compoundQuery.perform(get123().iterator(), new Collector());	116	result = compoundQuery.perform(get123().iterator(), new Collector());
117	assertEquals(1, result.size());	117	assertEquals(1, result.size());
118	assertEquals("2", result.toCollection().iterator().next());	118	assertEquals("2", result.toCollection().iterator().next());
Lines 120-141 Link Here
120	}	120	}
121		121
122	public void testCompoundAllMatchQueries() {	122	public void testCompoundAllMatchQueries() {
123	Query A = new MatchQuery() {	123	IQuery A = new MatchQuery() {
124	public boolean isMatch(Object candidate) {	124	public boolean isMatch(Object candidate) {
125	return false;	125	return false;
126	}	126	}
127	};	127	};
128	Query B = new MatchQuery() {	128	IQuery B = new MatchQuery() {
129	public boolean isMatch(Object candidate) {	129	public boolean isMatch(Object candidate) {
130	return false;	130	return false;
131	}	131	}
132	};	132	};
133	Query C = new MatchQuery() {	133	IQuery C = new MatchQuery() {
134	public boolean isMatch(Object candidate) {	134	public boolean isMatch(Object candidate) {
135	return false;	135	return false;
136	}	136	}
137	};	137	};
138	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {A, B, C}, true);	138	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
139	assertTrue("1.0", compoundQuery instanceof IMatchQuery);	139	assertTrue("1.0", compoundQuery instanceof IMatchQuery);
140	assertEquals("1.1", 3, compoundQuery.getQueries().length);	140	assertEquals("1.1", 3, compoundQuery.getQueries().length);
141	assertEquals("1.2", A, compoundQuery.getQueries()[0]);	141	assertEquals("1.2", A, compoundQuery.getQueries()[0]);
Lines 144-166 Link Here
144	}	144	}
145		145
146	public void testCompoundSomeMatchQueries() {	146	public void testCompoundSomeMatchQueries() {
147	Query A = new MatchQuery() {	147	IQuery A = new MatchQuery() {
148	public boolean isMatch(Object candidate) {	148	public boolean isMatch(Object candidate) {
149	return false;	149	return false;
150	}	150	}
151	};	151	};
152	Query B = new ContextQuery() {	152	IQuery B = new ContextQuery() {
153	public Collector perform(Iterator iterator, Collector result) {	153	public Collector perform(Iterator iterator, Collector result) {
154	// TODO Auto-generated method stub	154	// TODO Auto-generated method stub
155	return null;	155	return null;
156	}	156	}
157	};	157	};
158	Query C = new MatchQuery() {	158	IQuery C = new MatchQuery() {
159	public boolean isMatch(Object candidate) {	159	public boolean isMatch(Object candidate) {
160	return false;	160	return false;
161	}	161	}
162	};	162	};
163	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {A, B, C}, true);	163	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
164	assertTrue("1.0", !(compoundQuery instanceof IMatchQuery));	164	assertTrue("1.0", !(compoundQuery instanceof IMatchQuery));
165	assertEquals("1.1", 3, compoundQuery.getQueries().length);	165	assertEquals("1.1", 3, compoundQuery.getQueries().length);
166	assertEquals("1.2", A, compoundQuery.getQueries()[0]);	166	assertEquals("1.2", A, compoundQuery.getQueries()[0]);
Lines 169-193 Link Here
169	}	169	}
170		170
171	public void testCompoundNoMatchQueries() {	171	public void testCompoundNoMatchQueries() {
172	Query A = new ContextQuery() {	172	IQuery A = new ContextQuery() {
173	public Collector perform(Iterator iterator, Collector result) {	173	public Collector perform(Iterator iterator, Collector result) {
174	// TODO Auto-generated method stub	174	// TODO Auto-generated method stub
175	return null;	175	return null;
176	}	176	}
177	};	177	};
178	Query B = new ContextQuery() {	178	IQuery B = new ContextQuery() {
179	public Collector perform(Iterator iterator, Collector result) {	179	public Collector perform(Iterator iterator, Collector result) {
180	// TODO Auto-generated method stub	180	// TODO Auto-generated method stub
181	return null;	181	return null;
182	}	182	}
183	};	183	};
184	Query C = new ContextQuery() {	184	IQuery C = new ContextQuery() {
185	public Collector perform(Iterator iterator, Collector result) {	185	public Collector perform(Iterator iterator, Collector result) {
186	// TODO Auto-generated method stub	186	// TODO Auto-generated method stub
187	return null;	187	return null;
188	}	188	}
189	};	189	};
190	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {A, B, C}, true);	190	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {A, B, C}, true);
191	assertTrue("1.0", !(compoundQuery instanceof IMatchQuery));	191	assertTrue("1.0", !(compoundQuery instanceof IMatchQuery));
192	assertEquals("1.1", 3, compoundQuery.getQueries().length);	192	assertEquals("1.1", 3, compoundQuery.getQueries().length);
193	assertEquals("1.2", A, compoundQuery.getQueries()[0]);	193	assertEquals("1.2", A, compoundQuery.getQueries()[0]);
Lines 196-202 Link Here
196	}	196	}
197		197
198	public void testIntersection() {	198	public void testIntersection() {
199	Query ABC = new MatchQuery() {	199	IQuery ABC = new MatchQuery() {
200	public boolean isMatch(Object candidate) {	200	public boolean isMatch(Object candidate) {
201	if (candidate.equals("A") \|\| candidate.equals("B") \|\| candidate.equals("C"))	201	if (candidate.equals("A") \|\| candidate.equals("B") \|\| candidate.equals("C"))
202	return true;	202	return true;
Lines 204-210 Link Here
204	}	204	}
205	};	205	};
206		206
207	Query BCDE = new MatchQuery() {	207	IQuery BCDE = new MatchQuery() {
208	public boolean isMatch(Object candidate) {	208	public boolean isMatch(Object candidate) {
209	if (candidate.equals("B") \|\| candidate.equals("C") \|\| candidate.equals("D") \|\| candidate.equals("E"))	209	if (candidate.equals("B") \|\| candidate.equals("C") \|\| candidate.equals("D") \|\| candidate.equals("E"))
210	return true;	210	return true;
Lines 212-218 Link Here
212	}	212	}
213	};	213	};
214		214
215	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {ABC, BCDE}, true);	215	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, true);
216	Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());	216	Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
217	assertEquals("1.0", result.size(), 2);	217	assertEquals("1.0", result.size(), 2);
218	assertTrue("1.1", result.toCollection().contains("B"));	218	assertTrue("1.1", result.toCollection().contains("B"));
Lines 220-226 Link Here
220	}	220	}
221		221
222	public void testIntersection2() {	222	public void testIntersection2() {
223	Query ABC = new ContextQuery() {	223	IQuery ABC = new ContextQuery() {
224	public Collector perform(Iterator iterator, Collector result) {	224	public Collector perform(Iterator iterator, Collector result) {
225	while (iterator.hasNext()) {	225	while (iterator.hasNext()) {
226	Object o = iterator.next();	226	Object o = iterator.next();
Lines 231-237 Link Here
231	}	231	}
232	};	232	};
233		233
234	Query BCDE = new ContextQuery() {	234	IQuery BCDE = new ContextQuery() {
235	public Collector perform(Iterator iterator, Collector result) {	235	public Collector perform(Iterator iterator, Collector result) {
236	while (iterator.hasNext()) {	236	while (iterator.hasNext()) {
237	Object o = iterator.next();	237	Object o = iterator.next();
Lines 242-248 Link Here
242	}	242	}
243	};	243	};
244		244
245	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {ABC, BCDE}, true);	245	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, true);
246	Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());	246	Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
247	assertEquals("1.0", result.size(), 2);	247	assertEquals("1.0", result.size(), 2);
248	assertTrue("1.1", result.toCollection().contains("B"));	248	assertTrue("1.1", result.toCollection().contains("B"));
Lines 250-256 Link Here
250	}	250	}
251		251
252	public void testUnion() {	252	public void testUnion() {
253	Query ABC = new MatchQuery() {	253	IQuery ABC = new MatchQuery() {
254	public boolean isMatch(Object candidate) {	254	public boolean isMatch(Object candidate) {
255	if (candidate.equals("A") \|\| candidate.equals("B") \|\| candidate.equals("C"))	255	if (candidate.equals("A") \|\| candidate.equals("B") \|\| candidate.equals("C"))
256	return true;	256	return true;
Lines 258-264 Link Here
258	}	258	}
259	};	259	};
260		260
261	Query BCDE = new MatchQuery() {	261	IQuery BCDE = new MatchQuery() {
262	public boolean isMatch(Object candidate) {	262	public boolean isMatch(Object candidate) {
263	if (candidate.equals("B") \|\| candidate.equals("C") \|\| candidate.equals("D") \|\| candidate.equals("E"))	263	if (candidate.equals("B") \|\| candidate.equals("C") \|\| candidate.equals("D") \|\| candidate.equals("E"))
264	return true;	264	return true;
Lines 266-272 Link Here
266	}	266	}
267	};	267	};
268		268
269	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {ABC, BCDE}, false);	269	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, false);
270	Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());	270	Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
271	assertEquals("1.0", result.size(), 5);	271	assertEquals("1.0", result.size(), 5);
272	assertTrue("1.1", result.toCollection().contains("A"));	272	assertTrue("1.1", result.toCollection().contains("A"));
Lines 277-283 Link Here
277	}	277	}
278		278
279	public void testUnion2() {	279	public void testUnion2() {
280	Query ABC = new ContextQuery() {	280	IQuery ABC = new ContextQuery() {
281	public Collector perform(Iterator iterator, Collector result) {	281	public Collector perform(Iterator iterator, Collector result) {
282	while (iterator.hasNext()) {	282	while (iterator.hasNext()) {
283	Object o = iterator.next();	283	Object o = iterator.next();
Lines 288-294 Link Here
288	}	288	}
289	};	289	};
290		290
291	Query BCDE = new ContextQuery() {	291	IQuery BCDE = new ContextQuery() {
292	public Collector perform(Iterator iterator, Collector result) {	292	public Collector perform(Iterator iterator, Collector result) {
293	while (iterator.hasNext()) {	293	while (iterator.hasNext()) {
294	Object o = iterator.next();	294	Object o = iterator.next();
Lines 299-305 Link Here
299	}	299	}
300	};	300	};
301		301
302	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new Query[] {ABC, BCDE}, false);	302	CompoundQuery compoundQuery = CompoundQuery.createCompoundQuery(new IQuery[] {ABC, BCDE}, false);
303	Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());	303	Collector result = compoundQuery.perform(getABCDE().iterator(), new Collector());
304	assertEquals("1.0", result.size(), 5);	304	assertEquals("1.0", result.size(), 5);
305	assertTrue("1.1", result.toCollection().contains("A"));	305	assertTrue("1.1", result.toCollection().contains("A"));

Lines 24-30 Link Here

(-)src/org/eclipse/equinox/p2/tests/ui/query/QueryDescriptorTest.java (-3 / +3 lines)
24	class SimpleQueryable implements IQueryable {	24	class SimpleQueryable implements IQueryable {
25	List elements = Arrays.asList(new String[] {"a", "b", "c", "d", "e"});	25	List elements = Arrays.asList(new String[] {"a", "b", "c", "d", "e"});
26		26
27	public Collector query(Query query, Collector collector, IProgressMonitor monitor) {	27	public Collector query(IQuery query, Collector collector, IProgressMonitor monitor) {
28	return query.perform(elements.iterator(), collector);	28	return query.perform(elements.iterator(), collector);
29	}	29	}
30	}	30	}
Lines 98-104 Link Here
98	}	98	}
99		99
100	public void testCompoundDescriptorAND() {	100	public void testCompoundDescriptorAND() {
101	Query query = CompoundQuery.createCompoundQuery(new Query[] {new SimpleMatchQuery(), new SimpleMatchQuery2()}, true);	101	IQuery query = CompoundQuery.createCompoundQuery(new IQuery[] {new SimpleMatchQuery(), new SimpleMatchQuery2()}, true);
102	ElementQueryDescriptor eqDescriptor = new ElementQueryDescriptor(new SimpleQueryable(), query, new Collector(), new StringWrapper());	102	ElementQueryDescriptor eqDescriptor = new ElementQueryDescriptor(new SimpleQueryable(), query, new Collector(), new StringWrapper());
103	Collection collection = eqDescriptor.performQuery(null);	103	Collection collection = eqDescriptor.performQuery(null);
104	assertEquals("1.0", 1, collection.size());	104	assertEquals("1.0", 1, collection.size());
Lines 106-112 Link Here
106	}	106	}
107		107
108	public void testCompoundDescriptorOR() {	108	public void testCompoundDescriptorOR() {
109	Query query = CompoundQuery.createCompoundQuery(new Query[] {new SimpleMatchQuery(), new SimpleMatchQuery2()}, false);	109	IQuery query = CompoundQuery.createCompoundQuery(new IQuery[] {new SimpleMatchQuery(), new SimpleMatchQuery2()}, false);
110	ElementQueryDescriptor eqDescriptor = new ElementQueryDescriptor(new SimpleQueryable(), query, new Collector(), new StringWrapper());	110	ElementQueryDescriptor eqDescriptor = new ElementQueryDescriptor(new SimpleQueryable(), query, new Collector(), new StringWrapper());
111	Collection collection = eqDescriptor.performQuery(null);	111	Collection collection = eqDescriptor.performQuery(null);
112	assertEquals("1.0", 3, collection.size());	112	assertEquals("1.0", 3, collection.size());

Lines 37-43 Link Here

(-)src/org/eclipse/equinox/internal/p2/ui/DefaultQueryProvider.java (-11 / +11 lines)
37		37
38	private Policy policy;	38	private Policy policy;
39		39
40	private Query allQuery = new MatchQuery() {	40	private IQuery allQuery = new MatchQuery() {
41	public boolean isMatch(Object candidate) {	41	public boolean isMatch(Object candidate) {
42	return true;	42	return true;
43	}	43	}
Lines 85-99 Link Here
85	}	85	}
86	}	86	}
87		87
88	Query topLevelQuery = new IUPropertyQuery(context.getVisibleAvailableIUProperty(), Boolean.TRUE.toString());	88	IQuery topLevelQuery = new IUPropertyQuery(context.getVisibleAvailableIUProperty(), Boolean.TRUE.toString());
89	Query categoryQuery = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_CATEGORY, Boolean.toString(true));	89	IQuery categoryQuery = new IUPropertyQuery(IInstallableUnit.PROP_TYPE_CATEGORY, Boolean.toString(true));
90		90
91	// Showing child IU's of a group of repositories, or of a single repository	91	// Showing child IU's of a group of repositories, or of a single repository
92	if (element instanceof MetadataRepositories \|\| element instanceof MetadataRepositoryElement) {	92	if (element instanceof MetadataRepositories \|\| element instanceof MetadataRepositoryElement) {
93	if (context.getViewType() == IUViewQueryContext.AVAILABLE_VIEW_FLAT \|\| !context.getUseCategories()) {	93	if (context.getViewType() == IUViewQueryContext.AVAILABLE_VIEW_FLAT \|\| !context.getUseCategories()) {
94	AvailableIUWrapper wrapper = new AvailableIUWrapper(queryable, element, false, context.getShowAvailableChildren());	94	AvailableIUWrapper wrapper = new AvailableIUWrapper(queryable, element, false, context.getShowAvailableChildren());
95	if (showLatest)	95	if (showLatest)
96	topLevelQuery = new PipedQuery(new Query[] {topLevelQuery, new LatestIUVersionQuery()});	96	topLevelQuery = new PipedQuery(new IQuery[] {topLevelQuery, new LatestIUVersionQuery()});
97	if (targetProfile != null)	97	if (targetProfile != null)
98	wrapper.markInstalledIUs(targetProfile, hideInstalled);	98	wrapper.markInstalledIUs(targetProfile, hideInstalled);
99	return new ElementQueryDescriptor(queryable, topLevelQuery, new Collector(), wrapper);	99	return new ElementQueryDescriptor(queryable, topLevelQuery, new Collector(), wrapper);
Lines 108-114 Link Here
108	// children of a category should drill down according to the context. If we aren't in a category, we are already drilling down and	108	// children of a category should drill down according to the context. If we aren't in a category, we are already drilling down and
109	// continue to do so.	109	// continue to do so.
110	boolean drillDown = element instanceof CategoryElement ? context.getShowAvailableChildren() : true;	110	boolean drillDown = element instanceof CategoryElement ? context.getShowAvailableChildren() : true;
111	Query meetsAnyRequirementQuery = new AnyRequiredCapabilityQuery(((IIUElement) element).getRequirements());	111	IQuery meetsAnyRequirementQuery = new AnyRequiredCapabilityQuery(((IIUElement) element).getRequirements());
112	availableIUWrapper = new AvailableIUWrapper(queryable, element, true, drillDown);	112	availableIUWrapper = new AvailableIUWrapper(queryable, element, true, drillDown);
113	if (targetProfile != null)	113	if (targetProfile != null)
114	availableIUWrapper.markInstalledIUs(targetProfile, hideInstalled);	114	availableIUWrapper.markInstalledIUs(targetProfile, hideInstalled);
Lines 116-127 Link Here
116	// be visible in the category.	116	// be visible in the category.
117	if (element instanceof CategoryElement) {	117	if (element instanceof CategoryElement) {
118	if (showLatest)	118	if (showLatest)
119	meetsAnyRequirementQuery = new PipedQuery(new Query[] {meetsAnyRequirementQuery, new LatestIUVersionQuery()});	119	meetsAnyRequirementQuery = new PipedQuery(new IQuery[] {meetsAnyRequirementQuery, new LatestIUVersionQuery()});
120	return new ElementQueryDescriptor(queryable, meetsAnyRequirementQuery, new Collector(), availableIUWrapper);	120	return new ElementQueryDescriptor(queryable, meetsAnyRequirementQuery, new Collector(), availableIUWrapper);
121	}	121	}
122	Query query = CompoundQuery.createCompoundQuery(new Query[] {topLevelQuery, meetsAnyRequirementQuery}, true);	122	IQuery query = CompoundQuery.createCompoundQuery(new IQuery[] {topLevelQuery, meetsAnyRequirementQuery}, true);
123	if (showLatest)	123	if (showLatest)
124	query = new PipedQuery(new Query[] {query, new LatestIUVersionQuery()});	124	query = new PipedQuery(new IQuery[] {query, new LatestIUVersionQuery()});
125	// If it's not a category, these are generic requirements and should be filtered by the visibility property (topLevelQuery)	125	// If it's not a category, these are generic requirements and should be filtered by the visibility property (topLevelQuery)
126	return new ElementQueryDescriptor(queryable, query, new Collector(), availableIUWrapper);	126	return new ElementQueryDescriptor(queryable, query, new Collector(), availableIUWrapper);
127	}	127	}
Lines 155-163 Link Here
155	case QueryProvider.INSTALLED_IUS :	155	case QueryProvider.INSTALLED_IUS :
156	// Querying of IU's. We are drilling down into the requirements.	156	// Querying of IU's. We are drilling down into the requirements.
157	if (element instanceof IIUElement && context.getShowInstallChildren()) {	157	if (element instanceof IIUElement && context.getShowInstallChildren()) {
158	Query meetsAnyRequirementQuery = new AnyRequiredCapabilityQuery(((IIUElement) element).getRequirements());	158	IQuery meetsAnyRequirementQuery = new AnyRequiredCapabilityQuery(((IIUElement) element).getRequirements());
159	Query visibleAsAvailableQuery = new IUPropertyQuery(context.getVisibleAvailableIUProperty(), Boolean.TRUE.toString());	159	IQuery visibleAsAvailableQuery = new IUPropertyQuery(context.getVisibleAvailableIUProperty(), Boolean.TRUE.toString());
160	return new ElementQueryDescriptor(queryable, CompoundQuery.createCompoundQuery(new Query[] {visibleAsAvailableQuery, meetsAnyRequirementQuery}, true), new Collector(), new InstalledIUElementWrapper(queryable, element));	160	return new ElementQueryDescriptor(queryable, CompoundQuery.createCompoundQuery(new IQuery[] {visibleAsAvailableQuery, meetsAnyRequirementQuery}, true), new Collector(), new InstalledIUElementWrapper(queryable, element));
161	}	161	}
162	profile = (IProfile) ProvUI.getAdapter(element, IProfile.class);	162	profile = (IProfile) ProvUI.getAdapter(element, IProfile.class);
163	if (profile == null)	163	if (profile == null)

Lines 24-30 Link Here

(-)src/org/eclipse/equinox/internal/provisional/p2/ui/ElementQueryDescriptor.java (-3 / +3 lines)
24	*/	24	*/
25	public class ElementQueryDescriptor {	25	public class ElementQueryDescriptor {
26		26
27	private Query query;	27	private IQuery query;
28	private Collector collector;	28	private Collector collector;
29	private IQueryable queryable;	29	private IQueryable queryable;
30	private ElementWrapper wrapper;	30	private ElementWrapper wrapper;
Lines 33-39 Link Here
33	* Creates an ElementQueryDescriptor to represent a Query, its collector the queryable	33	* Creates an ElementQueryDescriptor to represent a Query, its collector the queryable
34	* on which it will run.	34	* on which it will run.
35	*/	35	*/
36	public ElementQueryDescriptor(IQueryable queryable, Query query, Collector collector) {	36	public ElementQueryDescriptor(IQueryable queryable, IQuery query, Collector collector) {
37	this(queryable, query, collector, null);	37	this(queryable, query, collector, null);
38	}	38	}
39		39
Lines 41-47 Link Here
41	* Creates an ElementQueryDescriptor to represent a Query, its collector the queryable	41	* Creates an ElementQueryDescriptor to represent a Query, its collector the queryable
42	* on which it will run, and the transformer used to transform the results.	42	* on which it will run, and the transformer used to transform the results.
43	*/	43	*/
44	public ElementQueryDescriptor(IQueryable queryable, Query query, Collector collector, ElementWrapper wrapper) {	44	public ElementQueryDescriptor(IQueryable queryable, IQuery query, Collector collector, ElementWrapper wrapper) {
45	this.query = query;	45	this.query = query;
46	this.collector = collector;	46	this.collector = collector;
47	this.queryable = queryable;	47	this.queryable = queryable;

Lines 120-133 Link Here

(-)src/org/eclipse/equinox/internal/p2/updatesite/SiteXMLAction.java (-4 / +4 lines)
120	String id = feature.getFeatureIdentifier() + ".feature.group"; //$NON-NLS-1$	120	String id = feature.getFeatureIdentifier() + ".feature.group"; //$NON-NLS-1$
121	String versionString = feature.getFeatureVersion();	121	String versionString = feature.getFeatureVersion();
122	Version version = versionString != null && versionString.length() > 0 ? Version.create(versionString) : Version.emptyVersion;	122	Version version = versionString != null && versionString.length() > 0 ? Version.create(versionString) : Version.emptyVersion;
123	Query query = null;	123	IQuery query = null;
124	Collector collector = null;	124	Collector collector = null;
125	if (version.equals(Version.emptyVersion)) {	125	if (version.equals(Version.emptyVersion)) {
126	query = new PipedQuery(new Query[] {new InstallableUnitQuery(id), new LatestIUVersionQuery()});	126	query = new PipedQuery(new IQuery[] {new InstallableUnitQuery(id), new LatestIUVersionQuery()});
127	collector = new Collector();	127	collector = new Collector();
128	} else if (version.getQualifier() != null && version.getQualifier().endsWith(QUALIFIER)) {	128	} else if (version.getQualifier() != null && version.getQualifier().endsWith(QUALIFIER)) {
129	final String v = versionString.substring(0, versionString.indexOf(QUALIFIER));	129	final String v = versionString.substring(0, versionString.indexOf(QUALIFIER));
130	Query qualifierQuery = new InstallableUnitQuery(id) {	130	IQuery qualifierQuery = new InstallableUnitQuery(id) {
131	private String qualifierVersion = v.endsWith(".") ? v.substring(0, v.length() - 1) : v; //$NON-NLS-1$	131	private String qualifierVersion = v.endsWith(".") ? v.substring(0, v.length() - 1) : v; //$NON-NLS-1$
132		132
133	public boolean isMatch(Object object) {	133	public boolean isMatch(Object object) {
Lines 138-144 Link Here
138	return false;	138	return false;
139	}	139	}
140	};	140	};
141	query = new PipedQuery(new Query[] {qualifierQuery, new LatestIUVersionQuery()});	141	query = new PipedQuery(new IQuery[] {qualifierQuery, new LatestIUVersionQuery()});
142	collector = new Collector();	142	collector = new Collector();
143	} else {	143	} else {
144	query = new InstallableUnitQuery(id, version);	144	query = new InstallableUnitQuery(id, version);