BeanFactory.MetaFactory (Smart GWT EE API 14.0d (2024-12-22))

Enclosing class:

BeanFactory<BeanClass>
```
public static interface BeanFactory.MetaFactory
```
An interface which you can extend in order to register classes with the BeanFactory reflection mechanism.
Note: While this mechanism continues to work, there is now an easier way to register classes for reflection, by annotating them with the BeanFactory.Generate annotation.
In order to use a BeanFactory for a class, you need to register it by generating a BeanFactory subclass for the class. You can use BeanFactory.CanvasMetaFactory to scan the class path and register every Canvas subclass (including your custom subclasses), or use BeanFactory.FormItemMetaFactory to regiser every FormItem subclass. However, if you know that you only need to register some classes for reflection, then you can use BeanFactory.MetaFactory instead (or, even more conveniently, the BeanFactory.Generate annotation).
Usage of BeanFactory.MetaFactory is most easily explained with an example. First, you define an interface. (Note that it can be an inner interface.)
```
 public interface MyMetaFactory extends BeanFactory.MetaFactory {
     BeanFactory<ListGrid> getListGridFactory();
     BeanFactory<TileGrid> getTileGridBeanFactory();
 }
```
... and then you trigger the generation process:
```
 GWT.create(MyMetaFactory.class);
```
Each function in the interface you define will result in the creation of one BeanFactory ... so, in this case, we would end up with bean factories for ListGrid and TileGrid. The rules are as follows:
1. The interface must extend BeanFactory.MetaFactory
2. The return type for each function must be BeanFactory, with a generic type that is the class you want the factory for.
3. The function must take no arguments.
4. The name of the function doesn't matter.
If you want, you can keep a reference to the results of the GWT.create(), and call the functions:
```
 MyMetaFactory metaFactory = GWT.create(MyMetaFactory.class);
 BeanFactory<TileGrid> myTileGridFactory = myMetaFactory.getTileGridBeanFactory();
```
However, you don't have to do that ... you can ignore the results of GWT.create() and just use the BeanFactory static API:
```
 GWT.create(MyMetaFactory.class);
 Object myGrid = BeanFactory.newInstance("TileGrid");
 BeanFactory.setProperty(myGrid, "width", 207);
```
... except that "TileGrid" would probably be a variable!
You can also use the generated classes in ComponentXML, by specifying the fully-qualified class name as the constructor for objects.
Note that the call to GWT.create() must occur at run-time before the factories are used. However, you can modularize by creating some factories first and other factories later, as long as each factory is created before being used.
See Also:

BeanFactory.Generate

Interface BeanFactory.MetaFactory