Refine search
private static Object toJson(Resource resource) { Map<String, Object> obj = new HashMap<>(); List<Object> caps = new ArrayList<>(); List<Object> reqs = new ArrayList<>(); for (Capability cap : resource.getCapabilities(null)) { caps.add(ResourceUtils.toString(null, cap.getNamespace(), cap.getAttributes(), cap.getDirectives())); } for (Requirement req : resource.getRequirements(null)) { reqs.add(ResourceUtils.toString(null, req.getNamespace(), req.getAttributes(), req.getDirectives())); } obj.put("capabilities", caps); obj.put("requirements", reqs); return obj; }
private boolean equalsReq(Requirement other) { if (!Objects.equals(namespace, other.getNamespace())) return false; if (!Objects.equals(attributes, other.getAttributes())) return false; if (!Objects.equals(directives, other.getDirectives())) return false; return Objects.equals(resource, other.getResource()); }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final WrappedRequirement other = (WrappedRequirement) obj; if (m_host != other.m_host && (m_host == null || !m_host.equals(other.m_host))) { return false; } if (m_req != other.m_req && (m_req == null || !m_req.equals(other.m_req))) { return false; } return true; }
/** * Create a requirement based on an existing requirement, providing the resource. * The namespace, attributes and directives are copied from the provided requirement. * @param requirement The requirement to base the new requirement on. * @param resource The resource to be associated with the requirement */ public RequirementImpl(Resource resource, Requirement requirement) { this(resource, requirement.getNamespace(), requirement.getDirectives(), requirement.getAttributes()); }
static Requirement getSubsystemRequirement(Resource resource) { for (Requirement requirement : resource.getRequirements(null)) { if (IDENTITY_NAMESPACE.equals(requirement.getNamespace()) && TYPE_SUBSYSTEM.equals(requirement.getAttributes().get(CAPABILITY_TYPE_ATTRIBUTE))) { return requirement; } } return null; }
List<Capability> caps = (wiring != null) ? wiring.getResourceCapabilities(null) : resource.getCapabilities(null); for (Capability cap : caps) if (cap.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) if (!cap.getResource().equals(resource)) (String) cap.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE), new Blame(cap, null)); Capability cap = wire.getCapability(); if (!cap.getResource().equals(wire.getProvider())) cap = new WrappedCapability(wire.getProvider(), cap); for (Requirement req : resource.getRequirements(null)) if (req.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE))
@Override public boolean equals(Object obj) { if (obj == this) return true; if (obj instanceof Wire) { Wire w = (Wire) obj; if (capability.equals(w.getCapability()) && requirement.equals(w.getRequirement())) { Resource provider = getProvider(); Resource requirer = getRequirer(); return (provider == null ? w.getProvider() == null : provider.equals(w.getProvider())) && (requirer == null ? w.getRequirer() == null : requirer.equals(w.getRequirer())); } } return false; }
for (Capability cap : wiring.getResource().getCapabilities(null)) if (cap.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) (String) cap.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE)); for (Capability cap : wire.getRequirement().getResource().getCapabilities(null)) if (cap.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) exportNames.add((String) cap.getAttributes().get( for (Wire wire : wiring.getRequiredResourceWires(null)) if (wire.getCapability().getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) if (exportNames.contains(wire.getCapability().getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE)))
public List<Capability> findProvider(Requirement requirement) { String namespace = requirement.getNamespace(); return resources.stream() .flatMap(resource -> resource.getCapabilities(namespace) .stream()) .filter(capability -> { if (!requirement.getNamespace() .equals(capability.getNamespace())) return false; if (!ResourceUtils.isEffective(requirement, capability)) return false; String filter = requirement.getDirectives() .get(Namespace.REQUIREMENT_FILTER_DIRECTIVE); if (filter == null) return true; try { Filter f = cache.computeIfAbsent(filter, (k) -> new Filter(k)); return f.matchMap(capability.getAttributes()); } catch (Exception e) { return false; } }) .collect(toCapabilities()); }
@Override public int hashCode() { int hash = 5; hash = 29 * hash + (this.m_requirer != null ? this.m_requirer.hashCode() : 0); hash = 29 * hash + (this.m_req != null ? this.m_req.hashCode() : 0); hash = 29 * hash + (this.m_provider != null ? this.m_provider.hashCode() : 0); hash = 29 * hash + (this.m_cap != null ? this.m_cap.hashCode() : 0); return hash; } }
private static Wire createWire(Requirement requirement, Candidates allCandidates) { Capability cand = allCandidates.getFirstCandidate(requirement); if (cand == null) { return null; } return new WireImpl( getDeclaredResource(requirement.getResource()), getDeclaredRequirement(requirement), getDeclaredResource(cand.getResource()), getDeclaredCapability(cand)); }
private static BundleWireDTO createBundleWireDTO(Wire wire, Set<BundleRevisionDTO> resources, Set<NodeDTO> nodes) { BundleWireDTO wdto = new BundleWireDTO(); if (wire instanceof BundleWire) { BundleWire w = (BundleWire) wire; BundleWiring pw = w.getProviderWiring(); addWiringNodeIfNotPresent(pw, resources, nodes); wdto.providerWiring = getWiringID(pw); BundleWiring rw = w.getRequirerWiring(); addWiringNodeIfNotPresent(rw, resources, nodes); wdto.requirerWiring = getWiringID(rw); } wdto.provider = getResourceIDAndAdd(wire.getProvider(), resources); wdto.requirer = getResourceIDAndAdd(wire.getRequirer(), resources); wdto.capability = new CapabilityRefDTO(); wdto.capability.capability = getCapabilityID(wire.getCapability()); wdto.capability.resource = getResourceIDAndAdd(wire.getCapability().getResource(), resources); wdto.requirement = new RequirementRefDTO(); wdto.requirement.requirement = getRequirementID(wire.getRequirement()); wdto.requirement.resource = getResourceIDAndAdd(wire.getRequirement().getResource(), resources); return wdto; }
@SuppressWarnings("unchecked") public static <T extends Requirement> T as(final Requirement req, Class<T> type) { return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] { type }, (target, method, args) -> (Requirement.class == method.getDeclaringClass()) ? method.invoke(req, args) : get(method, req.getAttributes(), req.getDirectives(), args)); }
private Capability getSatisfyingCapability(Requirement req) { // If the requiring revision is not resolved, then check in the // candidate map for its matching candidate. Capability cap = m_allCandidates.getFirstCandidate(req); // Otherwise, if the requiring revision is resolved then check // in its wires for the capability satisfying the requirement. if (cap == null && m_context.getWirings().containsKey(req.getResource())) { List<Wire> wires = m_context.getWirings().get(req.getResource()).getRequiredResourceWires(null); req = getDeclaredRequirement(req); for (Wire w : wires) { if (w.getRequirement().equals(req)) { // TODO: RESOLVER - This is not 100% correct, since requirements for // dynamic imports with wildcards will reside on many wires and // this code only finds the first one, not necessarily the correct // one. This is only used for the diagnostic message, but it still // could confuse the user. cap = w.getCapability(); break; } } } return cap; } }
@SuppressWarnings("unchecked") private static <T extends Resource> Set<T> collectDependencies(T resource, CapabilitySet capSet) { Set<T> result = new LinkedHashSet<>(); for (Requirement requirement : resource.getRequirements(null)) { String filter = requirement.getDirectives().get(Constants.FILTER_DIRECTIVE); SimpleFilter sf = (filter != null) ? SimpleFilter.parse(filter) : SimpleFilter.MATCH_ALL_FILTER; for (Capability cap : capSet.match(sf, true)) { result.add((T) cap.getResource()); } } return result; }
private void addWiredBundle(Map<Resource, List<Wire>> wirings, Resource resource, List<Resource> result) { List<Requirement> reqs = resource.getRequirements(BUNDLE_NAMESPACE); for (Requirement req : reqs) { List<Wire> wrs = wirings.get(resource); for (Wire w : wrs) { if (w.getRequirement() .equals(req)) { Resource res = w.getProvider(); if (res != null) { if (!result.contains(res)) { result.add(res); addWiredBundle(wirings, res, result); } } } } } }
protected void processMandatoryResource(Requirement requirement, LinkedHashSet<Capability> firstStageResult, Resource resource) { if (resource != null) { List<Capability> selfCaps = resource.getCapabilities(requirement.getNamespace()); if (selfCaps != null) { for (Capability selfCap : selfCaps) { if (matches(requirement, selfCap)) firstStageResult.add(selfCap); } } } }
@Override public boolean isEffective(Requirement requirement) { boolean isServiceReq = ServiceNamespace.SERVICE_NAMESPACE.equals(requirement.getNamespace()); return !(isServiceReq && FeaturesService.ServiceRequirementsBehavior.Disable == serviceRequirements); }
public static boolean isDynamic(Requirement req) { return PackageNamespace.RESOLUTION_DYNAMIC.equals(req.getDirectives() .get(Namespace.REQUIREMENT_RESOLUTION_DIRECTIVE)); }