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

The Class FactoryRuntimeException.

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

Instantiates a new factory runtime exception.

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

Instantiates a new factory runtime exception.

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

Instantiates a new factory runtime exception.

FactoryRuntimeException(String) - Constructor for exception org.refcodes.factory.FactoryRuntimeException

Instantiates a new factory runtime exception.

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

Instantiates a new factory runtime exception.

FactoryRuntimeException(Throwable) - Constructor for exception org.refcodes.factory.FactoryRuntimeException

Instantiates a new factory runtime exception.

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 AbstractRecyclableTypeFactory.toInstance() in case there are no more recycled objects available (provided via AbstractRecyclableTypeFactory.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 AbstractRecyclableTypeFactory.toInstance(Properties) in case there are no more recycled objects available (provided via AbstractRecyclableTypeFactory.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

To instance.

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

To instance.

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

To instances.

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 instance of the given type from the provided instance.

toUnmarshaled(SRC, Class<?>...) - Method in interface org.refcodes.factory.UnmarshalFactory

This method creates / retrieves an instance of one of the given types from the provided instance.

toUnmarshaled(SRC, Properties, Class<?>...) - Method in interface org.refcodes.factory.UnmarshalFactory

This method creates / retrieves an instance of one of the given types 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

Instantiates a new unexpected factory runtime exception.

UnexpectedFactoryRuntimeException(String, Throwable, String) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException

Instantiates a new unexpected factory runtime exception.

UnexpectedFactoryRuntimeException(String, Throwable) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException

Instantiates a new unexpected factory runtime exception.

UnexpectedFactoryRuntimeException(String) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException

Instantiates a new unexpected factory runtime exception.

UnexpectedFactoryRuntimeException(Throwable, String) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException

Instantiates a new unexpected factory runtime exception.

UnexpectedFactoryRuntimeException(Throwable) - Constructor for exception org.refcodes.factory.UnexpectedFactoryRuntimeException

Instantiates a new unexpected factory runtime exception.

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 LookupFactory) from an instance of a provided type.

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