Attachment #167574 for bug #222157

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




		createNegationImplication(iu, matches, explanation);
	}

	private void determinePotentialHostsForFragment(IInstallableUnit iu) {
		// determine matching hosts only for fragments
		if (!(iu instanceof IInstallableUnitFragment))
			return;

		IInstallableUnitFragment fragment = (IInstallableUnitFragment) iu;
		// for each host requirement, find matches and remember them 
		for (IRequirement req : fragment.getHost()) {
			List<IInstallableUnit> matches = getApplicableMatches(req);
			rememberHostMatches((IInstallableUnitFragment) iu, matches);
		}
	}

	private void expandRequirement(IRequirement req, IInstallableUnit iu, List<AbstractVariable> optionalAbstractRequirements, boolean isRootIu) throws ContradictionException {
		if (req.getMax() == 0) {
			expandNegatedRequirement(req, iu, optionalAbstractRequirements, isRootIu);

		if (!isApplicable(req))
			return;
		List<IInstallableUnit> matches = getApplicableMatches(req);
		determinePotentialHostsForFragment(iu);
			rememberHostMatches((IInstallableUnitFragment) iu, matches);
		}
		if (req.getMin() > 0) {
			if (matches.isEmpty()) {
				if (iu == entryPoint && emptyBecauseFiltered) {

	}

	private Collection<IRequirement> getRequiredCapabilities(IInstallableUnit iu) {
		boolean isFragment = iu instanceof IInstallableUnitFragment;
		//Short-circuit for the case of an IInstallableUnit 
		if ((!isFragment) && iu.getMetaRequirements().size() == 0)
			return iu.getRequirements();

		ArrayList<IRequirement> aggregatedRequirements = new ArrayList<IRequirement>(iu.getRequirements().size() + iu.getMetaRequirements().size() + (isFragment ? ((IInstallableUnitFragment) iu).getHost().size() : 0));
		aggregatedRequirements.addAll(iu.getRequirements());

		if (iu instanceof IInstallableUnitFragment) {
			aggregatedRequirements.addAll(((IInstallableUnitFragment) iu).getHost());
		}

		if (considerMetaRequirements)
			aggregatedRequirements.addAll(iu.getMetaRequirements());
		return aggregatedRequirements;
	}

	static final class Pending {

				if (isApplicable(reqs[i][1])) {
					IRequirement req = reqs[i][1];
					List<IInstallableUnit> matches = getApplicableMatches(req);
					determinePotentialHostsForFragment(iu);
						rememberHostMatches((IInstallableUnitFragment) iu, matches);
					}
					if (req.getMin() > 0) {
						if (matches.isEmpty()) {
							missingRequirement(patch, req);

					}

					List<IInstallableUnit> matches = getApplicableMatches(req);
					determinePotentialHostsForFragment(iu);
						rememberHostMatches((IInstallableUnitFragment) iu, matches);
					}
					if (req.getMin() > 0) {
						if (matches.isEmpty()) {
							dependencyHelper.implication(new Object[] {iu}).implies(patch).named(new Explanation.HardRequirement(iu, null));

			}
			IRequirement req = entry.getKey();
			List<IInstallableUnit> matches = getApplicableMatches(req);
			determinePotentialHostsForFragment(iu);
				rememberHostMatches((IInstallableUnitFragment) iu, matches);
			}
			if (req.getMin() > 0) {
				if (matches.isEmpty()) {
					if (requiredPatches.isEmpty()) {

		}
		existingMatches.retainAll(matches);
	}

	private boolean isHostRequirement(IInstallableUnit iu, IRequirement req) {
		if (!(iu instanceof IInstallableUnitFragment))
			return false;
		IInstallableUnitFragment fragment = (IInstallableUnitFragment) iu;
		for (IRequirement hostReqs : fragment.getHost()) {
			if (req.equals(hostReqs))
				return true;
		}
		return false;
	}

}




import org.eclipse.equinox.internal.p2.core.helpers.LogHelper;
import org.eclipse.equinox.internal.p2.core.helpers.Tracing;
import org.eclipse.equinox.internal.p2.metadata.InstallableUnit;
import org.eclipse.equinox.internal.p2.metadata.InstallableUnitPatch;
import org.eclipse.equinox.p2.metadata.*;
import org.eclipse.equinox.p2.metadata.expression.IMatchExpression;
import org.eclipse.equinox.p2.query.*;


		Map<Version, IInstallableUnit> iuSlice = slice.get(iu.getId());
		if (iuSlice == null) {

			iuSlice = new HashMap<Version, IInstallableUnit>();
			slice.put(iu.getId(), iuSlice);
		}

			return;
		}

		Collection<IRequirement> reqs = getRequirements(iu);
		if (reqs.isEmpty())
			return;
		for (IRequirement req : reqs) {

		return req.isGreedy();
	}

	private Collection<IRequirement> getRequirements(IInstallableUnit iu) {
		boolean isPatch = iu instanceof IInstallableUnitPatch;
		boolean isFragment = iu instanceof IInstallableUnitFragment;
		//Short-circuit for the case of an IInstallableUnit 
		if ((!isFragment) && (!isPatch) && iu.getMetaRequirements().size() == 0)
			return iu.getRequirements();

		ArrayList<IRequirement> aggregatedRequirements = new ArrayList<IRequirement>(iu.getRequirements().size() + iu.getMetaRequirements().size() + (isFragment ? ((IInstallableUnitFragment) iu).getHost().size() : 0) + (isPatch ? ((IInstallableUnitPatch) iu).getRequirementsChange().size() : 0));
		aggregatedRequirements.addAll(iu.getRequirements());

		if (iu instanceof IInstallableUnitFragment) {
			aggregatedRequirements.addAll(((IInstallableUnitFragment) iu).getHost());
		}

		if (iu instanceof InstallableUnitPatch) {
			IInstallableUnitPatch patchIU = (IInstallableUnitPatch) iu;
			List<IRequirementChange> changes = patchIU.getRequirementsChange();
			for (int i = 0; i < changes.size(); i++)
				aggregatedRequirements.add(changes.get(i).newValue());
		}

		if (considerMetaRequirements)
			aggregatedRequirements.addAll(iu.getMetaRequirements());
		return aggregatedRequirements;
		return aggregatedCapabilities;
	}

	private void expandRequirement(IInstallableUnit iu, IRequirement req) {

Return to bug 222157

Lines 404-409 Link Here

(-)src/org/eclipse/equinox/internal/p2/director/Projector.java (-36 / +32 lines)
404	createNegationImplication(iu, matches, explanation);	404	createNegationImplication(iu, matches, explanation);
405	}	405	}
406		406
		407	private void determinePotentialHostsForFragment(IInstallableUnit iu) {
		408	// determine matching hosts only for fragments
		409	if (!(iu instanceof IInstallableUnitFragment))
		410	return;
		411
		412	IInstallableUnitFragment fragment = (IInstallableUnitFragment) iu;
		413	// for each host requirement, find matches and remember them
		414	for (IRequirement req : fragment.getHost()) {
		415	List<IInstallableUnit> matches = getApplicableMatches(req);
		416	rememberHostMatches((IInstallableUnitFragment) iu, matches);
		417	}
		418	}
		419
407	private void expandRequirement(IRequirement req, IInstallableUnit iu, List<AbstractVariable> optionalAbstractRequirements, boolean isRootIu) throws ContradictionException {	420	private void expandRequirement(IRequirement req, IInstallableUnit iu, List<AbstractVariable> optionalAbstractRequirements, boolean isRootIu) throws ContradictionException {
408	if (req.getMax() == 0) {	421	if (req.getMax() == 0) {
409	expandNegatedRequirement(req, iu, optionalAbstractRequirements, isRootIu);	422	expandNegatedRequirement(req, iu, optionalAbstractRequirements, isRootIu);
Lines 412-420 Link Here
412	if (!isApplicable(req))	425	if (!isApplicable(req))
413	return;	426	return;
414	List<IInstallableUnit> matches = getApplicableMatches(req);	427	List<IInstallableUnit> matches = getApplicableMatches(req);
415	if (isHostRequirement(iu, req)) {	428	determinePotentialHostsForFragment(iu);
416	rememberHostMatches((IInstallableUnitFragment) iu, matches);
417	}
418	if (req.getMin() > 0) {	429	if (req.getMin() > 0) {
419	if (matches.isEmpty()) {	430	if (matches.isEmpty()) {
420	if (iu == entryPoint && emptyBecauseFiltered) {	431	if (iu == entryPoint && emptyBecauseFiltered) {
Lines 524-541 Link Here
524	}	535	}
525		536
526	private Collection<IRequirement> getRequiredCapabilities(IInstallableUnit iu) {	537	private Collection<IRequirement> getRequiredCapabilities(IInstallableUnit iu) {
527	Collection<IRequirement> rqs = iu.getRequirements();	538	boolean isFragment = iu instanceof IInstallableUnitFragment;
528	if (!considerMetaRequirements)	539	//Short-circuit for the case of an IInstallableUnit
529	return rqs;	540	if ((!isFragment) && iu.getMetaRequirements().size() == 0)
530		541	return iu.getRequirements();
531	Collection<IRequirement> metaRqs = iu.getMetaRequirements();	542
532	if (metaRqs.isEmpty())	543	ArrayList<IRequirement> aggregatedRequirements = new ArrayList<IRequirement>(iu.getRequirements().size() + iu.getMetaRequirements().size() + (isFragment ? ((IInstallableUnitFragment) iu).getHost().size() : 0));
533	return rqs;	544	aggregatedRequirements.addAll(iu.getRequirements());
534		545
535	ArrayList<IRequirement> aggregatedRqs = new ArrayList<IRequirement>(rqs.size() + metaRqs.size());	546	if (iu instanceof IInstallableUnitFragment) {
536	aggregatedRqs.addAll(rqs);	547	aggregatedRequirements.addAll(((IInstallableUnitFragment) iu).getHost());
537	aggregatedRqs.addAll(metaRqs);	548	}
538	return aggregatedRqs;	549
		550	if (considerMetaRequirements)
		551	aggregatedRequirements.addAll(iu.getMetaRequirements());
		552	return aggregatedRequirements;
539	}	553	}
540		554
541	static final class Pending {	555	static final class Pending {
Lines 585-593 Link Here
585	if (isApplicable(reqs[i][1])) {	599	if (isApplicable(reqs[i][1])) {
586	IRequirement req = reqs[i][1];	600	IRequirement req = reqs[i][1];
587	List<IInstallableUnit> matches = getApplicableMatches(req);	601	List<IInstallableUnit> matches = getApplicableMatches(req);
588	if (isHostRequirement(iu, req)) {	602	determinePotentialHostsForFragment(iu);
589	rememberHostMatches((IInstallableUnitFragment) iu, matches);
590	}
591	if (req.getMin() > 0) {	603	if (req.getMin() > 0) {
592	if (matches.isEmpty()) {	604	if (matches.isEmpty()) {
593	missingRequirement(patch, req);	605	missingRequirement(patch, req);
Lines 661-669 Link Here
661	}	673	}
662		674
663	List<IInstallableUnit> matches = getApplicableMatches(req);	675	List<IInstallableUnit> matches = getApplicableMatches(req);
664	if (isHostRequirement(iu, req)) {	676	determinePotentialHostsForFragment(iu);
665	rememberHostMatches((IInstallableUnitFragment) iu, matches);
666	}
667	if (req.getMin() > 0) {	677	if (req.getMin() > 0) {
668	if (matches.isEmpty()) {	678	if (matches.isEmpty()) {
669	dependencyHelper.implication(new Object[] {iu}).implies(patch).named(new Explanation.HardRequirement(iu, null));	679	dependencyHelper.implication(new Object[] {iu}).implies(patch).named(new Explanation.HardRequirement(iu, null));
Lines 766-774 Link Here
766	}	776	}
767	IRequirement req = entry.getKey();	777	IRequirement req = entry.getKey();
768	List<IInstallableUnit> matches = getApplicableMatches(req);	778	List<IInstallableUnit> matches = getApplicableMatches(req);
769	if (isHostRequirement(iu, req)) {	779	determinePotentialHostsForFragment(iu);
770	rememberHostMatches((IInstallableUnitFragment) iu, matches);
771	}
772	if (req.getMin() > 0) {	780	if (req.getMin() > 0) {
773	if (matches.isEmpty()) {	781	if (matches.isEmpty()) {
774	if (requiredPatches.isEmpty()) {	782	if (requiredPatches.isEmpty()) {
Lines 1176-1191 Link Here
1176	}	1184	}
1177	existingMatches.retainAll(matches);	1185	existingMatches.retainAll(matches);
1178	}	1186	}
1179
1180	private boolean isHostRequirement(IInstallableUnit iu, IRequirement req) {
1181	if (!(iu instanceof IInstallableUnitFragment))
1182	return false;
1183	IInstallableUnitFragment fragment = (IInstallableUnitFragment) iu;
1184	for (IRequirement hostReqs : fragment.getHost()) {
1185	if (req.equals(hostReqs))
1186	return true;
1187	}
1188	return false;
1189	}
1190
1191	}	1187	}

Lines 16-21 Link Here

(-)src/org/eclipse/equinox/internal/p2/director/Slicer.java (-26 / +27 lines)
16	import org.eclipse.equinox.internal.p2.core.helpers.LogHelper;	16	import org.eclipse.equinox.internal.p2.core.helpers.LogHelper;
17	import org.eclipse.equinox.internal.p2.core.helpers.Tracing;	17	import org.eclipse.equinox.internal.p2.core.helpers.Tracing;
18	import org.eclipse.equinox.internal.p2.metadata.InstallableUnit;	18	import org.eclipse.equinox.internal.p2.metadata.InstallableUnit;
		19	import org.eclipse.equinox.internal.p2.metadata.InstallableUnitPatch;
19	import org.eclipse.equinox.p2.metadata.*;	20	import org.eclipse.equinox.p2.metadata.*;
20	import org.eclipse.equinox.p2.metadata.expression.IMatchExpression;	21	import org.eclipse.equinox.p2.metadata.expression.IMatchExpression;
21	import org.eclipse.equinox.p2.query.*;	22	import org.eclipse.equinox.p2.query.*;
Lines 105-110 Link Here
105		106
106	Map<Version, IInstallableUnit> iuSlice = slice.get(iu.getId());	107	Map<Version, IInstallableUnit> iuSlice = slice.get(iu.getId());
107	if (iuSlice == null) {	108	if (iuSlice == null) {
		109
108	iuSlice = new HashMap<Version, IInstallableUnit>();	110	iuSlice = new HashMap<Version, IInstallableUnit>();
109	slice.put(iu.getId(), iuSlice);	111	slice.put(iu.getId(), iuSlice);
110	}	112	}
Lines 113-119 Link Here
113	return;	115	return;
114	}	116	}
115		117
116	Collection<IRequirement> reqs = getRequiredCapabilities(iu);	118	Collection<IRequirement> reqs = getRequirements(iu);
117	if (reqs.isEmpty())	119	if (reqs.isEmpty())
118	return;	120	return;
119	for (IRequirement req : reqs) {	121	for (IRequirement req : reqs) {
Lines 133-163 Link Here
133	return req.isGreedy();	135	return req.isGreedy();
134	}	136	}
135		137
136	private Collection<IRequirement> getRequiredCapabilities(IInstallableUnit iu) {	138	private Collection<IRequirement> getRequirements(IInstallableUnit iu) {
137	Collection<IRequirement> iuRequirements = iu.getRequirements();	139	boolean isPatch = iu instanceof IInstallableUnitPatch;
138	int initialRequirementCount = iuRequirements.size();	140	boolean isFragment = iu instanceof IInstallableUnitFragment;
139	if (!(iu instanceof IInstallableUnitPatch)) {	141	//Short-circuit for the case of an IInstallableUnit
140	if (!considerMetaRequirements)	142	if ((!isFragment) && (!isPatch) && iu.getMetaRequirements().size() == 0)
141	return iuRequirements;	143	return iu.getRequirements();
142		144
143	Collection<IRequirement> iuMetaRequirements = iu.getMetaRequirements();	145	ArrayList<IRequirement> aggregatedRequirements = new ArrayList<IRequirement>(iu.getRequirements().size() + iu.getMetaRequirements().size() + (isFragment ? ((IInstallableUnitFragment) iu).getHost().size() : 0) + (isPatch ? ((IInstallableUnitPatch) iu).getRequirementsChange().size() : 0));
144	int metaSize = iuMetaRequirements.size();	146	aggregatedRequirements.addAll(iu.getRequirements());
145	if (metaSize == 0)	147
146	return iuRequirements;	148	if (iu instanceof IInstallableUnitFragment) {
147		149	aggregatedRequirements.addAll(((IInstallableUnitFragment) iu).getHost());
148	ArrayList<IRequirement> aggregatedCapabilities = new ArrayList<IRequirement>(initialRequirementCount + metaSize);	150	}
149	aggregatedCapabilities.addAll(iuRequirements);	151
150	aggregatedCapabilities.addAll(iuMetaRequirements);	152	if (iu instanceof InstallableUnitPatch) {
151	return aggregatedCapabilities;	153	IInstallableUnitPatch patchIU = (IInstallableUnitPatch) iu;
152	}	154	List<IRequirementChange> changes = patchIU.getRequirementsChange();
153		155	for (int i = 0; i < changes.size(); i++)
154	IInstallableUnitPatch patchIU = (IInstallableUnitPatch) iu;	156	aggregatedRequirements.add(changes.get(i).newValue());
155	List<IRequirementChange> changes = patchIU.getRequirementsChange();	157	}
156	ArrayList<IRequirement> aggregatedCapabilities = new ArrayList<IRequirement>(initialRequirementCount + changes.size());	158
157	aggregatedCapabilities.addAll(iuRequirements);	159	if (considerMetaRequirements)
158	for (int i = 0; i < changes.size(); i++)	160	aggregatedRequirements.addAll(iu.getMetaRequirements());
159	aggregatedCapabilities.add(changes.get(i).newValue());	161	return aggregatedRequirements;
160	return aggregatedCapabilities;
161	}	162	}
162		163
163	private void expandRequirement(IInstallableUnit iu, IRequirement req) {	164	private void expandRequirement(IInstallableUnit iu, IRequirement req) {