org.osgi.resource.Wire Java Examples

public synchronized Map<Resource, List<Wire>> resolve(
		final ResolveContext context) throws ResolutionException {
	if (context == null) {
		throw new IllegalArgumentException("context is null");
	}

	final MultiMap<Resource, Wire> solution = new MultiMap<Resource, Wire>();
	final ArrayList<Requirement> unresolvedRequirements = new ArrayList<Requirement>();
	final ArrayList<Resource> unresolvedResources = new ArrayList<Resource>();

	resolve0(context, solution, unresolvedRequirements,
			unresolvedResources, true);

	if (!unresolvedRequirements.isEmpty()
			|| !unresolvedResources.isEmpty()) {
		throw new ResolutionException("Could not resolve.", null,
				unresolvedRequirements);
	}

	return solution.getFlatMap();
}
 

@Override
public Set<Resource> findResolution(List<Resource> resources)
    throws Exception {
  Resolver resolver = resolverTracker.getService();
  if (resolver == null) {
    throw new Exception(
        "Unable to find resolution: No Resolver service available!");
  }

  ResolveContextImpl rc = new ResolveContextImpl(bc, resources,
      new ArrayList<Resource>());
  Map<Resource, List<Wire>> resolution = resolver.resolve(rc);
  return resolution.keySet();
}
 

private void hostFragment(final ResolveContext context,
		final BundleRevision fragment, final BundleRevision host,
		final MultiMap<Resource, Wire> solution) {
	// host the capabilities
	for (final Capability cap : fragment.getCapabilities(null)) {
		if (!IdentityNamespace.IDENTITY_NAMESPACE
				.equals(cap.getNamespace())) {
			final HostedBundleCapability hostedCap = new HostedBundleCapability(
					host, cap);

			context.insertHostedCapability(
					new ArrayList<Capability>(host.getCapabilities(
							PackageNamespace.PACKAGE_NAMESPACE)),
					hostedCap);
		}
	}

	// create host wire
	final Capability hostCapability = host
			.getCapabilities(HostNamespace.HOST_NAMESPACE).get(0);
	final Requirement hostRequirement = fragment
			.getRequirements(HostNamespace.HOST_NAMESPACE).get(0);

	final Wire wire = Resources.createWire(hostCapability,
			hostRequirement);
	solution.insert(fragment, wire);
	solution.insert(host, wire);
}
 

public boolean equals(final Object o) {
	if (o instanceof AbstractWireImpl) {
		return o == this;
	}
	if (o instanceof Wire) {
		final Wire w = (Wire) o;
		return w.getRequirer().equals(requirement.getResource())
				&& w.getRequirement().equals(requirement)
				&& w.getProvider().equals(capability.getResource())
				&& w.getCapability().equals(capability);
	}
	return false;
}
 

private void addWire(final Wire wire) {
	if (wire.getProvider() == resource) {
		final Capability cap = wire.getCapability();
		capabilities.insertUnique(cap.getNamespace(), cap);
		providedWires.insert(cap.getNamespace(), wire);
	} else {
		final Requirement req = wire.getRequirement();
		requirements.insertUnique(req.getNamespace(), req);
		requiredWires.insert(req.getNamespace(), wire);
	}
}
 

ConciergeBundleWiring addAdditionalWires(final List<Wire> wires) {
	for (final Wire wire : wires) {
		wiring.addWire((BundleWire) wire);
	}

	packageImportWires = wiring.getPackageImportWires();
	requireBundleWires = wiring.getRequireBundleWires();
	return wiring;
}
 

@Override
public List<Wire> getProvidedResourceWires(String p1) {
    throw new UnsupportedOperationException();
}
 

@SuppressWarnings("unchecked")
@Override
public List<Wire> getRequiredResourceWires(String namespace) {
  return (List<Wire>)(List<?>)getRequiredWires(namespace);
}
 

@SuppressWarnings("unchecked")
@Override
public List<Wire> getProvidedResourceWires(String namespace) {
  return (List<Wire>)(List<?>)getProvidedWires(namespace);
}
 

public List<Wire> getRequiredResourceWires(final String namespace) {
	final List<BundleWire> bwires = getRequiredWires(namespace);
	return bwires == null ? null : new ArrayList<Wire>(bwires);
}
 

public List<Wire> getProvidedResourceWires(final String namespace) {
	final List<BundleWire> bwires = getProvidedWires(namespace);
	return bwires == null ? null : new ArrayList<Wire>(bwires);
}
 

public List<Wire> getRequiredResourceWires(final String namespace) {
	return namespace == null ? requiredWires.getAllValues()
			: requiredWires.lookup(namespace);
}
 

public List<Wire> getProvidedResourceWires(final String namespace) {
	return namespace == null ? providedWires.getAllValues()
			: providedWires.lookup(namespace);
}
 

ConciergeWiring(final Resource resource, final List<Wire> wires) {
	this.resource = resource;
	for (final Wire wire : wires) {
		addWire(wire);
	}
}
 

static Wire createWire(final Capability cap, final Requirement req) {
	return cap instanceof BundleCapability
			&& req instanceof BundleRequirement ? new ConciergeBundleWire(
			(BundleCapability) cap, (BundleRequirement) req)
			: new ConciergeWire(cap, req);
}
 

@Override
public List<Wire> getProvidedResourceWires(String p1) {
    throw new UnsupportedOperationException();
}
 

@Override
public List<Wire> getRequiredResourceWires(String p1) {
    throw new UnsupportedOperationException();
}
 

@Override
public List<Wire> getRequiredResourceWires(String p1) {
    throw new UnsupportedOperationException();
}
 

/**
 * Resolve the specified resolve context and return any new resources and
 * wires to the caller.
 * 
 * <p>
 * The resolver considers two groups of resources:
 * <ul>
 * <li>Mandatory - any resource in the
 * {@link ResolveContext#getMandatoryResources() mandatory group} must be
 * resolved. A failure to satisfy any mandatory requirement for these
 * resources will result in throwing a {@link ResolutionException}</li>
 * <li>Optional - any resource in the
 * {@link ResolveContext#getOptionalResources() optional group} may be
 * resolved. A failure to satisfy a mandatory requirement for a resource in
 * this group will not fail the overall resolution but no resources or wires
 * will be returned for that resource.</li>
 * </ul>
 * 
 * <p>
 * The resolve method returns the delta between the start state defined by
 * {@link ResolveContext#getWirings()} and the end resolved state. That is,
 * only new resources and wires are included.
 * 
 * <p>
 * The behavior of the resolver is not defined if the specified resolve
 * context supplies inconsistent information.
 * 
 * @param context The resolve context for the resolve operation. Must not be
 *        {@code null}.
 * @return The new resources and wires required to satisfy the specified
 *         resolve context. The returned map is the property of the caller
 *         and can be modified by the caller.
 * @throws ResolutionException If the resolution cannot be satisfied.
 */
Map<Resource, List<Wire>> resolve(ResolveContext context) throws ResolutionException;
 

/**
 * Returns the {@link Wire}s to the provided {@link Capability capabilities}
 * of this wiring.
 * 
 * <p>
 * This method returns the same value as {@link #getProvidedWires(String)}.
 * 
 * @param namespace The namespace of the capabilities for which to return
 *        wires or {@code null} to return the wires for the capabilities in
 *        all namespaces.
 * @return A list containing a snapshot of the {@link Wire}s for the
 *         {@link Capability capabilities} of this wiring, or an empty list
 *         if this wiring has no capabilities in the specified namespace.
 *         For a given namespace, the list contains the wires in the order
 *         the capabilities were specified in the manifests of the
 *         {@link #getResource() resource} and the attached fragment
 *         resources of this wiring. There is no ordering defined between
 *         capabilities in different namespaces.
 * @since 1.1
 */
List<Wire> getProvidedResourceWires(String namespace);
 

/**
 * Returns the {@link Wire}s to the {@link Requirement requirements} in use
 * by this wiring.
 * 
 * <p>
 * This method returns the same value as {@link #getRequiredWires(String)}.
 * 
 * @param namespace The namespace of the requirements for which to return
 *        wires or {@code null} to return the wires for the requirements in
 *        all namespaces.
 * @return A list containing a snapshot of the {@link Wire}s for the
 *         {@link Requirement requirements} of this wiring, or an empty list
 *         if this wiring has no requirements in the specified namespace.
 *         For a given namespace, the list contains the wires in the order
 *         the requirements were specified in the manifests of the
 *         {@link #getResource() resource} and the attached fragment
 *         resources of this wiring. There is no ordering defined between
 *         requirements in different namespaces.
 * @since 1.1
 */
List<Wire> getRequiredResourceWires(String namespace);
 

/**
 * Resolve the specified resolve context and return any new resources and
 * wires to the caller.
 * 
 * <p>
 * The resolver considers two groups of resources:
 * <ul>
 * <li>Mandatory - any resource in the
 * {@link ResolveContext#getMandatoryResources() mandatory group} must be
 * resolved. A failure to satisfy any mandatory requirement for these
 * resources will result in throwing a {@link ResolutionException}</li>
 * <li>Optional - any resource in the
 * {@link ResolveContext#getOptionalResources() optional group} may be
 * resolved. A failure to satisfy a mandatory requirement for a resource in
 * this group will not fail the overall resolution but no resources or wires
 * will be returned for that resource.</li>
 * </ul>
 * 
 * <p>
 * The resolve method returns the delta between the start state defined by
 * {@link ResolveContext#getWirings()} and the end resolved state. That is,
 * only new resources and wires are included.
 * 
 * <p>
 * The behavior of the resolver is not defined if the specified resolve
 * context supplies inconsistent information.
 * 
 * @param context The resolve context for the resolve operation. Must not be
 *        {@code null}.
 * @return The new resources and wires required to satisfy the specified
 *         resolve context. The returned map is the property of the caller
 *         and can be modified by the caller.
 * @throws ResolutionException If the resolution cannot be satisfied.
 */
Map<Resource, List<Wire>> resolve(ResolveContext context) throws ResolutionException;
 

/**
 * Returns the {@link Wire}s to the provided {@link Capability capabilities}
 * of this wiring.
 * 
 * <p>
 * This method returns the same value as {@link #getProvidedWires(String)}.
 * 
 * @param namespace The namespace of the capabilities for which to return
 *        wires or {@code null} to return the wires for the capabilities in
 *        all namespaces.
 * @return A list containing a snapshot of the {@link Wire}s for the
 *         {@link Capability capabilities} of this wiring, or an empty list
 *         if this wiring has no capabilities in the specified namespace.
 *         For a given namespace, the list contains the wires in the order
 *         the capabilities were specified in the manifests of the
 *         {@link #getResource() resource} and the attached fragment
 *         resources of this wiring. There is no ordering defined between
 *         capabilities in different namespaces.
 * @since 1.1
 */
List<Wire> getProvidedResourceWires(String namespace);
 

/**
 * Returns the {@link Wire}s to the {@link Requirement requirements} in use
 * by this wiring.
 * 
 * <p>
 * This method returns the same value as {@link #getRequiredWires(String)}.
 * 
 * @param namespace The namespace of the requirements for which to return
 *        wires or {@code null} to return the wires for the requirements in
 *        all namespaces.
 * @return A list containing a snapshot of the {@link Wire}s for the
 *         {@link Requirement requirements} of this wiring, or an empty list
 *         if this wiring has no requirements in the specified namespace.
 *         For a given namespace, the list contains the wires in the order
 *         the requirements were specified in the manifests of the
 *         {@link #getResource() resource} and the attached fragment
 *         resources of this wiring. There is no ordering defined between
 *         requirements in different namespaces.
 * @since 1.1
 */
List<Wire> getRequiredResourceWires(String namespace);