@Override public Map<String, String> getDirectives() { return requirement.getDirectives(); }
static CacheKey create(Requirement req) { String namespace = req.getNamespace(); String nsvalue = (String) req.getAttributes().get(namespace); return new CacheKey(namespace, nsvalue); }
@Override public Resource getRequirer() { return requirement.getResource(); }
public CompositeData getCompositeData(Requirement req) throws OpenDataException { String namespace = req.getNamespace(); CompositeData[] attsData = new AttributesType().getCompositeData(req.getAttributes()); CompositeData[] dirsData = new DirectivesType().getCompositeData(req.getDirectives()); Object[] itemValues = new Object[] { namespace, attsData, dirsData }; return new CompositeDataSupport(compositeType, getItemNames(), itemValues); }
@Override public Requirement addIdentityRequirement(String symbolicName, VersionRange range, Map<String, Object> atts, Map<String, String> dirs) { IllegalArgumentAssertion.assertNotNull(symbolicName, "symbolicName"); Requirement ireq = addRequirement(IdentityNamespace.IDENTITY_NAMESPACE, symbolicName); if (range != null) { ireq.getAttributes().put(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE, range); } if (atts != null) { ireq.getAttributes().putAll(atts); } if (dirs != null) { ireq.getDirectives().putAll(dirs); } return ireq; }
@Override public List<Requirement> getRequirements(String namespace) { List<Requirement> result = new ArrayList<Requirement>(); synchronized (requirements) { for (Requirement req : requirements) { if (namespace == null || namespace.equals(req.getNamespace())) { result.add(req); } } } return Collections.unmodifiableList(result); }
Iterator<Wire> iterator(ResolveContext context) throws ResolutionException { final Collection<Resource> optres = context.getOptionalResources(); final List<Capability> providers = context.findProviders(req); // Fail early if there are no providers for a non-optional requirement if (!optres.contains(req.getResource()) && !req.isOptional() && providers.isEmpty()) { Set<Requirement> unresolved = Collections.singleton(req); throw new ResolutionException("Cannot find provider for: " + req, null, unresolved); } return new Iterator<Wire>() { Iterator<Capability> delagate = providers.iterator(); @Override public boolean hasNext() { return delagate.hasNext(); } @Override public Wire next() { Capability cap = delagate.next(); return createWire(req, cap); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } }
@Override public Map<String, Object> getAttributes() { return requirement.getAttributes(); }
public static VersionRange getVersionRange(Requirement req, String attr) { Object value = req.getAttribute(attr); return (value instanceof String) ? new VersionRange((String) value) : (VersionRange) value; }
Iterator<Requirement> itreqs = manreqs.iterator(); while (itreqs.hasNext()) { if (itreqs.next().isOptional()) { itreqs.remove();
@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 List<Wire> getRequiredResourceWires(String namespace) { List<Wire> result = new ArrayList<Wire>(); for (Wire wire : required) { Requirement req = wire.getRequirement(); if (namespace == null || namespace.equals(req.getNamespace())) { result.add(wire); } } return Collections.unmodifiableList(result); }
@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()); Version version = AbstractCapability.getVersion(cap, IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE); matches = range.includes(version); reqatts = new HashMap<String, Object>(req.getAttributes()); reqatts.remove(IdentityNamespace.CAPABILITY_VERSION_ATTRIBUTE); capatts = new HashMap<String, Object>(cap.getAttributes());
@Override public Requirement getRequirement() { Resource resource = resbuilder.getResource(); String namespace = requirement.getNamespace(); return resource.getRequirements(namespace).get(0); }
@Override public boolean isEffective(Requirement req) { // Ignore reqs that are not effective:=resolve String effective = req.getDirectives().get(Namespace.REQUIREMENT_EFFECTIVE_DIRECTIVE); return effective == null || effective.equals(Namespace.EFFECTIVE_RESOLVE); }