DynamicFactory (cdk 2.2 API)

java.lang.Object
- org.openscience.cdk.DynamicFactory

public class DynamicFactory
extends Object

A factory class for constructing ICDKObject and IChemObject implementations. Instances can be created by registering a construction key (DynamicFactory.ConstructorKey) with a corresponding creator (DynamicFactory.Creator). In most cases a class can simply be registered by providing an interface and an implementation register(Class, Class). Internally the factory stores the object creators in a symbol table which allows near constant time access for all registered classes. In cases of a non-direct parameter match (e.g. Atom(Atom) can resolve to Atom(Element)) the constructor is matched by invoking find(ConstructorKey). If a constructor was found the new key will be registered with cache to avoid the overhead of finding the correct constructor again.



     // create an instance of the factory
     DynamicFactory factory = new DynamicFactory(5);

     // register some implementations
     factory.register(IAtom.class,          Atom.class);
     factory.register(IElement.class,       Element.class);
     factory.register(IAtomContainer.class, AtomContainer.class);

     // create an instance using the default constructor
     IAtom a1 = factory.ofClass(IAtom.class);

     // create an instance using a parametrised constructor
     IAtom c  = factory.ofClass(IAtom.class, "C");

     // using a custom creator to actually invoke a constructor
     // import static org.openscience.cdk.DynamicFactory.key;
     // import static org.openscience.cdk.DynamicFactory.BasicCreator;
     factory.register(key(IBond.class, IAtom[].class),
                      new BasicCreator<IAtom>(null) {
                          public IAtom create(Object[] objects) {
                              return new Bond((IAtom[]) objects);
                          }
                      });

It is not always convenient to specify a custom DynamicFactory.Creator for every construction type but the objects may still need some modification directly after creation. The factory provides DynamicFactory.CreationModifier which is invoked directly after object creation. This allows changing the default of creation. As an example it is possible to set a non-null charge on all atoms that are created.


      // import static org.openscience.cdk.DynamicFactory.CreationModifier;
     factory.register(IAtom.class, Atom.class,
                      new CreationModifier<Atom>() {
                          public void modify(Atom atom) {
                               atom.setFormalCharge(0);
                          }
                      }));

It is also possible change the object creation based on the input parameters.


 factory.register(key(IAtom.class, String.class),
                  new DynamicFactory.BasicCreator<IAtom>() {

                      public IAtom create(Object[] objects) {
                          String symbol = (String) objects[0];
                          return "R".equals(symbol)
                                      ? new PseudoAtom(symbol)
                                      : new Atom(symbol);
                      }
                  });

 factory.ofClass(IAtom.class, "C"); // IAtom
 factory.ofClass(IAtom.class, "R"); // IPseudoAtom

Author:: John May
Source code:: master
Belongs to CDK module:: core

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`DynamicFactory.BasicCreator<T>` A simple creator that helps in creating an anonymous classes for a creator.
`static class`	`DynamicFactory.ConstructorKey` A class which encapsulates the information about an interface (of this implementation) and the parameter types of the constructor.
`static interface`	`DynamicFactory.CreationModifier<T>` An interface that allows posterior modification of an instance after it has been created.
`static interface`	`DynamicFactory.Creator<T>` An interface that wraps object creation via the `DynamicFactory.Creator.create(Object[])` method.
`protected static class`	`DynamicFactory.DefaultInterfaceProvider` A default interface provider implementation that simply returns the classes from `Class.getInterfaces()`.
`static interface`	`DynamicFactory.InterfaceProvider` An interface that can provide which interfaces the given class implements.

Constructor Summary

Constructors
Constructor and Description
`DynamicFactory(DynamicFactory.InterfaceProvider interfaceProvider, int n)` Create a new default factory with an expected number of registered classes and an interface provider.
`DynamicFactory(int n)` Create a new default factory with an expected number of registered classes and a default interface provider.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T extends ICDKObject> Set<Class<?>>`	`implementorsOf(Class<T> intf)` Access the registered implementations for a given interface.
`static DynamicFactory.ConstructorKey`	`key(Class<?> intf, Class<?>... types)` Creates a constructor key for use in accessing constructors.
`<T extends ICDKObject> T`	`ofClass(Class<T> intf)` Construct an implementation using the default constructor.
`<T extends ICDKObject> T`	`ofClass(Class<T> intf, Object... objects)` Construct an implementation using a constructor whose parameters match that of the provided objects.
`<T extends ICDKObject> boolean`	`register(Class<? extends T> impl)` Registers a class with the factory.
`<S extends ICDKObject,T extends S> boolean`	`register(Class<S> intf, Class<T> impl, DynamicFactory.CreationModifier<T> modifier)` Explicitly register a concrete class with a provided interface and a given modifier.
`<S extends ICDKObject,T extends S> boolean`	`register(Class<S> intf, Constructor<T> constructor)` Register a specific constructor with an explicit interface.
`<S extends ICDKObject,T extends S> boolean`	`register(Class<S> intf, Constructor<T> constructor, DynamicFactory.CreationModifier<T> modifier)` Register a specific constructor with a creation modifier to an explicit interface.
`<T extends ICDKObject> boolean`	`register(Class<T> intf, Class<? extends T> impl)` Explicitly register a concrete class with a provided interface.
`<T> DynamicFactory.Creator<T>`	`register(DynamicFactory.ConstructorKey key, DynamicFactory.Creator<T> creator)` Register a constructor key with a defined `DynamicFactory.Creator`.
`Iterator<DynamicFactory.ConstructorKey>`	`suggest(Class<?> intf)` Provides a list of all possible constructor keys for the provided interface.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DynamicFactory
```
public DynamicFactory(DynamicFactory.InterfaceProvider interfaceProvider,
                      int n)
```
    Create a new default factory with an expected number of registered classes and an interface provider. The interface provider is used when registering an implementation without a specified interface register(Class).
    
    Parameters:
    
    interfaceProvider - provides the interfaces of a given implementation class
    
    n - the expected number of constructors that will be stored.
    
    See Also:
    
    DynamicFactory(int)
  - DynamicFactory
```
public DynamicFactory(int n)
```
    Create a new default factory with an expected number of registered classes and a default interface provider. The default interface provider simply invokes Class.getInterfaces() when registering an implementation without an explicit interface register(Class).
    
    Parameters:
    
    n - the expected number of constructors that will be stored.
- Method Detail
  - register
```
public <T extends ICDKObject> boolean register(Class<? extends T> impl)
```
    Registers a class with the factory. The interfaces of the class will be checked to see if they are CDK interfaces before they are registered. This method is provided for utility but will register the implementation with all valid interfaces. If a restricted registration is required then the safer register(Class, Class) can be used.
    
    Parameters:
    
    impl - a concrete class
    
    Throws:
    
    IllegalArgumentException - thrown if a non-concrete class is registered
    
    See Also:
    
    register(Class, Class), register(Class, java.lang.reflect.Constructor), register(org.openscience.cdk.DynamicFactory.ConstructorKey, org.openscience.cdk.DynamicFactory.Creator)
  - register
```
public <T extends ICDKObject> boolean register(Class<T> intf,
                                               Class<? extends T> impl)
```
    Explicitly register a concrete class with a provided interface. The DynamicFactory.Creator will be automatically created for all public constructors.
    
    Parameters:
    
    intf - the interface class to register
    
    impl - the concrete class which should implement the interface class
    
    Returns:
    
    whether registration was successful
  - register
```
public <S extends ICDKObject,T extends S> boolean register(Class<S> intf,
                                                           Class<T> impl,
                                                           DynamicFactory.CreationModifier<T> modifier)
```
    Explicitly register a concrete class with a provided interface and a given modifier. The DynamicFactory.Creator will be automatically created for all public constructors. The modifier is incorporated into the DynamicFactory.Creator and is invoked directly after instantiation.
```
      // import static org.openscience.cdk.DynamicFactory.CreationModifier;
     factory.register(IAtom.class, Atom.class,
                      new CreationModifier<Atom>() {
                          public void modify(Atom atom) {
                               atom.setFormalCharge(0);
                          }
                      }));
 
```
    Type Parameters:
    
    S - interface type
    
    T - implementation type (must extend interface)
    
    Parameters:
    
    intf - the interface class to register
    
    impl - the concrete class which should implement the interface class
    
    modifier - modify a instance after creation
    
    Returns:
    
    whether registration was successful
  - register
```
public <S extends ICDKObject,T extends S> boolean register(Class<S> intf,
                                                           Constructor<T> constructor)
```
    Register a specific constructor with an explicit interface.
```
     // only register construction of IAtom using a string - Atom("C")
     factory.register(IAtom.class,
                      Atom.class.getConstructor(String.class));
 
```
    Type Parameters:
    
    S - interface type
    
    T - implementation type (must extend interface)
    
    Parameters:
    
    intf - the interface
    
    constructor - a constructor which builds the given interface
    
    Returns:
    
    whether the constructor was registered
  - register
```
public <S extends ICDKObject,T extends S> boolean register(Class<S> intf,
                                                           Constructor<T> constructor,
                                                           DynamicFactory.CreationModifier<T> modifier)
```
    Register a specific constructor with a creation modifier to an explicit interface.
```
      // only register construction of IAtom using a string - Atom("C")
      factory.register(IAtom.class,
                       Atom.class.getConstructor(String.class),
                       new DynamicFactory.CreationModifier<Atom>() {

                           public void modify(Atom instance) {
                              instance.setFormalCharge(0);
                           }
                       });
 
```
    Type Parameters:
    
    S - interface type
    
    T - implementation type (must extend interface)
    
    Parameters:
    
    intf - the interface
    
    constructor - a constructor which builds the given interface
    
    Returns:
    
    whether the constructor was registered
  - register
```
public <T> DynamicFactory.Creator<T> register(DynamicFactory.ConstructorKey key,
                                              DynamicFactory.Creator<T> creator)
```
    Register a constructor key with a defined DynamicFactory.Creator. The key defines the interface and parameters of the creation and the creator actually creates the object.
```
     // import static org.openscience.cdk.DynamicFactory.key;
     factory.register(key(IBond.class, IAtom[].class),
                      new BasicCreator<IAtom>(null) {
                          public IAtom create(Object[] objects) {
                              return new Bond((IAtom[]) objects);
                          }
                      });
 
```
    Type Parameters:
    
    T - type of object that will be created
    
    Parameters:
    
    key - construction key, defines interface and parameter types
    
    creator - creates the actual object
    
    Returns:
    
    the registered creator - null if not registered
  - key
```
public static DynamicFactory.ConstructorKey key(Class<?> intf,
                                                Class<?>... types)
```
    Creates a constructor key for use in accessing constructors. The key combines the interface and types in a single instance which we can then use in a map.
    
    Parameters:
    
    intf - the interface to build the key for
    
    types - the classes that the the constructor requires
    
    Returns:
    
    a constructor key which can be used to lookup a constructor
  - ofClass
```
public <T extends ICDKObject> T ofClass(Class<T> intf,
                                        Object... objects)
```
    Construct an implementation using a constructor whose parameters match that of the provided objects.
    
    Type Parameters:
    
    T - the type of the class
    
    Parameters:
    
    intf - the interface to construct an instance of
    
    Returns:
    
    an implementation of provided interface
    
    Throws:
    
    IllegalArgumentException - thrown if the implementation can not be constructed
    
    IllegalArgumentException - thrown if the provided class is not an interface
  - ofClass
```
public <T extends ICDKObject> T ofClass(Class<T> intf)
```
    Construct an implementation using the default constructor. This provides some speed boost over invoking ofClass(Class, Object...).
    
    Type Parameters:
    
    T - the type of the class
    
    Parameters:
    
    intf - the interface to construct an instance of
    
    Returns:
    
    an implementation of provided interface constructed using the default constructor.
    
    Throws:
    
    IllegalArgumentException - thrown if the implementation can not be constructed
    
    IllegalArgumentException - thrown if the provided class is not an interface
  - implementorsOf
```
public <T extends ICDKObject> Set<Class<?>> implementorsOf(Class<T> intf)
```
    Access the registered implementations for a given interface.
    
    Type Parameters:
    
    T - the type of the interface
    
    Parameters:
    
    intf - an interface which has registered implementations in the factory
    
    Returns:
    
    set of implementation classes (empty if none found)
  - suggest
```
public Iterator<DynamicFactory.ConstructorKey> suggest(Class<?> intf)
```
    Provides a list of all possible constructor keys for the provided interface.
    
    Parameters:
    
    intf - an interface to find all constructors for
    
    Returns:
    
    an iterator of constructor keys

Class DynamicFactory

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DynamicFactory

DynamicFactory

Method Detail

register

register

register

register

register

register

key

ofClass

ofClass

implementorsOf

suggest