Package org.apache.felix.framework

Class StatefulResolver

java.lang.Object

org.apache.felix.framework.StatefulResolver

class StatefulResolver
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	StatefulResolver.ResolverHookRecord

Field Summary

Fields

Modifier and Type	Field	Description
private final Map<String,CapabilitySet>	m_capSets
private final Executor	m_executor
private final Felix	m_felix
private final Set<BundleRevision>	m_fragments
private boolean	m_isResolving
private final Logger	m_logger
private final ServiceRegistry	m_registry
private final org.apache.felix.resolver.ResolverImpl	m_resolver
private final Set<BundleRevision>	m_revisions
private final Set<BundleRevision>	m_selectedSingletons
private ServiceRegistration<?>	m_serviceRegistration
private final Map<String,List<BundleRevision>>	m_singletons

Constructor Summary

Constructors

Constructor	Description
StatefulResolver(Felix felix, ServiceRegistry registry)

Method Summary

Modifier and Type	Method	Description
(package private) void	addRevision(BundleRevision br)
private static void	addToSingletonMap(Map<String,List<BundleRevision>> singletons, BundleRevision br)
private static Set<String>	calculateExportedAndReexportedPackages(BundleRevision br, Map<Resource,List<Wire>> wireMap, Set<String> pkgs, Set<BundleRevision> cycles)
private void	deindexCapabilities(BundleRevision br)
private BundleRequirementImpl	findDynamicRequirement(List<BundleRequirement> dynamics, List<BundleCapability> candidates)
(package private) List<BundleCapability>	findProviders(BundleRequirement req, boolean obeyMandatory)
(package private) List<BundleCapability>	findProvidersInternal(StatefulResolver.ResolverHookRecord record, Requirement req, boolean obeyMandatory, boolean invokeHooksAndSecurity)
private void	fireResolvedEvents(Map<Resource,List<Wire>> wireMap)
private Executor	getExecutor()
private Set<BundleRevision>	getFragments()
private Set<BundleRevision>	getUnresolvedRevisions()
private Map<Resource,Wiring>	getWirings()
private List<BundleRevision>	groupSingletons(Map<BundleCapability,Collection<BundleCapability>> allCollisions, BundleCapability target, List<BundleRevision> group)
private void	indexCapabilities(BundleRevision br)
(package private) boolean	isAllowedDynamicImport(BundleRevision revision, String pkgName)
(package private) boolean	isEffective(Requirement req)
private boolean	isSelectedSingleton(BundleRevision br)
private void	markBundleResolved(BundleRevision revision)
private void	markResolvedRevisions(Map<Resource,List<Wire>> wireMap)
private StatefulResolver.ResolverHookRecord	prepareResolverHooks(Set<BundleRevision> mandatory, Set<BundleRevision> optional)
private void	releaseResolverHooks(StatefulResolver.ResolverHookRecord record)
(package private) void	removeRevision(BundleRevision br)
(package private) void	resolve(Set<BundleRevision> mandatory, Set<BundleRevision> optional)
(package private) BundleRevision	resolve(BundleRevision revision, String pkgName)
private void	selectDefaultSingletons(StatefulResolver.ResolverHookRecord record)
private void	selectSingleton(StatefulResolver.ResolverHookRecord record, List<BundleRevision> singletons)
private void	selectSingletons(StatefulResolver.ResolverHookRecord record)
private void	selectSingletonsUsingHooks(StatefulResolver.ResolverHookRecord record)
(package private) void	start()
(package private) void	stop()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

m_logger

private final Logger m_logger

m_felix

private final Felix m_felix

m_registry

private final ServiceRegistry m_registry

m_executor

private final Executor m_executor

m_resolver

private final org.apache.felix.resolver.ResolverImpl m_resolver

m_isResolving

private boolean m_isResolving

m_revisions

private final Set<BundleRevision> m_revisions

m_fragments

private final Set<BundleRevision> m_fragments

m_capSets

private final Map<String,CapabilitySet> m_capSets

m_singletons

private final Map<String,List<BundleRevision>> m_singletons

m_selectedSingletons

private final Set<BundleRevision> m_selectedSingletons

m_serviceRegistration

private volatile ServiceRegistration<?> m_serviceRegistration

Constructor Details

StatefulResolver

StatefulResolver(Felix felix,
 ServiceRegistry registry)

Method Details

getExecutor

private Executor getExecutor()

start

void start()

stop

void stop()

addRevision

void addRevision(BundleRevision br)

removeRevision

void removeRevision(BundleRevision br)

isEffective

boolean isEffective(Requirement req)

findProviders

List<BundleCapability> findProviders(BundleRequirement req,
 boolean obeyMandatory)

findProvidersInternal

List<BundleCapability> findProvidersInternal(StatefulResolver.ResolverHookRecord record,
 Requirement req,
 boolean obeyMandatory,
 boolean invokeHooksAndSecurity)

resolve

void resolve(Set<BundleRevision> mandatory,
 Set<BundleRevision> optional)
      throws org.osgi.service.resolver.ResolutionException,
BundleException

Throws:

org.osgi.service.resolver.ResolutionException

BundleException

resolve

BundleRevision resolve(BundleRevision revision,
 String pkgName)
                throws org.osgi.service.resolver.ResolutionException,
BundleException

Throws:

org.osgi.service.resolver.ResolutionException

BundleException

findDynamicRequirement

private BundleRequirementImpl findDynamicRequirement(List<BundleRequirement> dynamics,
 List<BundleCapability> candidates)

prepareResolverHooks

private StatefulResolver.ResolverHookRecord prepareResolverHooks(Set<BundleRevision> mandatory,
 Set<BundleRevision> optional)
                                                          throws BundleException,
org.osgi.service.resolver.ResolutionException

Throws:

BundleException

org.osgi.service.resolver.ResolutionException

releaseResolverHooks

private void releaseResolverHooks(StatefulResolver.ResolverHookRecord record)
                           throws BundleException

Throws:

BundleException

isAllowedDynamicImport

boolean isAllowedDynamicImport(BundleRevision revision,
 String pkgName)

markResolvedRevisions

private void markResolvedRevisions(Map<Resource,List<Wire>> wireMap)
                            throws ResolveException

Throws:

ResolveException

markBundleResolved

private void markBundleResolved(BundleRevision revision)

fireResolvedEvents

private void fireResolvedEvents(Map<Resource,List<Wire>> wireMap)

calculateExportedAndReexportedPackages

private static Set<String> calculateExportedAndReexportedPackages(BundleRevision br,
 Map<Resource,List<Wire>> wireMap,
 Set<String> pkgs,
 Set<BundleRevision> cycles)

indexCapabilities

private void indexCapabilities(BundleRevision br)

deindexCapabilities

private void deindexCapabilities(BundleRevision br)

isSelectedSingleton

private boolean isSelectedSingleton(BundleRevision br)

selectSingletons

private void selectSingletons(StatefulResolver.ResolverHookRecord record)
                       throws BundleException

Throws:

BundleException

selectDefaultSingletons

private void selectDefaultSingletons(StatefulResolver.ResolverHookRecord record)

selectSingletonsUsingHooks

private void selectSingletonsUsingHooks(StatefulResolver.ResolverHookRecord record)
                                 throws BundleException

Throws:

BundleException

groupSingletons

private List<BundleRevision> groupSingletons(Map<BundleCapability,Collection<BundleCapability>> allCollisions,
 BundleCapability target,
 List<BundleRevision> group)

selectSingleton

private void selectSingleton(StatefulResolver.ResolverHookRecord record,
 List<BundleRevision> singletons)

getFragments

private Set<BundleRevision> getFragments()

getUnresolvedRevisions

private Set<BundleRevision> getUnresolvedRevisions()

getWirings

private Map<Resource,Wiring> getWirings()

addToSingletonMap

private static void addToSingletonMap(Map<String,List<BundleRevision>> singletons,
 BundleRevision br)