/** * Creates a new query that will return any IU that meets any * one of the requirements of the specified IU. * * @param iu The IU whose requirements are to be checked */ public RequiredIUsQuery(IInstallableUnit iu) { super(IInstallableUnit.class, expression, iu.getRequirements()); } }
public Collection<IRequirement> getRequirements() { return iu.getRequirements(); }
public Collection<IRequirement> getRequirements() { return iu.getRequirements(); }
private Collection<IRequirement> allRequirements(IInstallableUnit iu) { if (!(iu instanceof IInstallableUnitPatch) && !(iu instanceof IInstallableUnitFragment)) return iu.getRequirements(); Set<IRequirement> allRequirements = new HashSet<>(iu.getRequirements()); if (iu instanceof IInstallableUnitPatch) ((IInstallableUnitPatch) iu).getRequirementsChange().stream() // .map(IRequirementChange::newValue) // .forEach(allRequirements::add); if (iu instanceof IInstallableUnitFragment) allRequirements.addAll(((IInstallableUnitFragment) iu).getHost()); return allRequirements; }
public Collection<IRequirement> getRequirements() { Collection<IRequirement> originalCapabilities = original.getRequirements(); if (fragments.length == 0) return originalCapabilities; ArrayList<IRequirement> result = new ArrayList<IRequirement>(originalCapabilities); for (int i = 0; i < fragments.length; i++) result.addAll(fragments[i].getRequirements()); return result; }
public Collection<IRequirement> getRequirements() { if (ius == null || ius.isEmpty()) return CollectionUtils.emptyList(); if (requirements == null) { if (ius.size() == 1) requirements = getIU().getRequirements(); else { ArrayList<IRequirement> capabilities = new ArrayList<IRequirement>(); for (IInstallableUnit iu : ius) { capabilities.addAll(iu.getRequirements()); } requirements = capabilities; } } return requirements; }
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<>(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; }
/** * Creates a new query that will return the members of the * given <code>category</code>. If the specified {@link IInstallableUnit} * is not a category, then no installable unit will satisfy the query. * * @param category The category * @return A query that returns category members */ public static IQuery<IInstallableUnit> createIUCategoryMemberQuery(IInstallableUnit category) { if (QueryUtil.isCategory(category)) return QueryUtil.createMatchQuery(matchesRequirementsExpression, category.getRequirements()); return NO_UNITS; }
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; }
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<>(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; }
protected boolean shouldWrap(Object match) { if (match instanceof IInstallableUnit) { IInstallableUnit iu = (IInstallableUnit) match; Collection<IRequirement> requirements = iu.getRequirements(); for (IRequirement requirement : requirements) { if (requirement instanceof IRequiredCapability) { if (((IRequiredCapability) requirement).getNamespace().equals(IInstallableUnit.NAMESPACE_IU_ID)) { referredIUs.add(((IRequiredCapability) requirement).getName()); } } } Iterator<?> iter = super.getCollection().iterator(); // Don't add the same category IU twice. while (iter.hasNext()) { CategoryElement element = (CategoryElement) iter.next(); if (element.shouldMerge(iu)) { element.mergeIU(iu); return false; } } return true; } return false; }
private static String getFragmentHost(IInstallableUnit unit, String fragmentName) { Collection<IRequirement> requires = unit.getRequirements(); for (IRequirement iRequirement : requires) { if (iRequirement instanceof IRequiredCapability) { IRequiredCapability requiredCapability = (IRequiredCapability) iRequirement; if (fragmentName.equals(requiredCapability.getName())) { String fragmentHost = requiredCapability.getName(); if (!requiredCapability.getRange().toString().equals("0.0.0")) { //$NON-NLS-1$ fragmentHost += ";bundle-version=\"" + requiredCapability.getRange() + '"'; //$NON-NLS-1$ } return fragmentHost; } } } return null; }
private static String getFragmentHost(IInstallableUnit unit, String fragmentName) { Collection<IRequirement> requires = unit.getRequirements(); for (IRequirement iRequirement : requires) { if (iRequirement instanceof IRequiredCapability) { IRequiredCapability requiredCapability = (IRequiredCapability) iRequirement; if (fragmentName.equals(requiredCapability.getName())) { String fragmentHost = requiredCapability.getName(); if (!requiredCapability.getRange().toString().equals("0.0.0")) { //$NON-NLS-1$ fragmentHost += ";bundle-version=\"" + requiredCapability.getRange() + '"'; //$NON-NLS-1$ } return fragmentHost; } } } return null; }
private void collectIncludedIUs(IQueryable<IInstallableUnit> availableIUs, Set<IInstallableUnit> result, Set<IStatus> errors, IInstallableUnit iu, boolean immediate, IProgressMonitor monitor) { // features listed in site.xml directly // features/bundles included in included features (RequiredCapability.isVersionStrict is approximation of this) for (IRequirement req : iu.getRequirements()) { IQueryResult<IInstallableUnit> matches = availableIUs .query(QueryUtil.createLatestQuery(QueryUtil.createMatchQuery(req.getMatches())), monitor); if (!matches.isEmpty()) { IInstallableUnit match = matches.iterator().next(); // can only be one if (immediate || isIncluded(iu, req, match)) { result.add(match); if (isFeature(match)) { collectIncludedIUs(availableIUs, result, errors, match, false, monitor); } } } else { errors.add(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Unable to find dependency from " + iu.toString() + " to " + req.toString())); } } }
public Collection<IUTreeViewer.IUTreeItem> getChildren() { if (children==null) { children = new ArrayList<IUTreeViewer.IUTreeItem>(); if (parent==null) { for (IRequirement r : iu.getRequirements()) { for (IInstallableUnit riu : provider.getInstallableUnits()) { if (r.isMatch(riu)) { IMatchExpression<IInstallableUnit> me = r.getFilter(); if (me!=null) { if (me.isMatch(riu)) children.add(new IUTreeItem(provider, this, riu)); } else children.add(new IUTreeItem(provider, this, riu)); } } } } } return children; }
private static Collection<InstallableUnitInfo> getIncludedInstallableUnit( Map<IVersionedId, InstallableUnitInfo> nodes, IInstallableUnit parent ) { Set<InstallableUnitInfo> result = new LinkedHashSet<InstallableUnitInfo>(); for ( IRequirement r : parent.getRequirements() ) { if ( r instanceof IRequiredCapability ) { IRequiredCapability rc = (IRequiredCapability) r; if ( isSingleVersion( rc.getRange() ) ) { InstallableUnitInfo otherNode = nodes.get( new VersionedId( rc.getName(), rc.getRange().getMinimum() ) ); if ( otherNode != null ) { result.add( otherNode ); } } } } return result; }
protected void changedRoots(List<WeightedObject<?>> weightedObjects, BigInteger weight, IInstallableUnit entryPointIU) { Collection<IRequirement> requirements = entryPointIU.getRequirements(); for (IRequirement req : requirements) { IQuery<IInstallableUnit> query = QueryUtil.createMatchQuery(req.getMatches()); IQueryResult<IInstallableUnit> matches = picker.query(query, null); Object[] changed = new Object[matches.toUnmodifiableSet().size()]; int i = 0; for (IInstallableUnit match : matches) { changed[i++] = isInstalledAsRoot(match) ? dependencyHelper.not(match) : match; } try { Projector.AbstractVariable abs = new Projector.AbstractVariable("CHANGED"); //$NON-NLS-1$ dependencyHelper.or(FakeExplanation.getInstance(), abs, changed); weightedObjects.add(WeightedObject.newWO(abs, weight)); } catch (ContradictionException e) { // TODO Auto-generated catch block TODO e.printStackTrace(); } } }
protected void removedRoots(List<WeightedObject<?>> weightedObjects, BigInteger weight, IInstallableUnit entryPointIU) { Collection<IRequirement> requirements = entryPointIU.getRequirements(); for (IRequirement req : requirements) { IQuery<IInstallableUnit> query = QueryUtil.createMatchQuery(req.getMatches()); IQueryResult<IInstallableUnit> matches = picker.query(query, null); boolean installed = false; Object[] literals = new Object[matches.toUnmodifiableSet().size()]; int i = 0; for (IInstallableUnit match : matches) { installed = installed || isInstalledAsRoot(match); literals[i++] = dependencyHelper.not(match); } if (installed) { try { Projector.AbstractVariable abs = new Projector.AbstractVariable("REMOVED"); //$NON-NLS-1$ dependencyHelper.and(FakeExplanation.getInstance(), abs, literals); weightedObjects.add(WeightedObject.newWO(abs, weight)); } catch (ContradictionException e) { // should not happen TODO e.printStackTrace(); } } } }
protected void newRoots(List<WeightedObject<?>> weightedObjects, BigInteger weight, IInstallableUnit entryPointIU) { Collection<IRequirement> requirements = entryPointIU.getRequirements(); for (IRequirement req : requirements) { IQuery<IInstallableUnit> query = QueryUtil.createMatchQuery(req.getMatches()); IQueryResult<IInstallableUnit> matches = picker.query(query, null); boolean oneInstalled = false; for (IInstallableUnit match : matches) { oneInstalled = oneInstalled || isInstalledAsRoot(match); } if (!oneInstalled) { try { Projector.AbstractVariable abs = new Projector.AbstractVariable("NEW"); //$NON-NLS-1$ dependencyHelper.or(FakeExplanation.getInstance(), abs, (Object[]) matches.toArray(IInstallableUnit.class)); weightedObjects.add(WeightedObject.newWO(abs, weight)); } catch (ContradictionException e) { // should not happen e.printStackTrace(); } } } }
private boolean hasOnlySimpleRequirements(IInstallableUnit iu) { for (IRequirement r : iu.getRequirements()) if (r.getMax() == 0 || !RequiredCapability.isSimpleRequirement(r.getMatches())) return false; if (iu.getUpdateDescriptor() != null) { for (IMatchExpression<IInstallableUnit> m : iu.getUpdateDescriptor().getIUsBeingUpdated()) { if (!RequiredCapability.isSimpleRequirement(m)) return false; } } for (IRequirement r : iu.getMetaRequirements()) if (r.getMax() == 0 || !RequiredCapability.isSimpleRequirement(r.getMatches())) return false; if (iu instanceof IInstallableUnitFragment) { for (IRequirement r : ((IInstallableUnitFragment) iu).getHost()) if (!RequiredCapability.isSimpleRequirement(r.getMatches())) return false; } if (iu instanceof IInstallableUnitPatch) { IInstallableUnitPatch iuPatch = (IInstallableUnitPatch) iu; for (IRequirement[] rArr : iuPatch.getApplicabilityScope()) for (IRequirement r : rArr) if (!RequiredCapability.isSimpleRequirement(r.getMatches())) return false; IRequirement lifeCycle = iuPatch.getLifeCycle(); if (lifeCycle != null && !RequiredCapability.isSimpleRequirement(lifeCycle.getMatches())) return false; } return true; }