Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) OSGi Alliance (2011, 2013). All Rights Reserved.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.osgi.service.resolver;
 
 import java.util.List;
 import java.util.Map;
A resolve context provides resources, options and constraints to the potential solution of a resolve operation.

Resolve Contexts:

  • Specify the mandatory and optional resources to resolve. The mandatory and optional resources must be consistent and correct. For example, they must not violate the singleton policy of the implementer.
  • Provide capabilities that the Resolver can use to satisfy requirements via the findProviders(org.osgi.resource.Requirement) method
  • Constrain solutions via the getWirings() method. A wiring consists of a map of existing resources to wiring.
  • Filter requirements that are part of a resolve operation via the isEffective(org.osgi.resource.Requirement).

A resolver may call the methods on the resolve context any number of times during a resolve operation using any thread. Implementors should ensure that this class is properly thread safe.

Except for insertHostedCapability(java.util.List,org.osgi.service.resolver.HostedCapability), the resolve context methods must be idempotent. This means that resources must have constant capabilities and requirements and the resolve context must return a consistent set of capabilities, wires and effective requirements.

Author(s):
$Id: 31e6bd75deae054742a168e7d5b76915b07cbb54 $
ThreadSafe:
 
 public abstract class ResolveContext {
Return the resources that must be resolved for this resolve context.

The default implementation returns an empty collection.

Returns:
The resources that must be resolved for this resolve context. May be empty if there are no mandatory resources.
 
 		return emptyCollection();
 	}

Return the resources that the resolver should attempt to resolve for this resolve context. Inability to resolve one of the specified resources will not result in a resolution exception.

The default implementation returns an empty collection.

Returns:
The resources that the resolver should attempt to resolve for this resolve context. May be empty if there are no mandatory resources.
 
 		return emptyCollection();
 	}
 
 	private static <T> Collection<T> emptyCollection() {
 	}

Find Capabilities that match the given Requirement.

The returned list contains org.osgi.resource.Capability objects where the Resource must be the declared Resource of the Capability. The Resolver can then add additional HostedCapability objects with the insertHostedCapability(java.util.List,org.osgi.service.resolver.HostedCapability) method when it, for example, attaches fragments. Those HostedCapability objects will then use the host's Resource which likely differs from the declared Resource of the corresponding Capability.

The returned list is in priority order such that the Capabilities with a lower index have a preference over those with a higher index. The resolver must use the insertHostedCapability(java.util.List,org.osgi.service.resolver.HostedCapability) method to add additional Capabilities to maintain priority order. In general, this is necessary when the Resolver uses Capabilities declared in a Resource but that must originate from an attached host.

Each returned Capability must match the given Requirement. This implies that the filter in the Requirement must match as well as any namespace specific directives. For example, the mandatory attributes for the osgi.wiring.package namespace.

Parameters:
requirement The requirement that a resolver is attempting to satisfy. Must not be null.
Returns:
A list of org.osgi.resource.Capability objects that match the specified requirement.
	public abstract List<CapabilityfindProviders(Requirement requirement);

Add a HostedCapability to the list of capabilities returned from findProviders(org.osgi.resource.Requirement).

This method is used by the Resolver to add Capabilities that are hosted by another Resource to the list of Capabilities returned from findProviders(org.osgi.resource.Requirement). This function is necessary to allow fragments to attach to hosts, thereby changing the origin of a Capability. This method must insert the specified HostedCapability in a place that makes the list maintain the preference order. It must return the index in the list of the inserted HostedCapability.

Parameters:
capabilities The list returned from findProviders(org.osgi.resource.Requirement). Must not be null.
hostedCapability The HostedCapability to insert in the specified list. Must not be null.
Returns:
The index in the list of the inserted HostedCapability.
	public abstract int insertHostedCapability(List<CapabilitycapabilitiesHostedCapability hostedCapability);

Test if a given requirement should be wired in the resolve operation. If this method returns false, then the resolver should ignore this requirement during the resolve operation.

The primary use case for this is to test the effective directive on the requirement, though implementations are free to use any effective test.

Parameters:
requirement The Requirement to test. Must not be null.
Returns:
true if the requirement should be considered as part of the resolve operation.
	public abstract boolean isEffective(Requirement requirement);

Returns the wirings for existing resolved resources.

For example, if this resolve context is for an OSGi framework, then the result would contain all the currently resolved bundles with each bundle's current wiring.

Multiple calls to this method for this resolve context must return the same result.

Returns:
The wirings for existing resolved resources. The returned map is unmodifiable.
	public abstract Map<ResourceWiringgetWirings();
New to GrepCode? Check out our FAQ X