public boolean equals(Object other) { if (other == null) return false; if (!(other instanceof IProvidedCapability)) return false; IProvidedCapability otherCapability = (IProvidedCapability) other; if (!(namespace.equals(otherCapability.getNamespace()))) return false; if (!(name.equals(otherCapability.getName()))) return false; return version.equals(otherCapability.getVersion()); }
private String getFeatureId(IInstallableUnit iu) { for (IProvidedCapability provided : iu.getProvidedCapabilities()) { if (PublisherHelper.CAPABILITY_NS_UPDATE_FEATURE.equals(provided.getNamespace())) { return provided.getName(); } } return null; }
private IProvidedCapability getBundleCapability(IInstallableUnit unit) { for (IProvidedCapability capability : unit.getProvidedCapabilities()) { if (BundlesAction.CAPABILITY_NS_OSGI_BUNDLE.equals(capability.getNamespace())) { return capability; } } return null; }
private boolean matches(IInstallableUnit unit, ParsedCapabilityPattern pattern) { switch (pattern.getType()) { case P2_INSTALLABLE_UNIT: return pattern.matchesId(unit.getId()) && pattern.matchesVersion(unit.getVersion()); case OSGI_BUNDLE: IProvidedCapability bundle = getBundleCapability(unit); if (bundle == null) return false; return pattern.matchesId(bundle.getName()) && pattern.matchesVersion(bundle.getVersion()); case JAVA_PACKAGE: for (IProvidedCapability exportedPackage : getPackageCapabilities(unit)) { if (pattern.matchesId(exportedPackage.getName()) && pattern.matchesVersion(exportedPackage.getVersion())) { return true; } } return false; } return false; }
public CapabilityIndex(Iterator<IInstallableUnit> itor) { HashMap<String, Object> index = new HashMap<String, Object>(300); while (itor.hasNext()) { IInstallableUnit iu = itor.next(); Collection<IProvidedCapability> pcs = iu.getProvidedCapabilities(); for (IProvidedCapability pc : pcs) { String name = pc.getName(); Object prev = index.put(name, iu); if (prev == null || prev == iu) continue; ArrayList<IInstallableUnit> list; if (prev instanceof IInstallableUnit) { list = new ArrayList<IInstallableUnit>(); list.add((IInstallableUnit) prev); } else list = (ArrayList<IInstallableUnit>) prev; list.add(iu); index.put(name, list); } } this.capabilityMap = index; }
private boolean isBundleOrFragmentWithId(IInstallableUnit iu, String id) { for (IProvidedCapability provided : iu.getProvidedCapabilities()) { if (BundlesAction.CAPABILITY_NS_OSGI_BUNDLE.equals(provided.getNamespace())) { return id.equals(provided.getName()); } } return false; }
private static boolean isTranslation(IInstallableUnitFragment fragment) { for (IProvidedCapability capability : fragment.getProvidedCapabilities()) { // TODO make the constant in the TranslationSupport class public and use it if ("org.eclipse.equinox.p2.localization".equals(capability.getNamespace())) //$NON-NLS-1$ return true; } return false; } }
@Override public boolean match( IInstallableUnit unit ) { for ( IProvidedCapability cap : unit.getProvidedCapabilities() ) { if ( match( cap.getName() ) ) { return true; } } return false; }
private List<SystemCapability> readCapabilities(IInstallableUnit specificationUnit) { List<SystemCapability> result = new ArrayList<>(); for (IProvidedCapability capability : specificationUnit.getProvidedCapabilities()) { String namespace = capability.getNamespace(); String name = capability.getName(); String version = capability.getVersion().toString(); if (JREAction.NAMESPACE_OSGI_EE.equals(namespace)) { result.add(new SystemCapability(Type.OSGI_EE, name, version)); } else if (PublisherHelper.CAPABILITY_NS_JAVA_PACKAGE.equals(namespace)) { result.add(new SystemCapability(Type.JAVA_PACKAGE, name, version)); } else { // ignore } } return result; }
private String getCapability(IInstallableUnit iu, String namespace) { for (Iterator<?> i = iu.getProvidedCapabilities().iterator(); i.hasNext();) { IProvidedCapability capability = (IProvidedCapability) i.next(); if (capability.getNamespace().equals(namespace)) return capability.getName(); } return null; }
private List<IProvidedCapability> getPackageCapabilities(IInstallableUnit unit) { Collection<IProvidedCapability> allCapabilities = unit.getProvidedCapabilities(); List<IProvidedCapability> packageCapabilities = new ArrayList<>(allCapabilities.size()); for (IProvidedCapability capability : allCapabilities) { if (PublisherHelper.CAPABILITY_NS_JAVA_PACKAGE.equals(capability.getNamespace())) { packageCapabilities.add(capability); } } return packageCapabilities; }
private void ensureSelfCapability(InstallableUnitDescription iu) { Collection<IProvidedCapability> capabilities = iu.getProvidedCapabilities(); for (IProvidedCapability capability : capabilities) { if (IInstallableUnit.NAMESPACE_IU_ID.equals(capability.getNamespace()) && iu.getId().equals(capability.getName()) && iu.getVersion().equals(capability.getVersion())) { return; } } IProvidedCapability[] newCapabilities = new IProvidedCapability[capabilities.size() + 1]; capabilities.toArray(newCapabilities); newCapabilities[newCapabilities.length - 1] = createSelfCapability(iu.getId(), iu.getVersion()); iu.setCapabilities(newCapabilities); } }
@Override public boolean match( IInstallableUnit unit ) { for ( IProvidedCapability cap : unit.getProvidedCapabilities() ) { if ( CAPABILITY_NS_JAVA_PACKAGE.equals( cap.getNamespace() ) && match( cap.getName() ) ) { return true; } } return false; }
private boolean providesJavaPackages(IInstallableUnit iu) { for (IProvidedCapability capability : iu.getProvidedCapabilities()) { if ("java.package".equals(capability.getNamespace())) { return true; } } return false; }
protected void writeProvidedCapabilities(Collection<IProvidedCapability> capabilities) { if (capabilities != null && capabilities.size() > 0) { start(PROVIDED_CAPABILITIES_ELEMENT); attribute(COLLECTION_SIZE_ATTRIBUTE, capabilities.size()); for (IProvidedCapability capability : capabilities) { start(PROVIDED_CAPABILITY_ELEMENT); attribute(NAMESPACE_ATTRIBUTE, capability.getNamespace()); attribute(NAME_ATTRIBUTE, capability.getName()); attribute(VERSION_ATTRIBUTE, capability.getVersion()); end(PROVIDED_CAPABILITY_ELEMENT); } end(PROVIDED_CAPABILITIES_ELEMENT); } }
private Type getType(IInstallableUnit iu) { Optional<IProvidedCapability> cap = iu.getProvidedCapabilities().stream() .filter(p -> p.getNamespace().equals(PublisherHelper.NAMESPACE_ECLIPSE_TYPE)).findAny(); if (!cap.isPresent()) return Type.other; switch (cap.get().getName()) { case "source": return Type.source_bundle; case "bundle": return Type.bundle; case "feature": return Type.feature; default: System.err.println("[WARNING] UNHANDLED " + cap.get()); return Type.other; } }
private static IInstallableUnit removeExportedPackages(IInstallableUnit initialUnit) { InstallableUnitDescription iud = new InstallableUnitDescription(); iud.setId(initialUnit.getId()); iud.setVersion(initialUnit.getVersion()); initialUnit.getProvidedCapabilities().stream() .filter(cap -> !PublisherHelper.CAPABILITY_NS_JAVA_PACKAGE.equals(cap.getNamespace())) .map(Collections::singleton).forEach(iud::addProvidedCapabilities); return MetadataFactory.createInstallableUnit(iud); }
protected void writeProvidedCapabilities(Collection<IProvidedCapability> capabilities) { if (capabilities != null && capabilities.size() > 0) { start(PROVIDED_CAPABILITIES_ELEMENT); attribute(COLLECTION_SIZE_ATTRIBUTE, capabilities.size()); for (IProvidedCapability capability : capabilities) { start(PROVIDED_CAPABILITY_ELEMENT); attribute(NAMESPACE_ATTRIBUTE, capability.getNamespace()); attribute(NAME_ATTRIBUTE, capability.getName()); attribute(VERSION_ATTRIBUTE, capability.getVersion()); end(PROVIDED_CAPABILITY_ELEMENT); } end(PROVIDED_CAPABILITIES_ELEMENT); } }
for (int k = 0; k < providedAdvice.length; k++) { IProvidedCapability providedCapability = providedAdvice[k]; if (providedCapability.getNamespace().equals(currentProvidedCapability.getNamespace()) && providedCapability.getName().equals(currentProvidedCapability.getName())) { resultProvidedCapabilities.remove(currentProvidedCapability); break;
protected void writeProvidedCapabilities(Collection<IProvidedCapability> capabilities) { if (capabilities != null && capabilities.size() > 0) { start(PROVIDED_CAPABILITIES_ELEMENT); attribute(COLLECTION_SIZE_ATTRIBUTE, capabilities.size()); for (IProvidedCapability capability : capabilities) { start(PROVIDED_CAPABILITY_ELEMENT); attribute(NAMESPACE_ATTRIBUTE, capability.getNamespace()); attribute(NAME_ATTRIBUTE, capability.getName()); attribute(VERSION_ATTRIBUTE, capability.getVersion()); end(PROVIDED_CAPABILITY_ELEMENT); } end(PROVIDED_CAPABILITIES_ELEMENT); } }