public static List<Resource> findResources(Repository repository, String bsn, String version, String type) { Requirement requirement = new CapReqBuilder("osgi.identity") .addDirective("filter", String.format("(&(osgi.identity=%s)(version=%s)(type=%s))", bsn, version, type)) .buildSyntheticRequirement(); return findResources(repository, requirement); }
public CapReqBuilder(String namespace, Attrs attrs) throws Exception { this(namespace); for (Entry<String, String> entry : attrs.entrySet()) { String key = entry.getKey(); if (key.endsWith(":")) addDirective(key.substring(0, key.length() - 1), entry.getValue()); else addAttribute(key, entry.getValue()); } }
public Requirement addImportPackage(String pname, Attrs attrs) throws Exception { CapReqBuilder reqb = new CapReqBuilder(resource, PackageNamespace.PACKAGE_NAMESPACE); reqb.addDirectives(attrs); reqb.addFilter(PackageNamespace.PACKAGE_NAMESPACE, pname, attrs.getVersion(), attrs); Requirement requirement = reqb.buildRequirement(); addRequirement(requirement); return requirement; }
@Override public Requirement error(String msg) { CapReqBuilder builder = new CapReqBuilder(msg); return builder.buildSyntheticRequirement(); } });
public static Requirement getRequirementFrom(String namespace, Attrs attrs, boolean unalias) throws Exception { CapReqBuilder builder = createCapReqBuilder(namespace, attrs); Requirement requirement = builder.buildSyntheticRequirement(); if (unalias) requirement = unalias(requirement); return requirement; }
public static Requirement copy(Requirement c, Resource r) throws Exception { CapReqBuilder from = new CapReqBuilder(c.getNamespace()).from(c); if (r == null) return from.buildSyntheticRequirement(); else return from.setResource(r) .buildRequirement(); }
public static CapReqBuilder clone(Capability capability) { CapReqBuilder builder = new CapReqBuilder(capability.getNamespace()); builder.addAttributes(capability.getAttributes()); builder.addDirectives(capability.getDirectives()); return builder; }
private static Requirement createRequirement(VersionRange range) { CapReqBuilder builder = new CapReqBuilder(Namespaces.NS_EXTENDER); StringBuilder filter = new StringBuilder(); filter.append('(').append(Namespaces.NS_EXTENDER).append('=').append(Namespaces.EXTENDER_SCR).append(')'); filter.insert(0, "(&"); filter.append(range.toFilter()); filter.append(')'); builder.addDirective(Namespaces.DIRECTIVE_FILTER, filter.toString()).addDirective( Namespaces.DIRECTIVE_EFFECTIVE, Namespaces.EFFECTIVE_ACTIVE); Requirement requirement = builder.buildRequirement(); return requirement; }
public static final CapReqBuilder createPackageRequirement(String pkgName, String range) { Filter filter; SimpleFilter pkgNameFilter = new SimpleFilter(PackageNamespace.PACKAGE_NAMESPACE, pkgName); if (range != null) filter = new AndFilter().addChild(pkgNameFilter) .addChild(new LiteralFilter(Filters.fromVersionRange(range))); else filter = pkgNameFilter; return new CapReqBuilder(PackageNamespace.PACKAGE_NAMESPACE) .addDirective(Namespace.REQUIREMENT_FILTER_DIRECTIVE, filter.toString()); }
void doExportService(Domain domain, List< ? super Capability> caps) throws Exception { @SuppressWarnings("deprecation") Parameters exports = new Parameters(domain.get(Constants.EXPORT_SERVICE)); for (Entry<String,Attrs> export : exports.entrySet()) { String service = Processor.removeDuplicateMarker(export.getKey()); CapReqBuilder builder = new CapReqBuilder(Namespaces.NS_SERVICE).addAttribute(Constants.OBJECTCLASS, service); for (Entry<String,String> attribEntry : export.getValue().entrySet()) builder.addAttribute(attribEntry.getKey(), attribEntry.getValue()); builder.addDirective(Namespaces.DIRECTIVE_EFFECTIVE, Namespaces.EFFECTIVE_ACTIVE); caps.add(builder.buildCapability()); } }
public static String toProvideCapability(Capability capability) throws Exception { StringBuilder sb = new StringBuilder(); sb.append(capability.getNamespace()); CapReqBuilder r = new CapReqBuilder(capability.getNamespace()); r.addAttributes(capability.getAttributes()); r.addDirectives(capability.getDirectives()); Attrs attrs = r.toAttrs(); sb.append(";") .append(attrs); return sb.toString(); }
public static Capability copy(Capability c, Resource r) throws Exception { CapReqBuilder from = new CapReqBuilder(c.getNamespace()).from(c); if (r == null) return from.buildSyntheticCapability(); else return from.setResource(r) .buildCapability(); }
void addFragmentHostCap(String bsn, aQute.bnd.version.Version version) throws Exception { CapReqBuilder rbb = new CapReqBuilder(resource, HostNamespace.HOST_NAMESPACE); rbb.addAttribute(HostNamespace.HOST_NAMESPACE, bsn); rbb.addAttribute(AbstractWiringNamespace.CAPABILITY_BUNDLE_VERSION_ATTRIBUTE, version); addCapability(rbb.buildCapability()); }
Resource constructInputRequirements() throws Exception { ResourceBuilder resBuilder = new ResourceBuilder(); CapReqBuilder identity = new CapReqBuilder(IdentityNamespace.IDENTITY_NAMESPACE) .addAttribute(IdentityNamespace.IDENTITY_NAMESPACE, IDENTITY_INITIAL_RESOURCE); resBuilder.addCapability(identity); Parameters inputRequirements = new Parameters(properties.mergeProperties(Constants.RUNREQUIRES), project); if (inputRequirements != null && !inputRequirements.isEmpty()) { List<Requirement> requires = CapReqBuilder.getRequirementsFrom(inputRequirements); resBuilder.addRequirements(requires); } return resBuilder.build(); }
/** * Get the framework repository from the * * @param repos * @param bsn */ public List<Resource> getResources(List<Repository> repos, String bsn, String range) { Requirement bundle = CapReqBuilder.createBundleRequirement(bsn, range) .buildSyntheticRequirement(); return getResources(repos, bundle); }
public void addExportPackage(String packageName, Attrs attrs) throws Exception { CapReqBuilder capb = new CapReqBuilder(resource, PackageNamespace.PACKAGE_NAMESPACE); capb.addAttributesOrDirectives(attrs); if (!attrs.containsKey(PackageNamespace.CAPABILITY_VERSION_ATTRIBUTE)) { capb.addAttribute(PackageNamespace.CAPABILITY_VERSION_ATTRIBUTE, Version.emptyVersion); } capb.addAttribute(PackageNamespace.PACKAGE_NAMESPACE, packageName); addCapability(capb); }
public void addRequireCapability(String namespace, String name, Attrs attrs) throws Exception { CapReqBuilder req = new CapReqBuilder(resource, namespace); req.addAttributesOrDirectives(attrs); addRequirement(req.buildRequirement()); }
public ResourceBuilder addCapability(CapReqBuilder builder) { if (built) throw new IllegalStateException("Resource already built"); Capability cap = builder.setResource(resource).buildCapability(); capabilities.add(cap); return this; }
public ResourceBuilder addRequirement(CapReqBuilder builder) { if (built) throw new IllegalStateException("Resource already built"); Requirement req = builder.setResource(resource).buildRequirement(); requirements.add(req); return this; }
public CapReqBuilder from(Capability c) throws Exception { addAttributes(c.getAttributes()); addDirectives(c.getDirectives()); return this; }