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.