# All Classes and Interfaces

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
invalid reference

    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 `Collection`or `Map`of 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`.