public String toString() { return getRequirement() + " -> " + getCapability(); //$NON-NLS-1$ }
private static void readWire(DataInputStream in, Map<Integer, Object> objectTable) throws IOException { int wireIndex = in.readInt(); ModuleCapability capability = (ModuleCapability) objectTable.get(in.readInt()); ModuleRevision provider = (ModuleRevision) objectTable.get(in.readInt()); ModuleRequirement requirement = (ModuleRequirement) objectTable.get(in.readInt()); ModuleRevision requirer = (ModuleRevision) objectTable.get(in.readInt()); if (capability == null || provider == null || requirement == null || requirer == null) throw new NullPointerException("Could not find the expected indexes"); //$NON-NLS-1$ ModuleWire result = new ModuleWire(capability, provider, requirement, requirer); addToReadTable(result, wireIndex, objectTable); }
DynamicFragments(ModuleWiring hostWiring, ModuleCapability hostCapability) { this.hostCapability = hostCapability; validProviders.add(hostWiring.getRevision()); for (ModuleWire hostWire : hostWiring.getProvidedModuleWires(HostNamespace.HOST_NAMESPACE)) { validProviders.add(hostWire.getRequirer()); fragments.put(hostWire.getRequirer().getSymbolicName(), hostWire.getRequirer()); } }
private void basicAddImmediateDependents(ModuleWiring wiring) { List<ModuleWire> providedWires = wiring.getProvidedModuleWires(null); if (providedWires != null) { for (ModuleWire wire : providedWires) { String namespace = wire.getRequirement().getNamespace(); if (PackageNamespace.PACKAGE_NAMESPACE.equals(namespace) || BundleNamespace.BUNDLE_NAMESPACE.equals(namespace)) { ModuleWiring dependent = wire.getRequirerWiring(); if (!allDependents.contains(dependent)) { allDependents.add(dependent); } } } } } }
public Bundle[] getImportingBundles() { if (!providerWiring.isInUse()) { return null; } Set<Bundle> importing = new HashSet<Bundle>(); String packageName = getName(); addRequirers(importing, providerWiring, packageName); List<ModuleWire> providedPackages = providerWiring.getProvidedModuleWires(PackageNamespace.PACKAGE_NAMESPACE); if (providedPackages == null) { // we don't hold locks while checking the graph, just return if no longer valid return null; } for (ModuleWire packageWire : providedPackages) { if (packageCapability.equals(packageWire.getCapability())) { importing.add(packageWire.getRequirer().getBundle()); if (packageWire.getRequirerWiring().isSubstitutedPackage(packageName)) { addRequirers(importing, packageWire.getRequirerWiring(), packageName); } } } return importing.toArray(new Bundle[importing.size()]); }
List<ModuleWire> removedWires = removedWiring.getRequiredModuleWires(null); for (ModuleWire wire : removedWires) { Collection<ModuleWire> providerWires = toRemoveWireLists.get(wire.getProviderWiring()); if (providerWires == null) { providerWires = new ArrayList<>(); toRemoveWireLists.put(wire.getProviderWiring(), providerWires); for (ModuleWire removedWire : entry.getValue()) { removedWire.invalidate();
List<ModuleWire> requiredWires = new ArrayList<ModuleWire>(resultEntry.getValue().size()); for (Wire wire : resultEntry.getValue()) { ModuleWire moduleWire = new ModuleWire((ModuleCapability) wire.getCapability(), (ModuleRevision) wire.getProvider(), (ModuleRequirement) wire.getRequirement(), (ModuleRevision) wire.getRequirer()); requiredWires.add(moduleWire); Map<ModuleCapability, List<ModuleWire>> providedWiresMap = provided.get(moduleWire.getProvider()); if (providedWiresMap == null) { providedWiresMap = new HashMap<ModuleCapability, List<ModuleWire>>(); provided.put(moduleWire.getProvider(), providedWiresMap); List<ModuleWire> providedWires = providedWiresMap.get(moduleWire.getCapability()); if (providedWires == null) { providedWires = new ArrayList<ModuleWire>(); providedWiresMap.put(moduleWire.getCapability(), providedWires);
private static void addDependents(ModuleRevision revision, Map<ModuleRevision, ModuleWiring> wiringCopy, Set<ModuleRevision> dependencyClosure) { if (dependencyClosure.contains(revision)) return; dependencyClosure.add(revision); ModuleWiring wiring = wiringCopy.get(revision); if (wiring == null) return; List<ModuleWire> provided = wiring.getProvidedModuleWires(null); // No null checks; we are holding the read lock here. // Add all requirers of the provided wires for (ModuleWire providedWire : provided) { addDependents(providedWire.getRequirer(), wiringCopy, dependencyClosure); } // add all hosts of a fragment if (revision.getTypes() == BundleRevision.TYPE_FRAGMENT) { List<ModuleWire> hosts = wiring.getRequiredModuleWires(HostNamespace.HOST_NAMESPACE); for (ModuleWire hostWire : hosts) { addDependents(hostWire.getProvider(), wiringCopy, dependencyClosure); } } }
final void addProvidedPackageNames(String packageName, List<String> result, boolean subPackages, Collection<BundleLoader> visited) { if (visited.contains(this)) return; visited.add(this); for (String exported : exportedPackages) { if (exported.equals(packageName) || (subPackages && isSubPackage(packageName, exported))) { if (!result.contains(exported)) result.add(exported); } } for (String substituted : wiring.getSubstitutedNames()) { if (substituted.equals(packageName) || (subPackages && isSubPackage(packageName, substituted))) { if (!result.contains(substituted)) result.add(substituted); } } for (ModuleWire bundleWire : requiredBundleWires) { if (BundleNamespace.VISIBILITY_REEXPORT.equals(bundleWire.getRequirement().getDirectives().get(BundleNamespace.REQUIREMENT_VISIBILITY_DIRECTIVE))) { BundleLoader loader = (BundleLoader) bundleWire.getProviderWiring().getModuleLoader(); if (loader != null) { loader.addProvidedPackageNames(packageName, result, subPackages, visited); } } } }
Bundle requirer = requireBundleWire.getRequirer().getBundle(); if (importing.contains(requirer)) { continue; String reExport = requireBundleWire.getRequirement().getDirectives().get(BundleNamespace.REQUIREMENT_VISIBILITY_DIRECTIVE); ModuleWiring requirerWiring = requireBundleWire.getRequirerWiring(); if (BundleNamespace.VISIBILITY_REEXPORT.equals(reExport)) { addRequirers(importing, requirerWiring, packageName); if (providedPackages != null) { for (ModuleWire packageWire : providedPackages) { if (packageName.equals(packageWire.getCapability().getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE))) { importing.add(packageWire.getRequirer().getBundle()); if (packageWire.getRequirerWiring().isSubstitutedPackage(packageName)) { addRequirers(importing, packageWire.getRequirerWiring(), packageName);
final PackageSource createExportPackageSource(ModuleWire importWire, Collection<BundleLoader> visited) { String name = (String) importWire.getCapability().getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE); BundleLoader providerLoader = (BundleLoader) importWire.getProviderWiring().getModuleLoader(); if (providerLoader == null) { return createMultiSource(name, new PackageSource[0]); } PackageSource requiredSource = providerLoader.findRequiredSource(name, visited); PackageSource exportSource = providerLoader.exportSources.createPackageSource(importWire.getCapability(), false); if (requiredSource == null) return exportSource; return createMultiSource(name, new PackageSource[] {requiredSource, exportSource}); }
@Override public int compare(ModuleWire w1, ModuleWire w2) { int index1 = orderedCapabilities.indexOf(w1.getCapability()); int index2 = orderedCapabilities.indexOf(w2.getCapability()); return index1 - index2; } });
public Bundle[] getHosts(Bundle bundle) { ModuleWiring wiring = getWiring(bundle); if (wiring == null) { return null; } List<ModuleWire> hostWires = wiring.getRequiredModuleWires(HostNamespace.HOST_NAMESPACE); if (hostWires == null) { // we don't hold locks while checking the graph, just return if no longer valid return null; } Collection<Bundle> hosts = new ArrayList<Bundle>(hostWires.size()); for (ModuleWire wire : hostWires) { Bundle host = wire.getProvider().getBundle(); if (host != null) { hosts.add(host); } } return hosts.isEmpty() ? null : hosts.toArray(new Bundle[hosts.size()]); }
@Override public int compare(ModuleWire w1, ModuleWire w2) { int index1 = orderedRequirements.indexOf(w1.getRequirement()); int index2 = orderedRequirements.indexOf(w2.getRequirement()); return index1 - index2; } });
private BundleLoader getProviderLoader(ModuleWire wire) { ModuleWiring provider = wire.getProviderWiring(); if (provider == null) { if (firstUseOfInvalidLoader.getAndSet(true)) { // publish a framework event once per loader, include an exception to show the stack String message = "Invalid class loader from a refreshed bundle is being used: " + toString(); //$NON-NLS-1$ container.getEventPublisher().publishFrameworkEvent(FrameworkEvent.ERROR, wiring.getBundle(), new IllegalStateException(message)); } return null; } return (BundleLoader) provider.getModuleLoader(); }
public Bundle[] getImportingBundles() { if (!providerWiring.isInUse()) { return null; } Set<Bundle> importing = new HashSet<Bundle>(); String packageName = getName(); addRequirers(importing, providerWiring, packageName); List<ModuleWire> providedPackages = providerWiring.getProvidedModuleWires(PackageNamespace.PACKAGE_NAMESPACE); if (providedPackages == null) { // we don't hold locks while checking the graph, just return if no longer valid return null; } for (ModuleWire packageWire : providedPackages) { if (packageCapability.equals(packageWire.getCapability())) { importing.add(packageWire.getRequirer().getBundle()); if (packageWire.getRequirerWiring().isSubstitutedPackage(packageName)) { addRequirers(importing, packageWire.getRequirerWiring(), packageName); } } } return importing.toArray(new Bundle[importing.size()]); }
List<ModuleWire> removedWires = removedWiring.getRequiredModuleWires(null); for (ModuleWire wire : removedWires) { Collection<ModuleWire> providerWires = toRemoveWireLists.get(wire.getProviderWiring()); if (providerWires == null) { providerWires = new ArrayList<ModuleWire>(); toRemoveWireLists.put(wire.getProviderWiring(), providerWires); for (ModuleWire removedWire : entry.getValue()) { removedWire.invalidate();
List<ModuleWire> requiredWires = new ArrayList<>(resultEntry.getValue().size()); for (Wire wire : resultEntry.getValue()) { ModuleWire moduleWire = new ModuleWire((ModuleCapability) wire.getCapability(), (ModuleRevision) wire.getProvider(), (ModuleRequirement) wire.getRequirement(), (ModuleRevision) wire.getRequirer()); requiredWires.add(moduleWire); Map<ModuleCapability, List<ModuleWire>> providedWiresMap = provided.get(moduleWire.getProvider()); if (providedWiresMap == null) { providedWiresMap = new HashMap<>(); provided.put(moduleWire.getProvider(), providedWiresMap); List<ModuleWire> providedWires = providedWiresMap.get(moduleWire.getCapability()); if (providedWires == null) { providedWires = new ArrayList<>(); providedWiresMap.put(moduleWire.getCapability(), providedWires);
private static void addDependents(ModuleRevision revision, Map<ModuleRevision, ModuleWiring> wiringCopy, Set<ModuleRevision> dependencyClosure) { if (dependencyClosure.contains(revision)) return; dependencyClosure.add(revision); ModuleWiring wiring = wiringCopy.get(revision); if (wiring == null) return; List<ModuleWire> provided = wiring.getProvidedModuleWires(null); // No null checks; we are holding the read lock here. // Add all requirers of the provided wires for (ModuleWire providedWire : provided) { addDependents(providedWire.getRequirer(), wiringCopy, dependencyClosure); } // add all hosts of a fragment if (revision.getTypes() == BundleRevision.TYPE_FRAGMENT) { List<ModuleWire> hosts = wiring.getRequiredModuleWires(HostNamespace.HOST_NAMESPACE); for (ModuleWire hostWire : hosts) { addDependents(hostWire.getProvider(), wiringCopy, dependencyClosure); } } }
final void addProvidedPackageNames(String packageName, List<String> result, boolean subPackages, Collection<BundleLoader> visited) { if (visited.contains(this)) return; visited.add(this); for (String exported : exportedPackages) { if (exported.equals(packageName) || (subPackages && isSubPackage(packageName, exported))) { if (!result.contains(exported)) result.add(exported); } } for (String substituted : wiring.getSubstitutedNames()) { if (substituted.equals(packageName) || (subPackages && isSubPackage(packageName, substituted))) { if (!result.contains(substituted)) result.add(substituted); } } for (ModuleWire bundleWire : requiredBundleWires) { if (BundleNamespace.VISIBILITY_REEXPORT.equals(bundleWire.getRequirement().getDirectives().get(BundleNamespace.REQUIREMENT_VISIBILITY_DIRECTIVE))) { BundleLoader loader = (BundleLoader) bundleWire.getProviderWiring().getModuleLoader(); if (loader != null) { loader.addProvidedPackageNames(packageName, result, subPackages, visited); } } } }