|
![]() |
|||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use ComponentAdapter | |
---|---|
org.picocontainer | This package contains the core API for PicoContainer, a compact container for working with the dependency injection pattern. |
org.picocontainer.adapters | |
org.picocontainer.behaviors | |
org.picocontainer.classname | |
org.picocontainer.containers | |
org.picocontainer.defaults | |
org.picocontainer.defaults.issues | |
org.picocontainer.gems.adapters | |
org.picocontainer.gems.behaviors | |
org.picocontainer.gems.constraints | |
org.picocontainer.gems.containers | |
org.picocontainer.gems.injectors | |
org.picocontainer.gems.jmx | The package contains classes to expose components of PicoContainer with JMX. |
org.picocontainer.gems.jndi | |
org.picocontainer.gems.monitors | This package contains various implementations of the ComponentMonitor interface that extend
the capabilities supplied by the default PicoContainer. |
org.picocontainer.injectors | |
org.picocontainer.monitors | |
org.picocontainer.parameters | |
org.picocontainer.tck | |
org.picocontainer.visitors |
Uses of ComponentAdapter in org.picocontainer |
---|
Subinterfaces of ComponentAdapter in org.picocontainer | |
---|---|
interface |
Behavior<T>
Behaviors modify the components created by a Injector with additional behaviors |
interface |
Injector<T>
Implementors are responsible for instantiating and injecting dependancies into Constructors, Methods and Fields. |
Fields in org.picocontainer with type parameters of type ComponentAdapter | |
---|---|
protected List<ComponentAdapter<?>> |
DefaultPicoContainer.orderedComponentAdapters
|
Methods in org.picocontainer with type parameters of type ComponentAdapter | ||
---|---|---|
|
ComponentAdapter.findAdapterOfType(Class<U> componentAdapterType)
Locates a component adapter of type componentAdapterType in the ComponentAdapter chain. |
Methods in org.picocontainer that return ComponentAdapter | ||
---|---|---|
|
BehaviorFactory.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
ComponentFactory.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
Create a new component adapter based on the specified arguments. |
|
ComponentAdapter |
PicoBuilderTestCase.CustomComponentFactory.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
|
|
PicoContainer.getComponentAdapter(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
|
DefaultPicoContainer.getComponentAdapter(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
|
PicoContainer.getComponentAdapter(Class<T> componentType,
NameBinding componentNameBinding)
Find a component adapter associated with the specified type. |
|
|
DefaultPicoContainer.getComponentAdapter(Class<T> componentType,
NameBinding componentNameBinding)
Find a component adapter associated with the specified type. |
|
ComponentAdapter<?> |
PicoContainer.getComponentAdapter(Object componentKey)
Find a component adapter associated with the specified key. |
|
ComponentAdapter<?> |
DefaultPicoContainer.getComponentAdapter(Object componentKey)
Find a component adapter associated with the specified key. |
|
ComponentAdapter<T> |
ComponentAdapter.getDelegate()
Component adapters may be nested in a chain, and this method is used to grab the next ComponentAdapter in the chain. |
|
|
MutablePicoContainer.removeComponent(Object componentKey)
Unregister a component by key. |
|
|
DefaultPicoContainer.removeComponent(Object componentKey)
Unregister a component by key. |
|
|
MutablePicoContainer.removeComponentByInstance(T componentInstance)
Unregister a component by instance. |
|
|
DefaultPicoContainer.removeComponentByInstance(T componentInstance)
Unregister a component by instance. |
Methods in org.picocontainer that return types with arguments of type ComponentAdapter | ||
---|---|---|
Collection<ComponentAdapter<?>> |
PicoContainer.getComponentAdapters()
Retrieve all the component adapters inside this container. |
|
Collection<ComponentAdapter<?>> |
DefaultPicoContainer.getComponentAdapters()
Retrieve all the component adapters inside this container. |
|
|
PicoContainer.getComponentAdapters(Class<T> componentType)
Retrieve all component adapters inside this container that are associated with the specified type. |
|
|
DefaultPicoContainer.getComponentAdapters(Class<T> componentType)
Retrieve all component adapters inside this container that are associated with the specified type. |
|
|
PicoContainer.getComponentAdapters(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
|
DefaultPicoContainer.getComponentAdapters(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
protected Map<Object,ComponentAdapter<?>> |
DefaultPicoContainer.getComponentKeyToAdapterCache()
|
|
protected List<ComponentAdapter<?>> |
DefaultPicoContainer.getModifiableComponentAdapterList()
|
|
protected List<ComponentAdapter<?>> |
DefaultPicoContainer.getOrderedComponentAdapters()
|
Methods in org.picocontainer with parameters of type ComponentAdapter | ||
---|---|---|
MutablePicoContainer |
MutablePicoContainer.addAdapter(ComponentAdapter<?> componentAdapter)
Register a component via a ComponentAdapter. |
|
MutablePicoContainer |
DefaultPicoContainer.addAdapter(ComponentAdapter<?> componentAdapter)
Register a component via a ComponentAdapter. |
|
MutablePicoContainer |
DefaultPicoContainer.addAdapter(ComponentAdapter<?> componentAdapter,
Properties properties)
|
|
protected MutablePicoContainer |
DefaultPicoContainer.addAdapterInternal(ComponentAdapter<?> componentAdapter)
|
|
|
BehaviorFactory.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
ComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] injected,
long duration)
Event thrown after the component has been instantiated using the given constructor. |
|
|
ComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
Event thrown as the component is being instantiated using the given constructor |
|
|
ComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception cause)
Event thrown if the component instantiation failed using the given constructor |
|
void |
ComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
Event thrown after the component method has been invoked on the given instance |
|
void |
ComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
Event thrown as the component method is being invoked on the given instance |
|
boolean |
Parameter.isResolvable(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
Check if the Parameter can satisfy the expected type using the container. |
|
void |
ComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
Event thrown if a lifecycle method invocation - start, stop or dispose - failed on the given instance |
|
|
Parameter.resolveInstance(PicoContainer container,
ComponentAdapter adapter,
Class<T> expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
Retrieve the object from the Parameter that satisfies the expected type. |
|
void |
Parameter.verify(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
Verify that the Parameter can satisfy the expected type using the container |
|
void |
PicoVisitor.visitComponentAdapter(ComponentAdapter<?> componentAdapter)
Visit a ComponentAdapter that has to accept the visitor. |
Uses of ComponentAdapter in org.picocontainer.adapters |
---|
Classes in org.picocontainer.adapters that implement ComponentAdapter | |
---|---|
class |
AbstractAdapter<T>
Base class for a ComponentAdapter with general functionality. |
class |
InstanceAdapter<T>
Component adapter which wraps a component instance. |
class |
NullCA
|
static class |
SimpleNamedBindingAnnotationTestCase.FieldInjector<T>
|
Methods in org.picocontainer.adapters with type parameters of type ComponentAdapter | ||
---|---|---|
|
AbstractAdapter.findAdapterOfType(Class<U> componentAdapterType)
|
Methods in org.picocontainer.adapters that return ComponentAdapter | ||
---|---|---|
|
SimpleNamedBindingAnnotationTestCase.FieldInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter |
NullCA.findAdapterOfType(Class componentAdapterType)
|
|
ComponentAdapter |
NullCA.getDelegate()
|
|
ComponentAdapter<T> |
AbstractAdapter.getDelegate()
|
|
protected ComponentAdapter |
InstanceAdapterTestCase.prepDEF_verifyDoesNotInstantiate(MutablePicoContainer picoContainer)
Prepare the test verifyDoesNotInstantiate. |
|
protected ComponentAdapter |
InstanceAdapterTestCase.prepDEF_verifyWithoutDependencyWorks(MutablePicoContainer picoContainer)
Prepare the test verifyWithoutDependencyWorks. |
|
protected ComponentAdapter |
InstanceAdapterTestCase.prepDEF_visitable()
Prepare the test visitable. |
|
protected ComponentAdapter |
InstanceAdapterTestCase.prepSER_isSerializable(MutablePicoContainer picoContainer)
Prepare the test isSerializable. |
|
protected ComponentAdapter |
InstanceAdapterTestCase.prepSER_isXStreamSerializable(MutablePicoContainer picoContainer)
Prepare the test isXStreamSerializable. |
Uses of ComponentAdapter in org.picocontainer.behaviors |
---|
Subinterfaces of ComponentAdapter in org.picocontainer.behaviors | |
---|---|
static interface |
BehaviorAdapterTestCase.ComponentAdapterThatCanManageLifecycle
|
static interface |
BehaviorAdapterTestCase.ComponentAdapterThatSupportsStrategy
|
static interface |
CachedTestCase.ComponentAdapterSupportingLifecycleStrategy
|
Classes in org.picocontainer.behaviors that implement ComponentAdapter | |
---|---|
class |
AbstractBehavior<T>
Component adapter which decorates another adapter. |
class |
Automated<T>
|
class |
Cached<T>
ComponentAdapter implementation that caches the component instance. |
class |
Decorated
|
class |
FieldDecorated
|
class |
HiddenImplementation<T>
This component adapter makes it possible to hide the implementation of a real subject (behind a proxy) provided the key is an interface. |
class |
Intercepted<T>
|
class |
Locked<T>
|
class |
PropertyApplicator<T>
Decorating component adapter that can be used to set additional properties on a component in a bean style. |
class |
Stored<T>
behaviour for all behaviours wishing to store their component in "awkward places" ( object references ) |
class |
Synchronized<T>
Component Adapter that uses java synchronized around getComponentInstance(). |
class |
ThreadCached<T>
This behavior supports caches values per thread. |
Fields in org.picocontainer.behaviors declared as ComponentAdapter | |
---|---|
protected ComponentAdapter<T> |
AbstractBehavior.delegate
|
Methods in org.picocontainer.behaviors with type parameters of type ComponentAdapter | ||
---|---|---|
|
AbstractBehavior.findAdapterOfType(Class<U> componentAdapterType)
|
Methods in org.picocontainer.behaviors that return ComponentAdapter | ||
---|---|---|
ComponentAdapter |
AdaptingBehavior.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
ComponentAdapter |
FieldDecorating.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
ComponentAdapter |
Automating.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
ComponentAdapter |
Decorating.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
ComponentAdapter |
ImplementationHiding.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
ComponentAdapter |
OptInCaching.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
|
AbstractBehaviorFactory.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
PropertyApplying.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
Synchronizing.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
ThreadCaching.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
Locking.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
Caching.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
Storing.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
AbstractBehaviorFactory.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
PropertyApplying.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
Synchronizing.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
Create a new component adapter based on the specified arguments. |
|
|
ThreadCaching.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
Locking.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
Create a new component adapter based on the specified arguments. |
|
|
Intercepting.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
Caching.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
Storing.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter |
AdaptingBehavior.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter |
FieldDecorating.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter |
Automating.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter |
Decorating.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter |
ImplementationHiding.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter |
OptInCaching.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter<T> |
AbstractBehavior.getDelegate()
|
|
protected ComponentAdapter |
SynchronizedTestCase.makeComponentAdapter(ComponentAdapter componentAdapter)
|
|
protected ComponentAdapter |
LockedTestCase.makeComponentAdapter(ComponentAdapter componentAdapter)
|
Constructors in org.picocontainer.behaviors with parameters of type ComponentAdapter | |
---|---|
AbstractBehavior(ComponentAdapter<T> delegate)
|
|
Automated(ComponentAdapter<T> delegate)
|
|
Cached(ComponentAdapter delegate)
|
|
Cached(ComponentAdapter delegate,
ObjectReference instanceReference)
|
|
Decorated(ComponentAdapter delegate,
Decorated.Decorator decorator)
|
|
FieldDecorated(ComponentAdapter delegate,
Class<?> fieldClass,
FieldDecorated.Decorator decorator)
|
|
HiddenImplementation(ComponentAdapter<T> delegate)
Creates an ImplementationHidingComponentAdapter with a delegate |
|
Intercepted(ComponentAdapter delegate)
|
|
Locked(ComponentAdapter<T> delegate)
|
|
PropertyApplicator(ComponentAdapter<T> delegate)
Construct a PropertyApplicator. |
|
Stored(ComponentAdapter<T> delegate,
ObjectReference<T> reference)
|
|
Synchronized(ComponentAdapter<T> delegate)
|
|
ThreadCached(ComponentAdapter<T> delegate)
|
Uses of ComponentAdapter in org.picocontainer.classname |
---|
Methods in org.picocontainer.classname that return ComponentAdapter | |
---|---|
ComponentAdapter<?> |
DefaultClassLoadingPicoContainer.getComponentAdapter(Object componentKey)
|
Methods in org.picocontainer.classname with parameters of type ComponentAdapter | |
---|---|
MutablePicoContainer |
DefaultClassLoadingPicoContainer.addAdapter(ComponentAdapter<?> componentAdapter)
|
Uses of ComponentAdapter in org.picocontainer.containers |
---|
Methods in org.picocontainer.containers that return ComponentAdapter | ||
---|---|---|
|
AbstractDelegatingPicoContainer.getComponentAdapter(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
|
ImmutablePicoContainer.getComponentAdapter(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
|
EmptyPicoContainer.getComponentAdapter(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
|
AbstractDelegatingPicoContainer.getComponentAdapter(Class<T> componentType,
NameBinding componentNameBinding)
|
|
|
ImmutablePicoContainer.getComponentAdapter(Class<T> componentType,
NameBinding componentNameBinding)
|
|
|
EmptyPicoContainer.getComponentAdapter(Class<T> componentType,
NameBinding componentNameBinding)
|
|
ComponentAdapter<?> |
AbstractDelegatingPicoContainer.getComponentAdapter(Object componentKey)
|
|
ComponentAdapter<?> |
ImmutablePicoContainer.getComponentAdapter(Object componentKey)
|
|
ComponentAdapter<?> |
EmptyPicoContainer.getComponentAdapter(Object componentKey)
|
|
|
AbstractDelegatingMutablePicoContainer.removeComponent(Object componentKey)
|
|
|
AbstractDelegatingMutablePicoContainer.removeComponentByInstance(T componentInstance)
|
Methods in org.picocontainer.containers that return types with arguments of type ComponentAdapter | ||
---|---|---|
Collection<ComponentAdapter<?>> |
AbstractDelegatingPicoContainer.getComponentAdapters()
|
|
Collection<ComponentAdapter<?>> |
ImmutablePicoContainer.getComponentAdapters()
|
|
Collection<ComponentAdapter<?>> |
EmptyPicoContainer.getComponentAdapters()
|
|
|
AbstractDelegatingPicoContainer.getComponentAdapters(Class<T> componentType)
|
|
|
CommandLinePicoContainer.getComponentAdapters(Class<T> componentType)
|
|
|
ImmutablePicoContainer.getComponentAdapters(Class<T> componentType)
|
|
|
EmptyPicoContainer.getComponentAdapters(Class<T> componentType)
|
|
|
AbstractDelegatingPicoContainer.getComponentAdapters(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
|
ImmutablePicoContainer.getComponentAdapters(Class<T> componentType,
Class<? extends Annotation> binding)
|
|
|
EmptyPicoContainer.getComponentAdapters(Class<T> componentType,
Class<? extends Annotation> binding)
|
Methods in org.picocontainer.containers with parameters of type ComponentAdapter | |
---|---|
MutablePicoContainer |
AbstractDelegatingMutablePicoContainer.addAdapter(ComponentAdapter<?> componentAdapter)
|
Uses of ComponentAdapter in org.picocontainer.defaults |
---|
Classes in org.picocontainer.defaults that implement ComponentAdapter | |
---|---|
static class |
UserQuestionTestCase.CheeseAdapter
|
Uses of ComponentAdapter in org.picocontainer.defaults.issues |
---|
Methods in org.picocontainer.defaults.issues with parameters of type ComponentAdapter | |
---|---|
void |
Issue0303TestCase.SwallowingComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
|
Uses of ComponentAdapter in org.picocontainer.gems.adapters |
---|
Classes in org.picocontainer.gems.adapters that implement ComponentAdapter | |
---|---|
class |
DelegateMethodAdapter<T>
Object construction is sometimes expensive, especially when it is seldom used object. |
class |
StaticFactoryAdapter<T>
Component adapter that wrapps a static factory with the help of StaticFactory . |
class |
ThreadLocalized<T>
A ComponentAdapter that realizes a ThreadLocal component instance. |
Methods in org.picocontainer.gems.adapters that return ComponentAdapter | ||
---|---|---|
ComponentAdapter |
ThreadLocalizing.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
|
DelegateAdaptorFactory.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
Create a new component adapter based on the specified arguments. |
|
ComponentAdapter |
ThreadLocalizing.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter<T> |
DelegateMethodAdapter.findAdapterOfType(Class componentAdapterType)
Locates a component adapter of type componentAdapterType in the ComponentAdapter chain. |
|
ComponentAdapter<T> |
DelegateMethodAdapter.getDelegate()
No delegates. |
Methods in org.picocontainer.gems.adapters with parameters of type ComponentAdapter | |
---|---|
ComponentAdapter |
ThreadLocalizing.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
Constructors in org.picocontainer.gems.adapters with parameters of type ComponentAdapter | |
---|---|
ThreadLocalized(ComponentAdapter<T> delegate)
Construct a ThreadLocalized using Proxy instances. |
|
ThreadLocalized(ComponentAdapter<T> delegate,
ProxyFactory proxyFactory)
Construct a ThreadLocalized. |
Uses of ComponentAdapter in org.picocontainer.gems.behaviors |
---|
Classes in org.picocontainer.gems.behaviors that implement ComponentAdapter | |
---|---|
class |
AsmHiddenImplementation<T>
This component adapter makes it possible to hide the implementation of a real subject (behind a proxy). |
class |
Assimilated<T>
ComponentAdapter that assimilates a component for a specific type. |
class |
HotSwappable<T>
This component adapter makes it possible to hide the implementation of a real subject (behind a proxy). |
class |
Pooled<T>
ComponentAdapter implementation that pools components. |
Methods in org.picocontainer.gems.behaviors that return ComponentAdapter | ||
---|---|---|
ComponentAdapter |
Assimilating.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
ComponentAdapter |
Pooling.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
|
HotSwapping.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
AsmImplementationHiding.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
HotSwapping.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
AsmImplementationHiding.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter |
Assimilating.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
Create a Assimilated . |
|
ComponentAdapter |
Pooling.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class componentImplementation,
Parameter... parameters)
|
Methods in org.picocontainer.gems.behaviors with parameters of type ComponentAdapter | ||
---|---|---|
ComponentAdapter |
Assimilating.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
ComponentAdapter |
Pooling.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter adapter)
|
|
|
HotSwapping.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
AsmImplementationHiding.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
Constructors in org.picocontainer.gems.behaviors with parameters of type ComponentAdapter | |
---|---|
AsmHiddenImplementation(ComponentAdapter<T> delegate)
|
|
Assimilated(Class<T> type,
ComponentAdapter delegate)
Construct an Assimilated. |
|
Assimilated(Class<T> type,
ComponentAdapter delegate,
ProxyFactory proxyFactory)
Construct an Assimilated. |
|
HiddenImplementation(ComponentAdapter<T> delegate)
Deprecated. |
|
HotSwappable(ComponentAdapter<T> delegate)
|
|
Pooled(ComponentAdapter delegate,
Pooled.Context context)
Construct a Pooled. |
Uses of ComponentAdapter in org.picocontainer.gems.constraints |
---|
Methods in org.picocontainer.gems.constraints that return types with arguments of type ComponentAdapter | |
---|---|
protected Map<Object,ComponentAdapter<?>> |
AbstractConstraint.getMatchingComponentAdapters(PicoContainer container,
ComponentAdapter adapter,
Class keyType,
Class valueType)
|
Methods in org.picocontainer.gems.constraints with parameters of type ComponentAdapter | |
---|---|
abstract boolean |
AbstractConstraint.evaluate(ComponentAdapter adapter)
|
boolean |
Constraint.evaluate(ComponentAdapter adapter)
Evaluate whether the given component adapter matches this constraint. |
boolean |
CollectionConstraint.evaluate(ComponentAdapter adapter)
|
boolean |
Not.evaluate(ComponentAdapter comp)
|
boolean |
And.evaluate(ComponentAdapter adapter)
|
boolean |
IsKeyType.evaluate(ComponentAdapter adapter)
|
boolean |
IsType.evaluate(ComponentAdapter adapter)
|
boolean |
IsExactType.evaluate(ComponentAdapter adapter)
|
boolean |
Or.evaluate(ComponentAdapter adapter)
|
boolean |
Anything.evaluate(ComponentAdapter adapter)
|
boolean |
IsKey.evaluate(ComponentAdapter adapter)
|
protected Map<Object,ComponentAdapter<?>> |
AbstractConstraint.getMatchingComponentAdapters(PicoContainer container,
ComponentAdapter adapter,
Class keyType,
Class valueType)
|
boolean |
AbstractConstraint.isResolvable(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
Object |
AbstractConstraint.resolveInstance(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
void |
AbstractConstraint.verify(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
Uses of ComponentAdapter in org.picocontainer.gems.containers |
---|
Methods in org.picocontainer.gems.containers that return ComponentAdapter | ||
---|---|---|
|
CommonsLoggingTracingContainerDecorator.getComponentAdapter(Class<T> componentType,
Class<? extends Annotation> binding)
Deprecated. |
|
|
Log4jTracingContainerDecorator.getComponentAdapter(Class<T> componentType,
Class<? extends Annotation> binding)
Deprecated. |
|
|
CommonsLoggingTracingContainerDecorator.getComponentAdapter(Class<T> componentType,
NameBinding componentNameBinding)
Deprecated. Find a component adapter associated with the specified type. |
|
|
Log4jTracingContainerDecorator.getComponentAdapter(Class<T> componentType,
NameBinding componentNameBinding)
Deprecated. Find a component adapter associated with the specified type. |
|
ComponentAdapter<?> |
CommonsLoggingTracingContainerDecorator.getComponentAdapter(Object componentKey)
Deprecated. Find a component adapter associated with the specified key. |
|
ComponentAdapter<?> |
Log4jTracingContainerDecorator.getComponentAdapter(Object componentKey)
Deprecated. Find a component adapter associated with the specified key. |
|
ComponentAdapter |
CommonsLoggingTracingContainerDecorator.removeComponent(Object componentKey)
Deprecated. Unregister a component by key. |
|
ComponentAdapter |
Log4jTracingContainerDecorator.removeComponent(Object componentKey)
Deprecated. Unregister a component by key. |
|
|
ReusablePicoContainer.removeComponent(Object componentKey)
|
|
ComponentAdapter |
CommonsLoggingTracingContainerDecorator.removeComponentByInstance(Object componentInstance)
Deprecated. Unregister a component by instance. |
|
ComponentAdapter |
Log4jTracingContainerDecorator.removeComponentByInstance(Object componentInstance)
Deprecated. Unregister a component by instance. |
|
|
ReusablePicoContainer.removeComponentByInstance(T componentInstance)
|
Methods in org.picocontainer.gems.containers that return types with arguments of type ComponentAdapter | ||
---|---|---|
Collection<ComponentAdapter<?>> |
CommonsLoggingTracingContainerDecorator.getComponentAdapters()
Deprecated. Retrieve all the component adapters inside this container. |
|
Collection<ComponentAdapter<?>> |
Log4jTracingContainerDecorator.getComponentAdapters()
Deprecated. Retrieve all the component adapters inside this container. |
|
|
CommonsLoggingTracingContainerDecorator.getComponentAdapters(Class<T> componentType)
Deprecated. Retrieve all component adapters inside this container that are associated with the specified type. |
|
|
Log4jTracingContainerDecorator.getComponentAdapters(Class<T> componentType)
Deprecated. Retrieve all component adapters inside this container that are associated with the specified type. |
|
|
CommonsLoggingTracingContainerDecorator.getComponentAdapters(Class<T> componentType,
Class<? extends Annotation> binding)
Deprecated. |
|
|
Log4jTracingContainerDecorator.getComponentAdapters(Class<T> componentType,
Class<? extends Annotation> binding)
Deprecated. |
Methods in org.picocontainer.gems.containers with parameters of type ComponentAdapter | |
---|---|
MutablePicoContainer |
CommonsLoggingTracingContainerDecorator.addAdapter(ComponentAdapter componentAdapter)
Deprecated. Register a component via a ComponentAdapter. |
MutablePicoContainer |
Log4jTracingContainerDecorator.addAdapter(ComponentAdapter componentAdapter)
Deprecated. Register a component via a ComponentAdapter. |
MutablePicoContainer |
ReusablePicoContainer.addAdapter(ComponentAdapter<?> componentAdapter)
|
MutablePicoContainer |
ReusablePicoContainer.addAdapter(ComponentAdapter<?> componentAdapter,
Properties properties)
|
Uses of ComponentAdapter in org.picocontainer.gems.injectors |
---|
Classes in org.picocontainer.gems.injectors that implement ComponentAdapter | |
---|---|
class |
CommonsLoggingInjector
This will Inject a Commons-Logging Logger for the injectee's class name |
class |
JavaLoggingInjector
This will Inject a Java-Logging Logger for the injectee's class name |
class |
Log4JInjector
This will Inject a Log4J Logger for the injectee's class name |
class |
Slf4JInjector
This will Inject a Slf4J Logger for the injectee's class name |
Uses of ComponentAdapter in org.picocontainer.gems.jmx |
---|
Classes in org.picocontainer.gems.jmx that implement ComponentAdapter | |
---|---|
class |
JMXExposed<T>
ComponentAdapter that is exposing a component as MBean in a MBeanServer. |
Methods in org.picocontainer.gems.jmx that return ComponentAdapter | ||
---|---|---|
|
JMXExposing.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
JMXExposing.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
Retrieve a ComponentAdapter . |
Methods in org.picocontainer.gems.jmx with parameters of type ComponentAdapter | ||
---|---|---|
|
JMXExposing.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
JMXRegistrationInfo |
DynamicMBeanComponentProvider.provide(PicoContainer picoContainer,
ComponentAdapter componentAdapter)
Provide the component itself as DynamicMBean if it is one and if an ObjectName can be created. |
|
JMXRegistrationInfo |
DynamicMBeanProvider.provide(PicoContainer picoContainer,
ComponentAdapter componentAdapter)
Provide a DynamicMBean from the component delivered by the ComponentAdapter. |
|
JMXRegistrationInfo |
AbstractConstructingProvider.provide(PicoContainer picoContainer,
ComponentAdapter componentAdapter)
Create a StandardMBean from the component provided by the ComponentAdapter. |
|
MBeanInfo |
MBeanInfoProvider.provide(PicoContainer picoContainer,
ComponentAdapter componentAdapter)
Provide a MBeanInfo for the given component. |
|
JMXRegistrationInfo |
RegisteredMBeanConstructingProvider.provide(PicoContainer picoContainer,
ComponentAdapter componentAdapter)
Provide a DynamicMBean for the given Pico component. |
|
MBeanInfo |
ComponentTypeConventionMBeanInfoProvider.provide(PicoContainer picoContainer,
ComponentAdapter componentAdapter)
Use the key of the component to search for a MBeanInfo in the PicoContainer. |
|
MBeanInfo |
ComponentKeyConventionMBeanInfoProvider.provide(PicoContainer picoContainer,
ComponentAdapter componentAdapter)
Use the key of the component to search for a MBeanInfo in the PicoContainer. |
|
void |
JMXVisitor.visitComponentAdapter(ComponentAdapter componentAdapter)
Register the component as MBean. |
Constructors in org.picocontainer.gems.jmx with parameters of type ComponentAdapter | |
---|---|
JMXExposed(ComponentAdapter<T> delegate,
MBeanServer mBeanServer)
Construct a JMXExposed behaviour. |
|
JMXExposed(ComponentAdapter<T> delegate,
MBeanServer mBeanServer,
DynamicMBeanProvider[] providers)
Construct a JMXExposed behaviour |
Uses of ComponentAdapter in org.picocontainer.gems.jndi |
---|
Classes in org.picocontainer.gems.jndi that implement ComponentAdapter | |
---|---|
class |
JNDIExposed<T>
exposes component to JNDI basically does same thing as cached, but uses JNDI reference instead. |
class |
JNDIProvided<T>
represents dependency provided via JNDI. |
Methods in org.picocontainer.gems.jndi with type parameters of type ComponentAdapter | ||
---|---|---|
|
JNDIProvided.findAdapterOfType(Class<U> componentAdapterType)
|
Methods in org.picocontainer.gems.jndi that return ComponentAdapter | ||
---|---|---|
|
JNDIExposing.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
|
JNDIProviding.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
JNDIExposing.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
ComponentAdapter<T> |
JNDIProvided.getDelegate()
|
Methods in org.picocontainer.gems.jndi with parameters of type ComponentAdapter | ||
---|---|---|
|
JNDIExposing.addComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
ComponentAdapter<T> adapter)
|
|
void |
JNDIContainerVisitor.visitComponentAdapter(ComponentAdapter componentAdapter)
in case component adapter is JNDIExposed, poke it gently and it will create component and register it to JNDI if not already done. |
Constructors in org.picocontainer.gems.jndi with parameters of type ComponentAdapter | |
---|---|
JNDIExposed(ComponentAdapter<T> delegate)
construct reference itself using vanilla initial context. |
|
JNDIExposed(ComponentAdapter<T> delegate,
JNDIObjectReference<T> instanceReference)
create with provided reference |
|
JNDIExposed(ComponentAdapter<T> delegate,
String name)
create adapter with desired name |
Uses of ComponentAdapter in org.picocontainer.gems.monitors |
---|
Methods in org.picocontainer.gems.monitors with parameters of type ComponentAdapter | ||
---|---|---|
|
DotDependencyGraphComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] injected,
long duration)
|
|
|
CommonsLoggingComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] parameters,
long duration)
Event thrown after the component has been instantiated using the given constructor. |
|
|
ComponentDependencyMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] injected,
long duration)
|
|
|
Log4JComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] parameters,
long duration)
Event thrown after the component has been instantiated using the given constructor. |
|
|
Slf4jComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] parameters,
long duration)
Event thrown after the component has been instantiated using the given constructor. |
|
|
CommonsLoggingComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
Event thrown as the component is being instantiated using the given constructor |
|
|
Log4JComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
Event thrown as the component is being instantiated using the given constructor |
|
|
Slf4jComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
Event thrown as the component is being instantiated using the given constructor |
|
|
CommonsLoggingComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception cause)
Event thrown if the component instantiation failed using the given constructor |
|
|
Log4JComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception cause)
Event thrown if the component instantiation failed using the given constructor |
|
|
Slf4jComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception cause)
Event thrown if the component instantiation failed using the given constructor |
|
void |
CommonsLoggingComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
Event thrown after the component method has been invoked on the given instance |
|
void |
Log4JComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
Event thrown after the component method has been invoked on the given instance |
|
void |
Slf4jComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
Event thrown after the component method has been invoked on the given instance |
|
void |
CommonsLoggingComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
Event thrown as the component method is being invoked on the given instance |
|
void |
Log4JComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
Event thrown as the component method is being invoked on the given instance |
|
void |
Slf4jComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
Event thrown as the component method is being invoked on the given instance |
|
void |
CommonsLoggingComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
Event thrown if a lifecycle method invocation - start, stop or dispose - failed on the given instance |
|
void |
Log4JComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
Event thrown if a lifecycle method invocation - start, stop or dispose - failed on the given instance |
|
void |
Slf4jComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
Event thrown if a lifecycle method invocation - start, stop or dispose - failed on the given instance |
Uses of ComponentAdapter in org.picocontainer.injectors |
---|
Classes in org.picocontainer.injectors that implement ComponentAdapter | |
---|---|
class |
AbstractInjector<T>
This ComponentAdapter will instantiate a new object for each call to org.picocontainer.ComponentAdapter#getComponentInstance(PicoContainer, Class) . |
class |
AnnotatedFieldInjector
Injection happens after instantiation, and through fields marked as injection points via an Annotation. |
class |
AnnotatedMethodInjector
|
class |
CompositeInjector<T>
|
class |
ConstructorInjector<T>
Injection will happen through a constructor for the component. |
class |
FactoryInjector<T>
A Injector which provides an custom instance in a factory style |
class |
IterativeInjector<T>
Injection will happen iteratively after component instantiation |
class |
MethodInjector<T>
Injection will happen through a single method for the component. |
class |
MultiInjector
|
class |
NamedFieldInjector
Injection happens after instantiation, and fields are marked as injection points via a named field. |
class |
SetterInjector<T>
Instantiates components using empty constructors and Setter Injection. |
class |
SingleMemberInjector<T>
Injection will happen in a single member function on the component. |
class |
TypedFieldInjector
Injection happens after instantiation, and fields are marked as injection points via a field type. |
Methods in org.picocontainer.injectors with type parameters of type ComponentAdapter | ||
---|---|---|
|
FactoryInjector.findAdapterOfType(Class<U> componentAdapterType)
|
Methods in org.picocontainer.injectors that return ComponentAdapter | ||
---|---|---|
|
MethodInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
AdaptingInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
CompositeInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
TypedFieldInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
NamedFieldInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
ConstructorInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties properties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
SetterInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
Create a SetterInjector . |
|
|
MultiInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
AnnotatedFieldInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
|
|
|
AnnotatedMethodInjection.createComponentAdapter(ComponentMonitor componentMonitor,
LifecycleStrategy lifecycleStrategy,
Properties componentProperties,
Object componentKey,
Class<T> componentImplementation,
Parameter... parameters)
Create a SetterInjector . |
|
ComponentAdapter<T> |
FactoryInjector.getDelegate()
|
|
ComponentAdapter<?> |
AbstractInjector.UnsatisfiableDependenciesException.getUnsatisfiableComponentAdapter()
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepDEF_isAbleToTakeParameters(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepDEF_isAbleToTakeParameters(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepDEF_verifyDoesNotInstantiate(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepDEF_verifyDoesNotInstantiate(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepDEF_verifyWithoutDependencyWorks(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepDEF_verifyWithoutDependencyWorks(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepDEF_visitable()
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepDEF_visitable()
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepINS_createsNewInstances(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepINS_createsNewInstances(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepINS_errorIsRethrown(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepINS_errorIsRethrown(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepINS_normalExceptionIsRethrownInsidePicoInitializationException(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepINS_normalExceptionIsRethrownInsidePicoInitializationException(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepINS_runtimeExceptionIsRethrown(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepINS_runtimeExceptionIsRethrown(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepRES_dependenciesAreResolved(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepRES_dependenciesAreResolved(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepRES_failingInstantiationWithCyclicDependencyException(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepRES_failingInstantiationWithCyclicDependencyException(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepRES_failingVerificationWithCyclicDependencyException(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepRES_failingVerificationWithCyclicDependencyException(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepSER_isSerializable(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepSER_isSerializable(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepSER_isXStreamSerializable(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepSER_isXStreamSerializable(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
ConstructorInjectorTestCase.prepVER_verificationFails(MutablePicoContainer picoContainer)
|
|
protected ComponentAdapter |
SetterInjectorTestCase.prepVER_verificationFails(MutablePicoContainer picoContainer)
|
Constructors in org.picocontainer.injectors with parameters of type ComponentAdapter | |
---|---|
AbstractInjector.UnsatisfiableDependenciesException(ComponentAdapter<?> instantiatingComponentAdapter,
Class<?> unsatisfiedDependencyType,
Set unsatisfiableDependencies,
PicoContainer leafContainer)
|
Uses of ComponentAdapter in org.picocontainer.monitors |
---|
Methods in org.picocontainer.monitors with parameters of type ComponentAdapter | ||
---|---|---|
|
ConsoleComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] parameters,
long duration)
|
|
|
WriterComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] injected,
long duration)
|
|
|
LifecycleComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] parameters,
long duration)
|
|
|
AbstractComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] injected,
long duration)
|
|
|
NullComponentMonitor.instantiated(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Object instantiated,
Object[] injected,
long duration)
|
|
|
ConsoleComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
|
|
|
WriterComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
|
|
|
LifecycleComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
|
|
|
AbstractComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
|
|
|
NullComponentMonitor.instantiating(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor)
|
|
|
ConsoleComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception cause)
|
|
|
WriterComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception cause)
|
|
|
LifecycleComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception cause)
|
|
|
AbstractComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception e)
|
|
|
NullComponentMonitor.instantiationFailed(PicoContainer container,
ComponentAdapter<T> componentAdapter,
Constructor<T> constructor,
Exception e)
|
|
void |
ConsoleComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
|
|
void |
WriterComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
|
|
void |
LifecycleComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
|
|
void |
AbstractComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
|
|
void |
NullComponentMonitor.invoked(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
long duration)
|
|
void |
ConsoleComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
|
|
void |
WriterComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
|
|
void |
LifecycleComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
|
|
void |
AbstractComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
|
|
void |
NullComponentMonitor.invoking(PicoContainer container,
ComponentAdapter<?> componentAdapter,
Member member,
Object instance)
|
|
void |
ConsoleComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
|
|
void |
WriterComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
|
|
void |
LifecycleComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
|
|
void |
AbstractComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
|
|
void |
NullComponentMonitor.lifecycleInvocationFailed(MutablePicoContainer container,
ComponentAdapter<?> componentAdapter,
Method method,
Object instance,
RuntimeException cause)
|
Uses of ComponentAdapter in org.picocontainer.parameters |
---|
Methods in org.picocontainer.parameters that return types with arguments of type ComponentAdapter | |
---|---|
protected Map<Object,ComponentAdapter<?>> |
CollectionComponentParameter.getMatchingComponentAdapters(PicoContainer container,
ComponentAdapter adapter,
Class keyType,
Class valueType)
Collect the matching ComponentAdapter instances. |
Methods in org.picocontainer.parameters with parameters of type ComponentAdapter | ||
---|---|---|
protected boolean |
CollectionComponentParameter.evaluate(ComponentAdapter adapter)
Evaluate whether the given component adapter will be part of the collective type. |
|
protected Map<Object,ComponentAdapter<?>> |
CollectionComponentParameter.getMatchingComponentAdapters(PicoContainer container,
ComponentAdapter adapter,
Class keyType,
Class valueType)
Collect the matching ComponentAdapter instances. |
|
boolean |
ConstantParameter.isResolvable(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
|
boolean |
BasicComponentParameter.isResolvable(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
Check whether the given Parameter can be satisfied by the container. |
|
boolean |
CollectionComponentParameter.isResolvable(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
Check for a successful dependency resolution of the parameter for the expected type. |
|
boolean |
ComponentParameter.isResolvable(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
|
|
BasicComponentParameter.resolveInstance(PicoContainer container,
ComponentAdapter adapter,
Class<T> expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
|
|
ComponentParameter.resolveInstance(PicoContainer container,
ComponentAdapter adapter,
Class<T> expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
|
Object |
ConstantParameter.resolveInstance(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
|
Object |
CollectionComponentParameter.resolveInstance(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
Resolve the parameter for the expected type. |
|
void |
ConstantParameter.verify(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
Verify that the Parameter can satisfy the expected type using the container |
|
void |
BasicComponentParameter.verify(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
|
void |
CollectionComponentParameter.verify(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
Verify a successful dependency resolution of the parameter for the expected type. |
|
void |
ComponentParameter.verify(PicoContainer container,
ComponentAdapter adapter,
Class expectedType,
NameBinding expectedNameBinding,
boolean useNames,
Annotation binding)
|
Uses of ComponentAdapter in org.picocontainer.tck |
---|
Classes in org.picocontainer.tck that implement ComponentAdapter | |
---|---|
static class |
AbstractComponentAdapterTest.CollectingBehavior
|
static class |
AbstractComponentAdapterTest.CycleDetectorBehavior
|
static class |
AbstractComponentAdapterTest.NotInstantiatableBehavior
|
static class |
AbstractPicoContainerTest.TestBehavior
|
Methods in org.picocontainer.tck that return ComponentAdapter | |
---|---|
protected ComponentAdapter |
AbstractComponentAdapterTest.prepDEF_isAbleToTakeParameters(MutablePicoContainer picoContainer)
Prepare the test isAbleToTakeParameters. |
protected abstract ComponentAdapter |
AbstractComponentAdapterTest.prepDEF_verifyDoesNotInstantiate(MutablePicoContainer picoContainer)
Prepare the test verifyDoesNotInstantiate. |
protected abstract ComponentAdapter |
AbstractComponentAdapterTest.prepDEF_verifyWithoutDependencyWorks(MutablePicoContainer picoContainer)
Prepare the test verifyWithoutDependencyWorks. |
protected abstract ComponentAdapter |
AbstractComponentAdapterTest.prepDEF_visitable()
Prepare the test visitable. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepINS_createsNewInstances(MutablePicoContainer picoContainer)
Prepare the test createsNewInstances. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepINS_errorIsRethrown(MutablePicoContainer picoContainer)
Prepare the test errorIsRethrown. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepINS_normalExceptionIsRethrownInsidePicoInitializationException(MutablePicoContainer picoContainer)
Prepare the test normalExceptionIsRethrownInsidePicoInvocationTargetInitializationException. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepINS_runtimeExceptionIsRethrown(MutablePicoContainer picoContainer)
Prepare the test runtimeExceptionIsRethrown. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepRES_dependenciesAreResolved(MutablePicoContainer picoContainer)
Prepare the test dependenciesAreResolved. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepRES_failingInstantiationWithCyclicDependencyException(MutablePicoContainer picoContainer)
Prepare the test failingInstantiationWithCyclicDependencyException. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepRES_failingVerificationWithCyclicDependencyException(MutablePicoContainer picoContainer)
Prepare the test failingVerificationWithCyclicDependencyException. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepSER_isSerializable(MutablePicoContainer picoContainer)
Prepare the test isSerializable. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepSER_isXStreamSerializable(MutablePicoContainer picoContainer)
Prepare the test isXStreamSerializable. |
protected ComponentAdapter |
AbstractComponentAdapterTest.prepVER_verificationFails(MutablePicoContainer picoContainer)
Prepare the test verificationFailsWithUnsatisfiedDependency. |
Methods in org.picocontainer.tck with parameters of type ComponentAdapter | |
---|---|
void |
AbstractPicoContainerTest.RecordingStrategyVisitor.visitComponentAdapter(ComponentAdapter componentAdapter)
|
Constructors in org.picocontainer.tck with parameters of type ComponentAdapter | |
---|---|
AbstractComponentAdapterTest.CollectingBehavior(ComponentAdapter delegate,
List list)
|
|
AbstractComponentAdapterTest.CycleDetectorBehavior(ComponentAdapter delegate,
Set set,
ObjectReference reference)
|
|
AbstractComponentAdapterTest.NotInstantiatableBehavior(ComponentAdapter delegate)
|
|
AbstractPicoContainerTest.TestBehavior(ComponentAdapter delegate)
|
Uses of ComponentAdapter in org.picocontainer.visitors |
---|
Methods in org.picocontainer.visitors with parameters of type ComponentAdapter | |
---|---|
void |
TraversalCheckingVisitor.visitComponentAdapter(ComponentAdapter<?> componentAdapter)
Visit a ComponentAdapter that has to accept the visitor. |
void |
VerifyingVisitor.visitComponentAdapter(ComponentAdapter<?> componentAdapter)
|
|
![]() |
|||||||||
PREV NEXT | FRAMES NO FRAMES |