Package jfun.yan

Basic component combinators and containers.

See:
Description

Interface Summary

Binder<From,To>	Represents the "bind" function in monad.
ComponentBinder<From,To>	In addition to mapping the previous result to a new Creator, ComponentBinder also verifies the type of the previous result.
ComponentMap	A map that is used to retrieve Component by key or type.
Container	The facade interface which provides the full functionality of yan container.
Creator<T>	A creator is responsible for creating component instances.
Dependency	This interface is responsible for providing dependency to the creation of a component instance.
LazyComponent<T>	A lazily evaluated Component.
Map<From,To>	Map one object to another.
Map2<A,B,R>	Maps two objects to another object.
Map3<A,B,C,R>	Maps three objects to another object.
Map4<A,B,C,D,R>	Maps four objects to another object.
Map5<A,B,C,D,E,R>	Maps five objects to another object.
Mutation<T>	To represent any mutation to an object or any side effect.
ParameterBinder<T>	Dynamically maps a parameter to a Creator that creates the corresponding argument value.
Part	A Part object encapsulates creation and verification logic for any property or parameter of a component.
PropertiesInjector	Represents the logic that pulls property values from a Dependency object and inject them into the appropriate properties.
PropertyBinder	Dynamically map a property to a Creator object that creates the property value.
Recovery<T>	This interface represents an error recovery strategy.
Registrar	Registrar is a mutable ComponentMap.
Stateful	Represents anything that has a state.
Typeful	Represents anything that has a type.
Verifiable	Represents any thing that can be verified.

Class Summary

Component<T>	Responsible for component instance creation and verification.
ComponentInfo	This class contains meta information about any component.
Components	This class provides implementations of some basic components as well as most of the commonly used combiniators for Component.
Creator2Component<T>	To adapt a Creator object to Component.
DecoratingComponent	Base class for component decorators that do not change the result returned from the target component it decorates and causes no side-effect by itself other than those caused by the target component.
DefaultPropertiesInjector	The default PropertiesInjector implementation that uses java.beans introspection mechanism and injects properties by property names.
DelegatingComponent	Base class for delegating Component object.
DelegatingComponentMap	The base class for delegating to a ComponentMap object.
FilteredPropertiesInjector	This implementation only attempts to inject a property when this property satisfies a MemberPredicate object.
Functions	This is the facade class to create different Function objects.
Introspector	Helper class to get meta information about a component.
ManualDependency	ManualDependency disables auto-wiring by refusing to resolve any component part.
Monad	The facade class to provide monadic combinators for Component.
ParameterEntry	This class represents a parameter in a Function object.
PropertyEntry	This class represents a property of an object.
Proxies	This class provides all dynamic proxy related utility functions.
SimpleComponent<T>	This abstract class provides a convenient way to create Component implementations that do not have dependencies to resolve.
SimpleDependency	A simple implementation of the Dependency interface.
StoreBinder<T,L>	This implementation executes an array of components sequentially and collect the results into an ElementStore object created by the StoreBinder.toStore(Object) method.

Exception Summary

AmbiguousComponentResolutionException	Exception when ambiguity happens for component resolution.
ComponentInstantiationException	The wrapper exception class for any checked exception happened during component instance creation.
ComponentResolutionException	Represents an error when a component or a part of a component cannot be resolved.
CyclicDependencyException	Represents the error when a cyclic dependency is detected.
DefaultingException	Represents an exception when a default value is used.
IllegalPropertyNameException	Represents the error when a property name is illegal.
InternalException	Represents any exception that's used internally by the framework and should not be wrapped.
InvalidPropertyException	Represents any exception about a component property.
IrresolveableArgumentException	Represents an exception when a parameter of a component cannot be resolved.
IrresolveablePropertyException	Represents an exception when a property of a component cannot be resolved.
NonReadablePropertyException	Represents an exception when a bean component tries to read a property that is not readable.
NonWritablePropertyException	Represents an exception when a bean component tries to set a property that is not writable.
NullBeanObjectException	Thrown when a java bean object is null.
ParameterTypeMismatchException	Represents an exception when the type of the actual argument does not match the expected parameter type.
PropertyTypeMismatchException	Represents an exception where the type of the actual property value does not match the expected property type.
ReturnTypeMismatchException	Represents an error when a component's type does not match the return type of the factory method that it implements.
TypeMismatchException	Represents any type mismatch exception.
UnknownComponentTypeException	Represents an error when a dynamic component whose type is unknown is used in a place where a component type is required.
UnresolvedComponentException	Represents exception when a component cannot be resolved.
UnsatisfiedComponentException	Represents an exception when a component's dependency cannot be satisfied.
YanException	The root exception representing any container or component related exception.

Package jfun.yan Description

Basic component combinators and containers.

Package Specification

The code is developed and tested under Java 1.4.

Related Documentation

For overviews, tutorials, examples, guides, and tool documentation, please see README.txt: