Index (org.refcodes:refcodes-factory 1.1.1 API)

A B C F G L M N O R T U

A

AbstractRecyclableTypeFactory<T> - Class in org.refcodes.factory.impls: The AbstractRecyclableTypeFactory is an abstract implementation of the RecyclableTypeFactory taking care on recycling and reusing instances.
AbstractRecyclableTypeFactory() - Constructor for class org.refcodes.factory.impls.AbstractRecyclableTypeFactory: Default constructor creating a AbstractRecyclableTypeFactory.
AbstractRecyclableTypeFactory(int) - Constructor for class org.refcodes.factory.impls.AbstractRecyclableTypeFactory: Constructor creating a AbstractRecyclableTypeFactory which allows only a given maximum of recycled instances to be contained in this factory.

B

BeanFactory<ID> - Interface in org.refcodes.factory: A lookup factory supporting type and ID lookup.
BeanLookupFactory<ID> - Interface in org.refcodes.factory: The BeanLookupFactory defines the functionality which must be provided in order to represent a factory for object creation of objects identified by an ID String and of the expected type (in contrast to the TypeFactory and the LookupFactory which create instances of a predefined type specified with a generic argument).

C

clear() - Method in class org.refcodes.factory.impls.AbstractRecyclableTypeFactory
CollectionFactory<C extends Collection<?>> - Interface in org.refcodes.factory: The CollectionFactory defines the functionality which must be provided in order to represent a factory for object creation of *ALL* objects being of a requested type (in contrast to the TypeFactory and the LookupFactory which create instances of a predefined type specified with a generic argument).
ContextConverterFactory<T,CTX> - Interface in org.refcodes.factory: The ContextConverterFactory defines the functionality which must be provided in order to represent a factory for object creation depending on some provided context and of a predefined type specified with a generic argument (in contrast to the BeanLookupFactory , which creates instances of an expected type).
ContextLookupFactory<T,ID,CTX> - Interface in org.refcodes.factory: The ContextLookupFactory defines the functionality which must be provided in order to represent a factory for object creation of objects identified by an ID String and of a predefined type specified with a generic argument (in contrast to the BeanLookupFactory, which creates instances of an expected type).

F

FactoryRuntimeException - Exception in org.refcodes.factory
FactoryRuntimeException(String, String) - Constructor for exception org.refcodes.factory.FactoryRuntimeException
FactoryRuntimeException(String, Throwable, String) - Constructor for exception org.refcodes.factory.FactoryRuntimeException
FactoryRuntimeException(String, Throwable) - Constructor for exception org.refcodes.factory.FactoryRuntimeException
FactoryRuntimeException(String) - Constructor for exception org.refcodes.factory.FactoryRuntimeException
FactoryRuntimeException(Throwable, String) - Constructor for exception org.refcodes.factory.FactoryRuntimeException
FactoryRuntimeException(Throwable) - Constructor for exception org.refcodes.factory.FactoryRuntimeException

G

getInstanceCount() - Method in class org.refcodes.factory.impls.AbstractRecyclableTypeFactory: Returns the number of recycled instances currently being managed by the AbstractRecyclableTypeFactory.

L

LookupFactory<T,ID> - Interface in org.refcodes.factory: The LookupFactory defines the functionality which must be provided in order to represent a factory for object creation of objects identified by an ID String and of a predefined type specified with a generic argument (in contrast to the BeanLookupFactory, which creates instances of an expected type).

M

MarshalFactory<T> - Interface in org.refcodes.factory: The MarshalFactory defines the functionality which must be provided in order to represent a factory for object creation depending on some provided context and of a predefined type specified with a generic argument (in contrast to the BeanLookupFactory , which creates instances of an expected type).

N

newInstance() - Method in class org.refcodes.factory.impls.AbstractRecyclableTypeFactory: To be implemented by you, called by toInstance() in case there are no more recycled objects available (provided via recycleInstance(Object)). ------------------------------------------------------------------------- This method creates / retrieves an instance of the given type with the given identifier (name) constructed as defined in one to many configuration files.
newInstance(Properties) - Method in class org.refcodes.factory.impls.AbstractRecyclableTypeFactory: To be implemented by you, called by toInstance(Properties) in case there are no more recycled objects available (provided via recycleInstance(Object)). ------------------------------------------------------------------------- This method creates / retrieves an instance of the given type with the given identifier (name) constructed as defined in one to many configuration files.

O

org.refcodes.factory - package org.refcodes.factory
org.refcodes.factory.impls - package org.refcodes.factory.impls

R

RecyclableTypeFactory<T> - Interface in org.refcodes.factory: The RecyclableTypeFactory is a TypeFactory providing recycling support for instances as being created by the RecyclableTypeFactoryTypeFactory.toInstance() (or TypeFactory.toInstance(Properties).
recycleInstance(T) - Method in class org.refcodes.factory.impls.AbstractRecyclableTypeFactory
recycleInstance(T) - Method in interface org.refcodes.factory.TypeRecyclable: Makes the provided instance available for reuse by the factory.

T

toInstance(ID) - Method in interface org.refcodes.factory.BeanFactory
toInstance(ID) - Method in interface org.refcodes.factory.BeanLookupFactory: This method creates / retrieves an instance of the given type identified with the given identifier (name).
toInstance(ID, Properties) - Method in interface org.refcodes.factory.BeanLookupFactory: This method creates / retrieves an instance of the given type identified with the given identifier (name).
toInstance(CTX) - Method in interface org.refcodes.factory.ContextConverterFactory: This method creates / retrieves an instance of the given type with the given identifier (name) constructed as defined in one to many configuration files.
toInstance(CTX, Properties) - Method in interface org.refcodes.factory.ContextConverterFactory: This method creates / retrieves an instance of the given type with the given identifier (name) constructed as defined in one to many configuration files.
toInstance(ID, CTX) - Method in interface org.refcodes.factory.ContextLookupFactory: This method creates / retrieves an instance of the configured type identified with the given identifier (name).
toInstance(ID, CTX, Properties) - Method in interface org.refcodes.factory.ContextLookupFactory: This method creates / retrieves an instance of the configured type identified with the given identifier (name).
toInstance() - Method in class org.refcodes.factory.impls.AbstractRecyclableTypeFactory
toInstance(Properties) - Method in class org.refcodes.factory.impls.AbstractRecyclableTypeFactory
toInstance(ID) - Method in interface org.refcodes.factory.LookupFactory: This method creates / retrieves an instance of the configured type identified with the given identifier (name).
toInstance(ID, Properties) - Method in interface org.refcodes.factory.LookupFactory: This method creates / retrieves an instance of the configured type identified with the given identifier (name).
toInstance() - Method in interface org.refcodes.factory.TypeFactory: This method creates / retrieves an instance of the given type with the given identifier (name) constructed as defined in one to many configuration files.
toInstance(Properties) - Method in interface org.refcodes.factory.TypeFactory: This method creates / retrieves an instance of the given type with the given identifier (name) constructed as defined in one to many configuration files.
toInstances(Class<?>) - Method in interface org.refcodes.factory.BeanFactory
toInstances() - Method in interface org.refcodes.factory.CollectionFactory: This method creates / retrieves all instances of the given type.
toInstances(Properties) - Method in interface org.refcodes.factory.CollectionFactory: This method creates / retrieves all instances of the given type.
toInstances(Class<?>) - Method in interface org.refcodes.factory.TypeLookupFactory: This method creates / retrieves an all instances of the given type.
toInstances(Class<?>, Properties) - Method in interface org.refcodes.factory.TypeLookupFactory: This method creates / retrieves all instances of the given type.
toMarshaled(SRC) - Method in interface org.refcodes.factory.MarshalFactory: This method creates / retrieves an instance of the given type with the given identifier (name) constructed as defined in one to many configuration files.
toMarshaled(SRC, Properties) - Method in interface org.refcodes.factory.MarshalFactory: This method creates / retrieves an instance of the given type with the given identifier (name) constructed as defined in one to many configuration files.
toUnmarshaled(SRC, Class<T>) - Method in interface org.refcodes.factory.UnmarshalFactory: This method creates / retrieves an instances of the given type from the provided instance.
toUnmarshaled(SRC, Class<T>, Properties) - Method in interface org.refcodes.factory.UnmarshalFactory: This method creates / retrieves all instances of the given type.
TypeFactory<T> - Interface in org.refcodes.factory: The TypeFactory defines the functionality which must be provided in order to represent a factory for object creation of a predefined type specified with a generic argument (in contrast to the BeanLookupFactory , which creates instances of an expected type).
TypeLookupFactory - Interface in org.refcodes.factory: The TypeLookupFactory defines the functionality which must be provided in order to represent a factory for object creation of *ALL* objects being of a requested type (in contrast to the TypeFactory and the LookupFactory which create instances of a predefined type specified with a generic argument).
TypeRecyclable<T> - Interface in org.refcodes.factory: A factory implementing the TypeRecyclable interface takes once created instances back and will recycle them in terms of reusing: When a new instance is to be created and the factory contains recycled instances, then first recycled instances are returned till there are no more such instances available.

U

UnexpectedFactoryRuntimeException - Exception in org.refcodes.factory: Thrown in case of a caught runtime exception of an underlying framework which only shows up at runtime (probably not documented in any API).
UnexpectedFactoryRuntimeException(String, String) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException
UnexpectedFactoryRuntimeException(String, Throwable, String) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException
UnexpectedFactoryRuntimeException(String, Throwable) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException
UnexpectedFactoryRuntimeException(String) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException
UnexpectedFactoryRuntimeException(Throwable, String) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException
UnexpectedFactoryRuntimeException(Throwable) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException
UnmarshalFactory<SRC> - Interface in org.refcodes.factory: The UnmarshalFactory defines the functionality which must be provided in order to represent a factory for object creation of an object being of a requested type (in contrast to the TypeFactory and the SelectorFactory from an instance of a provided type.

A B C F G L M N O R T U