All Classes

Class	Description
AbstractAdapter<T>	Base class for a ComponentAdapter with general functionality.
AbstractBehavior<T>	Component adapter which decorates another adapter.
AbstractBehaviorFactory
AbstractComponentMonitor	A monitor which delegates to another monitor.
AbstractDelegatingMutablePicoContainer	abstract base class for delegating to mutable containers
AbstractDelegatingPicoContainer	Abstract base class for immutable delegation to a PicoContainer
AbstractFieldInjector<T>
AbstractInjectionFactory
AbstractInjector<T>	This ComponentAdapter will instantiate a new object for each call to ComponentAdapter.getComponentInstance(PicoContainer, Type).
AbstractInjector.AmbiguousComponentResolutionException	Exception that is thrown as part of the introspection.
AbstractInjector.CyclicDependencyException
AbstractInjector.NotConcreteRegistrationException
AbstractInjector.UnsatisfiableDependenciesException	Exception thrown when some of the component's dependencies are not satisfiable.
AbstractMonitoringLifecycleStrategy	Abstract base class for lifecycle strategy implementation supporting a ComponentMonitor.
AbstractParameter
AbstractPicoVisitor	Abstract PicoVisitor implementation.
AbstractPicoVisitor.PicoVisitorTraversalException	Exception for a PicoVisitor, that is dependent on a defined starting point of the traversal.
AdaptingBehavior
AdaptingInjection	Creates injector instances, depending on the injection characteristics of the component class.
AnnotatedFieldInjection	A InjectionFactory for Guice-style annotated fields.
AnnotatedFieldInjector<T>	Injection happens after instantiation, and through fields marked as injection points via an Annotation.
AnnotatedMethodInjection	A InjectionFactory for Guice-style annotated methods.
AnnotatedMethodInjector
Automated<T>
Automating
BasicComponentParameter	A BasicComponentParameter should be used to pass in a particular component as argument to a different component's constructor.
Behavior<T>	Behaviors modify the components created by a Injector with additional behaviors
Behavior	static collection of factory methods for easier behavior creation
BehaviorFactory	Extends ComponentFactory to provide factory methods for Behaviors
Behaviors	Static collection of factory methods for different BehaviourFactory implementations.
Bind
BindKey<T>
BuiltInConverters	Provides some built-in converters used by DefaultPicoContainer.
Cache
Cached<T>	ComponentAdapter implementation that caches the component instance.
Caching	factory class creating cached behaviours
Characteristics	Collection of immutable properties, holding behaviour characteristics.
Characteristics.ImmutableProperties	Read only property set.
ClassLoadingPicoContainer	A ClassLoadingPicoContainer extends PicoContainer with classloader juggling capability
ClassName	ClassName is a simple wrapper for a class name which is used as a key in the registration of components in PicoContainer.
ClassPathElement	ClassPathElement denotes an element in a classpath allowing to grant permissions.
CollectionComponentParameter	A CollectionComponentParameter should be used to support inject an Array, a Collectionor Mapof components automatically.
CommandLineArgumentsPicoContainer	Deprecated. Use CommandLinePicoContainer instead.
CommandLinePicoContainer	CommandLineArgumentsPicoContainer configured itself from array of strings which are most likely coming in as command line arguments
ComponentAdapter<T>	A component adapter is responsible for providing a specific component instance of type <T>.
ComponentAdapter.NOTHING
ComponentFactory	A component factory is responsible for creating ComponentAdapter component adapters.
ComponentLifecycle<T>
ComponentMonitor	A component monitor is responsible for monitoring the component instantiation and method invocation.
ComponentMonitorHelper	An abstract ComponentMonitor which supports all the message formats.
ComponentMonitorStrategy	Interface responsible for changing monitoring strategy.
ComponentParameter	A ComponentParameter should be used to pass in a particular component as argument to a different component's constructor.
ComposingMonitor	The first of a list of composers passed in that responds with an instance for a missing component will be used.
ComposingMonitor.Composer	A Composer can be used to make components that are otherwise missing.
CompositeInjection	A Composite of other types on InjectionFactories - pass them into the varargs constructor.
CompositeInjector<T>
CompositeLifecycleStrategy	Allow for use of alternate LifecycleStrategy strategies to be used at the same time.
CompositePicoContainer	CompositePicoContainer takes a var-args list of containers and will query them in turn for getComponent(*) and getComponentAdapter(*) requests.
ConsoleComponentMonitor	A ComponentMonitor which writes to a OutputStream.
ConstantParameter	A ConstantParameter should be used to pass in "constant" arguments to constructors.
ConstructorInjection	A InjectionFactory for constructor injection.
ConstructorInjector<T>	Injection will happen through a constructor for the component.
Converter<T>	Interface for type converters.
Converters	A facade for a collection of converters that provides string-to-type conversions.
Converting	Interface for containers that can handle string-to-object conversion in object parameters.
ConvertsNothing	Null-object implementation of Converters
CustomPermissionsURLClassLoader	CustomPermissionsURLClassLoader extends URLClassLoader, adding the abilty to programatically add permissions easily.
Decorated<T>
Decorating	BehaviorFactory for Decorating.
DefaultClassLoadingPicoContainer	Default implementation of ClassLoadingPicoContainer.
DefaultClassLoadingPicoContainer.ClassVisitor
DefaultConstructorParameter	Part of the replacement construct for Parameter.ZERO
DefaultLifecycleState	Bean-like implementation of LifecycleState.
DefaultPicoContainer	The Standard PicoContainer/MutablePicoContainer implementation.
DefaultPicoContainer.KnowsContainerAdapter<T>
DefaultPicoContainer.LateInstance
Disposable	An interface which is implemented by components that need to dispose of resources during the shutdown of that component.
Emjection
EmptyPicoContainer	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
FactoryInjector<T>	An Injector which provides an custom instance in a factory style
FactoryInjector.CantWorkItOut
FieldDecorated
FieldDecorated.Decorator
FieldDecorating	BehaviorFactory for Field Decorating.
ForgetfulConstructorInjection	Constructor Injection where 'which constructor?' is re-calculated each time an instance is asked to construct a component.
Guarded<T>	behaviour for allows components to be guarded by another component
Guarding	factory class creating guard behaviour
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.
ImmutablePicoContainer	wrap pico container to achieve immutability Typically its used to mock a parent container.
ImplementationHiding
Inject
InjectInto
InjectionFactory
Injector<T>	Implementers are responsible for instantiating and injecting dependancies into Constructors, Methods and Fields.
Injector	convenience class providing static methods to conveniently create injectors ( like org.junit.Assert )
Injectors
InstanceAdapter<T>	Component adapter which wraps a component instance.
Intercepted<T>
Intercepted.Controller
Intercepted.ControllerImpl
Intercepted.InterceptorThreadLocal
Intercepting
IterativeInjector<T>	Injection will happen iteratively after component instantiation
JavaEE5LifecycleStrategy	Java EE 5 has some annotations PreDestroy and PostConstruct that map to start() and dispose() in our world
LifecycleComponentMonitor	A ComponentMonitor which collects lifecycle failures and rethrows them on demand after the failures.
LifecycleState	Current lifecycle state of the container.
LifecycleStrategy	An interface which specifies the lifecycle strategy on the component instance.
Locked<T>
Locking	This behavior factory provides java.util.concurrent locks.
MethodCallingVisitor	A PicoVisitor implementation, that calls methods on the components of a specific type.
MethodInjection	A InjectionFactory for methods.
MethodInjector<T>	Injection will happen through a single method for the component.
MethodInjector.ByMethodName
MethodInjector.ByReflectionMethod
MultiInjection
MultiInjector
MutablePicoContainer	This is the core interface used for registration of components with a container.
NameBinding
NamedFieldInjection	A InjectionFactory for named fields.
NamedFieldInjector<T>	Injection happens after instantiation, and fields are marked as injection points via a named field.
NamedMethodInjection
NamedMethodInjector<T>
NewInstanceConverter	Converts a value to an object via its single-String constructor.
Nullable
NullComponentMonitor	A ComponentMonitor which does nothing.
NullLifecycleStrategy	Lifecycle strategy that does nothing.
NullParameter	Once in a great while, you actually want to pass in 'null' as an argument.
ObjectReference<T>	A way to refer to objects that are stored in "awkward" places (for example inside a HttpSession or ThreadLocal).
OptInCaching	Behavior that turns off Caching behavior by default.
Parameter	This class provides control over the arguments that will be passed to a constructor.
Parameter.DelegateResolver	Delegate to another reolver
Parameter.NotResolved	The Parameter cannot (ever) be resolved
Parameter.Resolver	Resolver is used transitarily during resolving of Parameters.
Parameter.ValueResolver	A fixed value wrapped as a Resolver
ParameterNameBinding
PicoBuilder	Helps assembles the myriad items available to a picocontainer.
PicoClassNotFoundException
PicoCompositionException	Subclass of PicoException that is thrown when there is: - a problem initializing the container - a cyclic dependency between components occurs.
PicoContainer	This is the core interface for PicoContainer.
PicoException	Superclass for all Exceptions in PicoContainer.
PicoLifecycleException
PicoVerificationException	Subclass of PicoException that is thrown when a PicoContainer hierarchy cannot be verified.
PicoVisitor	Interface realizing a visitor pattern for PicoContainer as described in the GoF.
PrimitiveMemberChecker
PropertiesPicoContainer	immutable pico container constructed from properties.
PropertyApplicator<T>	Decorating component adapter that can be used to set additional properties on a component in a bean style.
PropertyApplying	A ComponentFactory that creates PropertyApplicator instances.
Provider	Providers are a type of Injector that can participate in Injection via a custom method.
ProviderAdapter	Providers are a type of Injector that can participate in Injection via a custom method.
ReflectionLifecycleException	Subclass of PicoException that is thrown when there is a problem invoking lifecycle methods via reflection.
ReflectionLifecycleStrategy	Reflection lifecycle strategy.
RegexComposer	Subsets components in a container, the keys for which match a regular expression.
Reinjection
Reinjector	A Reinjector allows methods on pre-instantiated classes to be invoked, with appropriately scoped parameters.
SetterInjection	A InjectionFactory for JavaBeans.
SetterInjector<T>	Instantiates components using empty constructors and Setter Injection.
SimpleReference<T>	Simple instance implementation of ObjectReference.
SingleMemberInjector<T>	Injection will happen in a single member function on the component.
SingleMemberInjector.ParameterCannotBeNullException
Startable	An interface which is implemented by components that can be started and stopped.
StartableLifecycleStrategy	Startable lifecycle strategy.
Stored<T>
Stored.Instance<T>
Storing
Storing.StoreThreadLocal
Storing.StoreWrapper
Synchronized<T>	Component Adapter that uses java synchronized around getComponentInstance().
Synchronizing	This behavior factory provides synchronized wrappers to control access to a particular component.
SystemPropertiesPicoContainer	A container backed by system properties (is a PropertiesPicoContainer)
ThreadCached<T>	This behavior supports caches values per thread.
ThreadCaching
ThreadLocalMapObjectReference<T>	Gets and sets references on a map stored in Thread Local
ThreadLocalReference<T>	Gets and sets references on Thread Local
TieringPicoContainer
TransientPicoContainer
TraversalCheckingVisitor	Concrete implementation of Visitor which simply checks traversals.
TypedFieldInjection	A InjectionFactory for named fields.
TypedFieldInjector<T>	Injection happens after instantiation, and fields are marked as injection points via a field type.
UrlConverter	Converts values to URL data type objects
VerifyingVisitor	Visitor to verify PicoContainer instances.
WriterComponentMonitor	A ComponentMonitor which writes to a Writer.