Refine search
@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; }
private static void writeWire(ModuleWire wire, DataOutputStream out, Map<Object, Integer> objectTable) throws IOException { Wire w = wire; Integer capability = objectTable.get(w.getCapability()); Integer provider = objectTable.get(w.getProvider()); Integer requirement = objectTable.get(w.getRequirement()); Integer requirer = objectTable.get(w.getRequirer()); if (capability == null || provider == null || requirement == null || requirer == null) throw new NullPointerException("Could not find the expected indexes"); //$NON-NLS-1$ out.writeInt(addToWriteTable(wire, objectTable)); out.writeInt(capability); out.writeInt(provider); out.writeInt(requirement); out.writeInt(requirer); }
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); } } } } } }
if (candCap.getNamespace().equals(PackageNamespace.PACKAGE_NAMESPACE)) else if (candCap.getNamespace().equals(BundleNamespace.BUNDLE_NAMESPACE)) rc, candCap.getResource(), allCandidates, resourcePkgMap); if (w.getRequirement().getNamespace() .equals(BundleNamespace.BUNDLE_NAMESPACE)) String value = w.getRequirement() .getDirectives() .get(BundleNamespace.REQUIREMENT_VISIBILITY_DIRECTIVE); if ((value != null) current, currentReq, w.getCapability(), resourcePkgMap, allCandidates, for (Requirement req : candCap.getResource().getRequirements(null)) if (req.getNamespace().equals(BundleNamespace.BUNDLE_NAMESPACE))
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))
boolean isFragment = Util.isFragment(candCap.getResource()); if ((isFragment || !rc.getWirings().containsKey(candCap.getResource())) && !candCap.getResource().equals(req.getResource())) PopulateResult result = m_populateResultCache.get(candCap.getResource()); || rc.getWirings().get(wire.getProvider()) .getResourceCapabilities(null).contains(fragCand)) candidates, new WrappedCapability( wire.getCapability().getResource(), fragCand));
Requirement r = wire.getRequirement(); if (!r.getResource().equals(wire.getRequirer()) || Util.isDynamic(r)) r = new WrappedRequirement(wire.getRequirer(), r); Capability c = wire.getCapability(); if (!c.getResource().equals(wire.getProvider())) c = new WrappedCapability(wire.getProvider(), c); if (dynamicReq != null && resource.equals(session.getDynamicHost()))
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)))
Requirement r = wire.getRequirement(); if (!r.getResource().equals(wire.getRequirer()) || ((r.getDirectives() .get(PackageNamespace.REQUIREMENT_RESOLUTION_DIRECTIVE) != null) && r.getDirectives() .get(PackageNamespace.REQUIREMENT_RESOLUTION_DIRECTIVE) .equals(PackageNamespace.RESOLUTION_DYNAMIC))) r = new WrappedRequirement(wire.getRequirer(), r); Capability c = wire.getCapability(); if (!c.getResource().equals(wire.getProvider())) c = new WrappedCapability(wire.getProvider(), c); for (Requirement req : resource.getRequirements(null)) Capability cap = caps.get(i); calculateExportedPackages( session.getContext(), cap.getResource(), allCandidates, resourcePkgMap); String pkgName = (String) cap.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE); if (resourcePkgs.m_exportedPkgs.containsKey(pkgName) || resourcePkgs.m_importedPkgs.containsKey(pkgName)
for (Resource res : resolution.keySet()) { for (Wire wire : resolution.get(res)) { if (HOST_NAMESPACE.equals(wire.getCapability().getNamespace())) { Bundle bundle; if (wire.getProvider() instanceof BundleRevision) { bundle = ((BundleRevision) wire.getProvider()).getBundle(); } else { bundle = resources.get(wire.getProvider()); Bundle b = resources.get(wire.getRequirer()); Resource r = b != null ? b.adapt(BundleRevision.class) : wire.getRequirer(); newFragments.get(bundle).add(r); for (Wire wire : newWires) { String namespace = wire.getRequirement().getNamespace(); if (!namespace.equals(BundleNamespace.BUNDLE_NAMESPACE) && !namespace.equals(PackageNamespace.PACKAGE_NAMESPACE) String effective = wire.getRequirement().getDirectives().get(Namespace.CAPABILITY_EFFECTIVE_DIRECTIVE); if (effective != null && !Namespace.EFFECTIVE_RESOLVE.equals(effective)) { continue; if (!isBundle(wire.getProvider())) { continue; if (!wiredResources.containsKey(wire.getProvider())) { wiredResources.put(wire.getProvider(), wire.getRequirement());
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; }
private static Resource findResolvedProvider(Wire wire, Set<Resource> resources, AbstractResolveContext rc) { // Make sure not to add new resources into the result. The resolver // already created the closure of all the needed resources. We need to // find the key in the result that already provides the capability // defined by this wire. Capability capability = wire.getCapability(); Resource resource = capability.getResource(); if (rc.isSystemResource(resource) || (ResourceUtils.isFragment(resource) && resources.contains(resource))) { return resource; } for (Resource resolved : resources) { for (Capability resolvedCap : resolved.getCapabilities(capability.getNamespace())) { if (ResourceUtils.matches(wire.getRequirement(), resolvedCap)) { return resolved; } } } // It shouldn't be possible to arrive here! throw new IllegalStateException( Strings.format("The capability for wire %s was not associated with a resource in the resolution", wire)); }
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; }
if (rw.getCapability().getNamespace().equals( BundleRevision.BUNDLE_NAMESPACE)) String dir = rw.getRequirement() .getDirectives().get(Constants.VISIBILITY_DIRECTIVE); if ((dir != null) && (dir.equals(Constants.VISIBILITY_REEXPORT))) (BundleRevision) rw.getProvider(), wireMap, pkgs,
for (List<Wire> wires : resolver.getWiring().values()) { for (Wire wire : wires) { if (features.contains(wire.getRequirer()) && unmanaged.contains(wire.getProvider())) { requested.add(wire.getProvider()); for (List<Wire> wires : resolver.getWiring().values()) { for (Wire wire : wires) { if (requested.contains(wire.getProvider()) && unmanaged.contains(wire.getRequirer())) { requested.remove(wire.getProvider()); Set<Resource> conditions = new HashSet<>(); for (Wire wire : resolver.getWiring().get(feature)) { if (IDENTITY_NAMESPACE.equals(wire.getRequirement().getNamespace()) && FeatureResource.CONDITIONAL_TRUE.equals(wire.getRequirement().getDirectives().get(FeatureResource.REQUIREMENT_CONDITIONAL_DIRECTIVE))) { conditions.add(wire.getProvider());
/** * Returns a mapping for resources that match given filter, to a subsystem that represents region or scoped feature. * @param resourceFilter * @return map from resource to region name */ private Map<Resource, String> getResourceMapping(SimpleFilter resourceFilter) { Map<String, String> flats = getFlatSubsystemsMap(); Map<Resource, List<Wire>> wiring = getWiring(); Map<Resource, String> resources = new HashMap<>(); SimpleFilter sf = createFilter(IDENTITY_NAMESPACE, "*", CAPABILITY_TYPE_ATTRIBUTE, TYPE_SUBSYSTEM); if (wiring != null) { for (Resource resource : wiring.keySet()) { if (findMatchingCapability(resourceFilter, resource.getCapabilities(null)) != null) { // Find the subsystem where this feature is installed Wire wire = findMatchingWire(sf, wiring.get(resource)); if (wire != null) { String region = (String) wire.getCapability().getAttributes().get(IDENTITY_NAMESPACE); region = flats.get(region); resources.put(resource, region); } } } } return resources; }
private void propagateState(Map<Resource, FeatureState> states, Resource resource, FeatureState state, SubsystemResolver resolver) { if (!isSubsystem(resource)) { FeatureState reqState = mergeStates(state, states.get(resource)); if (reqState != states.get(resource)) { states.put(resource, reqState); for (Wire wire : resolver.getWiring().get(resource)) { if (IDENTITY_NAMESPACE.equals(wire.getCapability().getNamespace())) { propagateState(states, wire.getProvider(), reqState, resolver); } } } } }
wired.add(wire.getProvider()); if (HostNamespace.HOST_NAMESPACE.equals(wire.getRequirement().getNamespace())) { for (Wire hostWire : wiring.get(wire.getProvider())) { wired.add(hostWire.getProvider());
Resource requirer = optionalWire.getRequirer(); Capability requirerIdentity = toPureIdentity(requirer, log); if (required.containsKey(requirer)) { Requirement req = optionalWire.getRequirement(); if (req.equals(requiredWire.getRequirement())) { continue optional;
List<Wire> wires = requirementsAndWires.wires; for (Wire wire : wires) { Capability capability = wire.getCapability(); Requirement requirement = wire.getRequirement();