@Override public Resource getProvider() { return capability.getResource(); }
public CompositeData getCompositeData(Capability cap) throws OpenDataException { String namespace = cap.getNamespace(); CompositeData[] attsData = new AttributesType().getCompositeData(cap.getAttributes()); CompositeData[] dirsData = new DirectivesType().getCompositeData(cap.getDirectives()); Object[] itemValues = new Object[] { namespace, attsData, dirsData }; return new CompositeDataSupport(compositeType, getItemNames(), itemValues); }
@Override public Capability getIdentityCapability() { if (identityCapability == null) { List<Capability> icaps = getCapabilities(IdentityNamespace.IDENTITY_NAMESPACE); if (icaps.size() > 1) throw new IllegalStateException("Multiple identity capabilities"); if (icaps.size() < 1) throw new IllegalStateException("No identity capability"); Capability icap = icaps.get(0); Object version = icap.getAttribute(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE); if (!(version instanceof Version)) { version = version == null ? Version.emptyVersion : Version.parseVersion(version.toString()); icap.getAttributes().put(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE, version); } identityCapability = icap; } return identityCapability; }
static CacheKey create(Capability cap) { String namespace = cap.getNamespace(); String nsvalue = (String) cap.getAttributes().get(namespace); return new CacheKey(namespace, nsvalue); }
@Override public Capability addIdentityCapability(String symbolicName, Version version, Map<String, Object> atts, Map<String, String> dirs) { IllegalArgumentAssertion.assertNotNull(symbolicName, "symbolicName"); Capability icap = addCapability(IdentityNamespace.IDENTITY_NAMESPACE, symbolicName); if (version != null) { icap.getAttributes().put(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE, version); } if (atts != null) { icap.getAttributes().putAll(atts); } if (dirs != null) { icap.getDirectives().putAll(dirs); } return icap; }
public static Version getVersion(Capability cap, String attname) { Object attval = cap.getAttributes().get(attname); if (attval != null && !(attval instanceof Version)) { attval = new Version(attval.toString()); cap.getAttributes().put(attname, attval); } return attval != null ? (Version) attval : Version.emptyVersion; }
@Override public List<Capability> getCapabilities(String namespace) { List<Capability> result = new ArrayList<Capability>(); synchronized (capabilities) { for (Capability cap : capabilities) { if (namespace == null || namespace.equals(cap.getNamespace())) { result.add(cap); } } } return Collections.unmodifiableList(result); }
private static URL getContentURL(Resource resource) { IllegalArgumentAssertion.assertNotNull(resource, "resource"); List<Capability> ccaps = resource.getCapabilities(ContentNamespace.CONTENT_NAMESPACE); if (ccaps.size() != 1) return null; return ccaps.get(0).adapt(ContentCapability.class).getContentURL(); }
@Override public ResourceIdentity getIdentity() { if (identity == null) { Capability icap = getIdentityCapability(); String symbolicName = (String) icap.getAttribute(IdentityNamespace.IDENTITY_NAMESPACE); Version version = (Version) icap.getAttribute(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE); identity = ResourceIdentity.create(symbolicName, version); } return identity; }
@Override public boolean match(Capability cap, Requirement req) { Map<String, Object> reqatts = req.getAttributes(); Map<String, Object> capatts = cap.getAttributes(); boolean matches = req.getNamespace().equals(cap.getNamespace()); reqatts = new HashMap<String, Object>(req.getAttributes()); reqatts.remove(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE); capatts = new HashMap<String, Object>(cap.getAttributes()); capatts.remove(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE);
public Capability addIdentityCapability(MavenCoordinates mavenid) { Capability icap = addIdentityCapability(MavenUtils.getSymbolicName(mavenid), MavenUtils.getVersion(mavenid), null, null); icap.getAttributes().put(ContentNamespace.CAPABILITY_MAVEN_IDENTITY_ATTRIBUTE, mavenid); return icap; }
private int getCapabilityIndex(Capability cap) { return getResource().getCapabilities(cap.getNamespace()).indexOf(cap); }
return null; ContentCapability ccap = ccaps.get(0).adapt(ContentCapability.class); InputStream contentStream = ccap.getContentStream(); if (contentStream == null) {
/** * A reference resource has a 'type' attribute with value 'reference' */ public static boolean isReference(Resource res) { Object attval = res.getIdentityCapability().getAttribute(IdentityNamespace.CAPABILITY_TYPE_ATTRIBUTE); return IdentityNamespace.TYPE_REFERENCE.equals(attval); }
@Override public ResourceBuilder fromResource(Resource res) { for (Capability cap : res.getCapabilities(null)) { addCapability(cap.getNamespace(), cap.getAttributes(), cap.getDirectives()); } for (Requirement req : res.getRequirements(null)) { addRequirement(req.getNamespace(), req.getAttributes(), req.getDirectives()); } return this; }
@Override public int compare(Capability cap1, Capability cap2) { // Prefer already wired if (wirings != null) { Wiring w1 = wirings.get(cap1.getResource()); Wiring w2 = wirings.get(cap2.getResource()); if (w1 != null && w2 == null) return -1; if (w1 == null && w2 != null) return +1; } // Prefer higher version Version v1 = AbstractCapability.getVersion(cap1, IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE); Version v2 = AbstractCapability.getVersion(cap2, IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE); return v2.compareTo(v1); } }; }
Map<String, Object> attsD = builderD.addIdentityCapability(residD).getAttributes(); attsD.put(ContentNamespace.CAPABILITY_RUNTIME_NAME_ATTRIBUTE, RESOURCE_D + ".war"); builderD.addContentCapability(deployer.getDeployment(RESOURCE_D));
public void addProvidedWire(Wire wire) { List<Wire> nswires = provided.get(cap.getNamespace()); if (nswires == null) { nswires = new ArrayList<Wire>(); provided.put(cap.getNamespace(), nswires);
private static URL getRequiredContentURL(Resource resource) { IllegalArgumentAssertion.assertNotNull(resource, "resource"); List<Capability> ccaps = resource.getCapabilities(ContentNamespace.CONTENT_NAMESPACE); IllegalArgumentAssertion.assertFalse(ccaps.isEmpty(), "Cannot obtain content capability from: " + resource); IllegalArgumentAssertion.assertFalse(ccaps.size() > 1, "Cannot process multiple content capabilities in: " + resource); URL contentURL = ccaps.get(0).adapt(ContentCapability.class).getContentURL(); IllegalArgumentAssertion.assertTrue(contentURL != null, "Cannot obtain content URL from: " + resource); return contentURL; } }
/** * A shared resource has a 'shared' attribute with value 'true' */ public static boolean isShared(Resource resource) { Object attval = resource.getIdentityCapability().getAttribute(IdentityNamespace.CAPABILITY_SHARED_ATTRIBUTE); return Boolean.parseBoolean(attval != null ? attval.toString() : null); } }