All Classes and Interfaces
Class
Description
Base class for a ComponentAdapter with general functionality.
Component adapter which decorates another adapter.
A
monitor which delegates to another monitor.abstract base class for delegating to mutable containers
Abstract base class for immutable delegation to a PicoContainer
This ComponentAdapter will instantiate a new object for each call to
ComponentAdapter.getComponentInstance(PicoContainer, Type).Exception that is thrown as part of the introspection.
Exception thrown when some of the component's dependencies are not satisfiable.
Abstract base class for lifecycle strategy implementation supporting a
ComponentMonitor.Abstract PicoVisitor implementation.
Exception for a PicoVisitor, that is dependent on a defined starting point of the traversal.
Creates injector instances, depending on the injection characteristics of the component class.
A
InjectionFactory for Guice-style annotated fields.Injection happens after instantiation, and through fields marked as injection points via an Annotation.
A
InjectionFactory for Guice-style annotated methods.A BasicComponentParameter should be used to pass in a particular component as argument to a
different component's constructor.
Behaviors modify the components created by a Injector with additional behaviors
static collection of factory methods for easier behavior creation
Extends ComponentFactory to provide factory methods for Behaviors
Static collection of factory methods for different BehaviourFactory implementations.
Provides some built-in converters used by
DefaultPicoContainer.ComponentAdapter implementation that caches the component instance.factory class creating cached behaviours
Collection of immutable properties, holding behaviour characteristics.
Read only property set.
A ClassLoadingPicoContainer extends PicoContainer with classloader juggling capability
ClassName is a simple wrapper for a class name which is used as a key in
the registration of components in PicoContainer.
ClassPathElement denotes an element in a classpath allowing to grant permissions.
A CollectionComponentParameter should be used to support inject an
Array, a
Collectionor Mapof components automatically.Deprecated.
CommandLineArgumentsPicoContainer configured itself from array of strings
which are most likely coming in as command line arguments
A component adapter is responsible for providing a specific component
instance of type <T>.
A component factory is responsible for creating
ComponentAdapter component adapters.A component monitor is responsible for monitoring the component instantiation
and method invocation.
An abstract
ComponentMonitor which supports all the message formats.
Interface responsible for changing monitoring strategy.
A ComponentParameter should be used to pass in a particular component as argument to a
different component's constructor.
The first of a list of composers passed in that responds with an instance for a missing component will
be used.
A Composer can be used to make components that are otherwise missing.
A Composite of other types on InjectionFactories - pass them into the varargs constructor.
Allow for use of alternate LifecycleStrategy strategies to be used
at the same time.
CompositePicoContainer takes a var-args list of containers and will query them
in turn for getComponent(*) and getComponentAdapter(*) requests.
A
ComponentMonitor which writes to a OutputStream.A ConstantParameter should be used to pass in "constant" arguments to constructors.
A
InjectionFactory for constructor injection.Injection will happen through a constructor for the component.
Interface for type converters.
A facade for a collection of converters that provides string-to-type conversions.
Interface for containers that can handle string-to-object conversion in object parameters.
Null-object implementation of Converters
CustomPermissionsURLClassLoader extends URLClassLoader, adding the abilty to programatically add permissions easily.
BehaviorFactory for Decorating.
Default implementation of ClassLoadingPicoContainer.
Part of the replacement construct for Parameter.ZERO
Bean-like implementation of LifecycleState.
The Standard
PicoContainer/MutablePicoContainer implementation.An interface which is implemented by components that need to dispose of resources during the shutdown of that
component.
Empty pico container serving as recoil damper in situations where you
do not like to check whether container reference supplied to you
is null or not
An Injector which provides an custom instance in a factory style
BehaviorFactory for Field Decorating.
Constructor Injection where 'which constructor?' is re-calculated each time an
instance is asked to construct a component.
behaviour for allows components to be guarded by another component
factory class creating guard behaviour
This component adapter makes it possible to hide the implementation
of a real subject (behind a proxy) provided the key is an interface.
wrap pico container to achieve immutability
Typically its used to mock a parent container.
Implementers are responsible for instantiating and injecting dependancies into
Constructors, Methods and Fields.
convenience class providing static methods to conveniently create injectors
( like org.junit.Assert )
Component adapter which wraps a component instance.
Injection will happen iteratively after component instantiation
Java EE 5 has some annotations PreDestroy and PostConstruct that map to start() and dispose() in our world
A
ComponentMonitor which collects lifecycle failures
and rethrows them on demand after the failures.Current lifecycle state of the container.
An interface which specifies the lifecycle strategy on the component instance.
This behavior factory provides java.util.concurrent locks.
A PicoVisitor implementation, that calls methods on the components of a specific type.
A
InjectionFactory for methods.Injection will happen through a single method for the component.
This is the core interface used for registration of components with a container.
A
InjectionFactory for named fields.Injection happens after instantiation, and fields are marked as
injection points via a named field.
Converts a value to an object via its single-String constructor.
A
ComponentMonitor which does nothing.Lifecycle strategy that does nothing.
Once in a great while, you actually want to pass in 'null' as an argument.
A way to refer to objects that are stored in "awkward" places (for example inside a
HttpSession or ThreadLocal).Behavior that turns off Caching behavior by default.
This class provides control over the arguments that will be passed to a constructor.
Delegate to another reolver
The Parameter cannot (ever) be resolved
Resolver is used transitarily during resolving of Parameters.
A fixed value wrapped as a Resolver
Helps assembles the myriad items available to a picocontainer.
Subclass of
PicoException that is thrown when there is:
- a problem initializing the container
- a cyclic dependency between components occurs.This is the core interface for PicoContainer.
Superclass for all Exceptions in PicoContainer.
Subclass of
PicoException that is thrown when a PicoContainer hierarchy
cannot be verified.Interface realizing a visitor pattern for
PicoContainer as described in the GoF.immutable pico container constructed from properties.
Decorating component adapter that can be used to set additional properties
on a component in a bean style.
A
ComponentFactory that creates
PropertyApplicator instances.Providers are a type of Injector that can participate in Injection via a custom method.
Providers are a type of Injector that can participate in Injection via a custom method.
Subclass of
PicoException that is thrown when there is a problem
invoking lifecycle methods via reflection.Reflection lifecycle strategy.
Subsets components in a container, the keys for which match a regular expression.
A Reinjector allows methods on pre-instantiated classes to be invoked,
with appropriately scoped parameters.
A
InjectionFactory for JavaBeans.Instantiates components using empty constructors and
Setter Injection.
Simple instance implementation of ObjectReference.
Injection will happen in a single member function on the component.
An interface which is implemented by components that can be started and stopped.
Startable lifecycle strategy.
Component Adapter that uses java synchronized around getComponentInstance().
This behavior factory provides synchronized wrappers to control access to a particular component.
A container backed by system properties (is a PropertiesPicoContainer)
This behavior supports caches values per thread.
Gets and sets references on a map stored in Thread Local
Gets and sets references on Thread Local
Concrete implementation of Visitor which simply checks traversals.
A
InjectionFactory for named fields.Injection happens after instantiation, and fields are marked as
injection points via a field type.
Converts values to URL data type objects
Visitor to verify
PicoContainer instances.A
ComponentMonitor which writes to a Writer.
CommandLinePicoContainerinstead.