void addCapability(AbstractCapability cap) { synchronized (capabilities) { assertMutable(); capabilities.add(cap); } }
@Override public <T> boolean hasAttachment(AttachmentKey<T> key) { return getAttachmentsInternal().hasAttachment(key); }
void validate() { // Make sure we have an identity getIdentity(); // Validate the capabilities for (Capability cap : getCapabilities(null)) { ((AbstractCapability) cap).validate(); } // Validate the requirements for (Requirement req : getRequirements(null)) { ((AbstractRequirement) req).validate(); } }
@Override @SuppressWarnings("unchecked") public <T> T adapt(Class<T> type) { T result = null; if (type.isAssignableFrom(getClass())) { result = (T) this; } else if (type.isAssignableFrom(CompositeData.class)) { result = (T) getCompositeData(); } else if (type.isAssignableFrom(ResourceContent.class)) { result = (T) getResourceContent(); } return result; }
@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; }
addcomma = true; ResourceIdentity icap = resource.getIdentity(); if (icap != null) { buffer.append(addcomma ? "," : "");
@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 Capability addCapability(String namespace, Map<String, Object> atts, Map<String, String> dirs) { IllegalArgumentAssertion.assertNotNull(namespace, "namespace"); AbstractResource resource = getResourceInternal(); AbstractCapability cap = createCapability(resource, namespace, mutableAttributes(atts), mutableDirectives(dirs)); resource.addCapability(cap); return cap; }
@Override public Requirement addRequirement(String namespace, Map<String, Object> atts, Map<String, String> dirs) { IllegalArgumentAssertion.assertNotNull(namespace, "namespace"); AbstractResource resource = getResourceInternal(); AbstractRequirement req = createRequirement(resource, namespace, mutableAttributes(atts), mutableDirectives(dirs)); resource.addRequirement(req); return req; }
List<Capability> ccaps = getCapabilities(ContentNamespace.CONTENT_NAMESPACE); if (ccaps.isEmpty()) return null;
addcomma = true; ResourceIdentity icap = resource.getIdentity(); if (icap != null) { buffer.append(addcomma ? "," : "");
@Override public <T> T getAttachment(AttachmentKey<T> key) { return getAttachmentsInternal().getAttachment(key); }
void addRequirement(AbstractRequirement req) { synchronized (requirements) { assertMutable(); requirements.add(req); } }
@Override public <T> T putAttachment(AttachmentKey<T> key, T value) { return getAttachmentsInternal().putAttachment(key, value); }
@Override public Resource getMutableResource() { AbstractResource resource = getResourceInternal(); resource.assertMutable(); return resource; }
@Override public <T> T removeAttachment(AttachmentKey<T> key) { return getAttachmentsInternal().getAttachment(key); }