FactoryBuilderSupport (Groovy 2.4.5)

java.lang.Object
- groovy.lang.GroovyObjectSupport
- - groovy.lang.Binding
  - - groovy.util.FactoryBuilderSupport

All Implemented Interfaces:

GroovyObject

Direct Known Subclasses:

ObjectGraphBuilder
```
public abstract class FactoryBuilderSupport
extends Binding
```
Mix of BuilderSupport and SwingBuilder's factory support. Warning: this implementation is not thread safe and should not be used across threads in a multi-threaded environment. A locking mechanism should be implemented by the subclass if use is expected across multiple threads.

Author:

James Strachan, Andres Almiray, Danno Ferrin

Field Summary

Fields
Modifier and Type	Field and Description
`protected LinkedList<Closure>`	`attributeDelegates`
`protected boolean`	`autoRegistrationComplete`
`protected boolean`	`autoRegistrationRunning`
`static String`	`CHILD_BUILDER`
`static String`	`CURRENT_BUILDER`
`static String`	`CURRENT_FACTORY`
`static String`	`CURRENT_NAME`
`static String`	`CURRENT_NODE`
`protected Map<String,Closure>`	`explicitMethods`
`protected Map<String,Closure[]>`	`explicitProperties`
`protected Closure`	`methodMissingDelegate`
`static String`	`OWNER`
`static String`	`PARENT_BUILDER`
`static String`	`PARENT_CONTEXT`
`static String`	`PARENT_FACTORY`
`static String`	`PARENT_NAME`
`static String`	`PARENT_NODE`
`protected LinkedList<Closure>`	`postInstantiateDelegates`
`protected LinkedList<Closure>`	`postNodeCompletionDelegates`
`protected LinkedList<Closure>`	`preInstantiateDelegates`
`protected Closure`	`propertyMissingDelegate`
`protected Map<String,Set<String>>`	`registrationGroup`
`protected String`	`registrationGroupName`
`static String`	`SCRIPT_CLASS_NAME`

Constructor Summary

Constructors
Constructor and Description

FactoryBuilderSupport()

FactoryBuilderSupport(boolean init)

Constructors
Constructor and Description
`FactoryBuilderSupport()`
`FactoryBuilderSupport(boolean init)`

Method Summary

Methods
Modifier and Type	Method and Description
`Closure`	`addAttributeDelegate(Closure attrDelegate)` Add an attribute delegate so it can intercept attributes being set.
`void`	`addDisposalClosure(Closure closure)`
`Closure`	`addPostInstantiateDelegate(Closure delegate)` Add a postInstantiate delegate so it can intercept nodes after they are created.
`Closure`	`addPostNodeCompletionDelegate(Closure delegate)` Add a nodeCompletion delegate so it can intercept nodes after they done with building.
`Closure`	`addPreInstantiateDelegate(Closure delegate)` Add a preInstantiate delegate so it can intercept nodes before they are created.
`void`	`autoRegisterNodes()` Ask the nodes to be registered
`Object`	`build(Class viewClass)`
`Object`	`build(Script script)`
`Object`	`build(String script, GroovyClassLoader loader)`
`protected boolean`	`checkExplicitMethod(String methodName, Object args, Reference result)`
`static void`	`checkValueIsNull(Object value, Object name)` Throws an exception if value is null.
`static boolean`	`checkValueIsType(Object value, Object name, Class type)` Checks type of value against builder type
`static boolean`	`checkValueIsTypeNotString(Object value, Object name, Class type)` Checks values against factory's type
`protected Object`	`createNode(Object name, Map attributes, Object value)` This method is responsible for instantiating a node and configure its properties.
`protected Object`	`dispatchNodeCall(Object name, Object args)`
`protected Object`	`dispathNodeCall(Object name, Object args)` Deprecated.
`void`	`dispose()`
`List<Closure>`	`getAttributeDelegates()`
`FactoryBuilderSupport`	`getChildBuilder()`
`Map<String,Object>`	`getContext()`
`Object`	`getContextAttribute(String key)`
`protected LinkedList<Map<String,Object>>`	`getContexts()`
`protected Map<String,Object>`	`getContinuationData()` Stores the thread local states in a Map that can be passed across threads
`Object`	`getCurrent()`
`FactoryBuilderSupport`	`getCurrentBuilder()`
`Factory`	`getCurrentFactory()`
`String`	`getCurrentName()`
`List<Closure>`	`getDisposalClosures()`
`Map<String,Closure>`	`getExplicitMethods()`
`Map<String,Closure[]>`	`getExplicitProperties()`
`Map<String,Factory>`	`getFactories()`
`Map<String,Closure>`	`getLocalExplicitMethods()`
`Map<String,Closure[]>`	`getLocalExplicitProperties()`
`Map<String,Factory>`	`getLocalFactories()`
`Closure`	`getMethodMissingDelegate()`
`Object`	`getName(String methodName)` A hook to allow names to be converted into some other object such as a QName in XML or ObjectName in JMX.
`Closure`	`getNameMappingClosure()`
`Map`	`getParentContext()`
`Factory`	`getParentFactory()`
`String`	`getParentName()`
`Object`	`getParentNode()`
`List<Closure>`	`getPostInstantiateDelegates()`
`List<Closure>`	`getPostNodeCompletionDelegates()`
`List<Closure>`	`getPreInstantiateDelegates()`
`Object`	`getProperty(String property)` Overloaded to make variables appear as bean properties or via the subscript operator
`Closure`	`getPropertyMissingDelegate()`
`protected FactoryBuilderSupport`	`getProxyBuilder()` Proxy builders are useful for changing the building context, thus enabling mix & match builders.
`Set<String>`	`getRegistrationGroupItems(String group)`
`Set<String>`	`getRegistrationGroups()`
`Object`	`getVariable(String name)`
`Map`	`getVariables()`
`protected void`	`handleNodeAttributes(Object node, Map attributes)` Assigns any existing properties to the node. It will call attributeDelegates before passing control to the factory that built the node.
`Object`	`invokeMethod(String methodName)` Convenience method when no arguments are required
`Object`	`invokeMethod(String methodName, Object args)` Invokes the given method.
`protected void`	`newContext()` Pushes a new context on the stack.
`protected void`	`nodeCompleted(Object parent, Object node)` A hook to allow nodes to be processed once they have had all of their children applied.
`protected Map<String,Object>`	`popContext()` Removes the last context from the stack.
`protected void`	`postInstantiate(Object name, Map attributes, Object node)` A hook after the factory creates the node and before attributes are set. It will call any registered postInstantiateDelegates, if you override this method be sure to call this impl somewhere in your code.
`protected Object`	`postNodeCompletion(Object parent, Object node)` A hook to allow nodes to be processed once they have had all of their children applied and allows the actual node object that represents the Markup element to be changed. It will call any registered postNodeCompletionDelegates, if you override this method be sure to call this impl at the end of your code.
`protected void`	`preInstantiate(Object name, Map attributes, Object value)` A hook before the factory creates the node. It will call any registered preInstantiateDelegates, if you override this method be sure to call this impl somewhere in your code.
`void`	`registerBeanFactory(String theName, Class beanClass)` Registers a factory for a JavaBean. The JavaBean class should have a no-args constructor.
`void`	`registerBeanFactory(String theName, String groupName, Class beanClass)` Registers a factory for a JavaBean. The JavaBean class should have a no-args constructor.
`void`	`registerExplicitMethod(String name, Closure closure)`
`void`	`registerExplicitMethod(String name, String groupName, Closure closure)`
`void`	`registerExplicitProperty(String name, Closure getter, Closure setter)`
`void`	`registerExplicitProperty(String name, String groupName, Closure getter, Closure setter)`
`void`	`registerFactory(String name, Factory factory)` Registers a factory for a node name.
`void`	`registerFactory(String name, String groupName, Factory factory)` Registers a factory for a node name.
`void`	`removeAttributeDelegate(Closure attrDelegate)` Remove the most recently added instance of the attribute delegate.
`void`	`removePostInstantiateDelegate(Closure delegate)` Remove the most recently added instance of the postInstantiate delegate.
`void`	`removePostNodeCompletionDelegate(Closure delegate)` Remove the most recently added instance of the nodeCompletion delegate.
`void`	`removePreInstantiateDelegate(Closure delegate)` Remove the most recently added instance of the preInstantiate delegate.
`protected void`	`reset()` Clears the context stack.
`protected Closure`	`resolveExplicitMethod(String methodName, Object args)` This is a hook for subclasses to plugin a custom strategy for mapping names to explicit methods.
`protected Closure[]`	`resolveExplicitProperty(String propertyName)` This is a hook for subclasses to plugin a custom strategy for mapping names to property methods.
`protected Factory`	`resolveFactory(Object name, Map attributes, Object value)` This is a hook for subclasses to plugin a custom strategy for mapping names to factories.
`protected void`	`restoreFromContinuationData(Map<String,Object> data)` Restores the state of the current builder to the same state as an older build.
`protected void`	`setClosureDelegate(Closure closure, Object node)` A strategy method to allow derived builders to use builder-trees and switch in different kinds of builders.
`void`	`setMethodMissingDelegate(Closure delegate)`
`void`	`setNameMappingClosure(Closure nameMappingClosure)`
`protected void`	`setNodeAttributes(Object node, Map attributes)` Maps attributes key/values to properties on node.
`protected void`	`setParent(Object parent, Object child)` Strategy method to establish parent/child relationships.
`void`	`setProperty(String property, Object newValue)` Overloaded to make variables appear as bean properties or via the subscript operator
`void`	`setPropertyMissingDelegate(Closure delegate)`
`protected void`	`setProxyBuilder(FactoryBuilderSupport proxyBuilder)` Sets the builder to be used as a proxy.
`void`	`setVariable(String name, Object value)` Sets the value of the given variable
`Object`	`withBuilder(FactoryBuilderSupport builder, Closure closure)` Switches the builder's proxyBuilder during the execution of a closure. This is useful to temporary change the building context to another builder without the need for a contrived setup.
`Object`	`withBuilder(FactoryBuilderSupport builder, String name, Closure closure)` Switches the builder's proxyBuilder during the execution of a closure. This is useful to temporary change the building context to another builder without the need for a contrived setup.
`Object`	`withBuilder(Map attributes, FactoryBuilderSupport builder, String name, Closure closure)` Switches the builder's proxyBuilder during the execution of a closure. This is useful to temporary change the building context to another builder without the need for a contrived setup.

Methods inherited from class groovy.lang.Binding
hasVariable

Methods inherited from class groovy.lang.GroovyObjectSupport
getMetaClass, setMetaClass

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

- Field Detail
  - CURRENT_FACTORY
```
public static final String CURRENT_FACTORY
```
    See Also:
    Constant Field Values
  - PARENT_FACTORY
```
public static final String PARENT_FACTORY
```
    See Also:
    Constant Field Values
  - PARENT_NODE
```
public static final String PARENT_NODE
```
    See Also:
    Constant Field Values
  - CURRENT_NODE
```
public static final String CURRENT_NODE
```
    See Also:
    Constant Field Values
  - PARENT_CONTEXT
```
public static final String PARENT_CONTEXT
```
    See Also:
    Constant Field Values
  - PARENT_NAME
```
public static final String PARENT_NAME
```
    See Also:
    Constant Field Values
  - CURRENT_NAME
```
public static final String CURRENT_NAME
```
    See Also:
    Constant Field Values
  - OWNER
```
public static final String OWNER
```
    See Also:
    Constant Field Values
  - PARENT_BUILDER
```
public static final String PARENT_BUILDER
```
    See Also:
    Constant Field Values
  - CURRENT_BUILDER
```
public static final String CURRENT_BUILDER
```
    See Also:
    Constant Field Values
  - CHILD_BUILDER
```
public static final String CHILD_BUILDER
```
    See Also:
    Constant Field Values
  - SCRIPT_CLASS_NAME
```
public static final String SCRIPT_CLASS_NAME
```
    See Also:
    Constant Field Values
  - attributeDelegates
```
protected LinkedList<Closure> attributeDelegates
```
  - preInstantiateDelegates
```
protected LinkedList<Closure> preInstantiateDelegates
```
  - postInstantiateDelegates
```
protected LinkedList<Closure> postInstantiateDelegates
```
  - postNodeCompletionDelegates
```
protected LinkedList<Closure> postNodeCompletionDelegates
```
  - methodMissingDelegate
```
protected Closure methodMissingDelegate
```
  - propertyMissingDelegate
```
protected Closure propertyMissingDelegate
```
  - explicitProperties
```
protected Map<String,Closure[]> explicitProperties
```
  - explicitMethods
```
protected Map<String,Closure> explicitMethods
```
  - registrationGroup
```
protected Map<String,Set<String>> registrationGroup
```
  - registrationGroupName
```
protected String registrationGroupName
```
  - autoRegistrationRunning
```
protected boolean autoRegistrationRunning
```
  - autoRegistrationComplete
```
protected boolean autoRegistrationComplete
```
- Constructor Detail
  - FactoryBuilderSupport
```
public FactoryBuilderSupport()
```
  - FactoryBuilderSupport
```
public FactoryBuilderSupport(boolean init)
```
- Method Detail
  - checkValueIsNull
```
public static void checkValueIsNull(Object value,
                    Object name)
```
    Throws an exception if value is null.
    
    Parameters:
    value - the node's value
    name - the node's name
  - checkValueIsType
```
public static boolean checkValueIsType(Object value,
                       Object name,
                       Class type)
```
    Checks type of value against builder type
    
    Parameters:
    value - the node's value
    name - the node's name
    type - a Class that may be assignable to the value's class
    
    Returns:
    true if type is assignable to the value's class, false if value is null.
  - checkValueIsTypeNotString
```
public static boolean checkValueIsTypeNotString(Object value,
                                Object name,
                                Class type)
```
    Checks values against factory's type
    
    Parameters:
    value - the node's value
    name - the node's name
    type - a Class that may be assignable to the value's class
    
    Returns:
    Returns true if type is assignable to the value's class, false if value is null or a String.
  - autoRegisterNodes
```
public void autoRegisterNodes()
```
    Ask the nodes to be registered
  - getVariable
```
public Object getVariable(String name)
```
    Overrides:
    
    getVariable in class Binding
    
    Parameters:
    name - the name of the variable to lookup
    
    Returns:
    the variable value
  - setVariable
```
public void setVariable(String name,
               Object value)
```
    Sets the value of the given variable
    
    Overrides:
    
    setVariable in class Binding
    
    Parameters:
    name - the name of the variable to set
    value - the new value for the given variable
  - getVariables
```
public Map getVariables()
```
    Overrides:
    
    getVariables in class Binding
  - getProperty
```
public Object getProperty(String property)
```
    Overloaded to make variables appear as bean properties or via the subscript operator
    
    Specified by:
    
    getProperty in interface GroovyObject
    
    Overrides:
    
    getProperty in class Binding
    
    Parameters:
    property - the name of the property of interest
    
    Returns:
    the given property
  - setProperty
```
public void setProperty(String property,
               Object newValue)
```
    Overloaded to make variables appear as bean properties or via the subscript operator
    
    Specified by:
    
    setProperty in interface GroovyObject
    
    Overrides:
    
    setProperty in class Binding
    
    Parameters:
    property - the name of the property of interest
    newValue - the new value for the property
  - getFactories
```
public Map<String,Factory> getFactories()
```
    Returns:
    the factory map (Unmodifiable Map).
  - getExplicitMethods
```
public Map<String,Closure> getExplicitMethods()
```
    Returns:
    the explicit methods map (Unmodifiable Map).
  - getExplicitProperties
```
public Map<String,Closure[]> getExplicitProperties()
```
    Returns:
    the explicit properties map (Unmodifiable Map).
  - getLocalFactories
```
public Map<String,Factory> getLocalFactories()
```
    Returns:
    the factory map (Unmodifiable Map).
  - getLocalExplicitMethods
```
public Map<String,Closure> getLocalExplicitMethods()
```
    Returns:
    the explicit methods map (Unmodifiable Map).
  - getLocalExplicitProperties
```
public Map<String,Closure[]> getLocalExplicitProperties()
```
    Returns:
    the explicit properties map (Unmodifiable Map).
  - getRegistrationGroups
```
public Set<String> getRegistrationGroups()
```
  - getRegistrationGroupItems
```
public Set<String> getRegistrationGroupItems(String group)
```
  - getAttributeDelegates
```
public List<Closure> getAttributeDelegates()
```
  - getPreInstantiateDelegates
```
public List<Closure> getPreInstantiateDelegates()
```
  - getPostInstantiateDelegates
```
public List<Closure> getPostInstantiateDelegates()
```
  - getPostNodeCompletionDelegates
```
public List<Closure> getPostNodeCompletionDelegates()
```
  - getMethodMissingDelegate
```
public Closure getMethodMissingDelegate()
```
  - setMethodMissingDelegate
```
public void setMethodMissingDelegate(Closure delegate)
```
  - getPropertyMissingDelegate
```
public Closure getPropertyMissingDelegate()
```
  - setPropertyMissingDelegate
```
public void setPropertyMissingDelegate(Closure delegate)
```
  - getContext
```
public Map<String,Object> getContext()
```
    Returns:
    the context of the current node.
  - getCurrent
```
public Object getCurrent()
```
    Returns:
    the current node being built.
  - getCurrentFactory
```
public Factory getCurrentFactory()
```
    Returns:
    the factory that built the current node.
  - getCurrentName
```
public String getCurrentName()
```
    Returns:
    the factory of the parent of the current node.
  - getCurrentBuilder
```
public FactoryBuilderSupport getCurrentBuilder()
```
    Returns:
    the builder that built the current node.
  - getParentNode
```
public Object getParentNode()
```
    Returns:
    the node of the parent of the current node.
  - getParentFactory
```
public Factory getParentFactory()
```
    Returns:
    the factory of the parent of the current node.
  - getParentContext
```
public Map getParentContext()
```
    Returns:
    the context of the parent of the current node.
  - getParentName
```
public String getParentName()
```
    Returns:
    the name of the parent of the current node.
  - getChildBuilder
```
public FactoryBuilderSupport getChildBuilder()
```
  - getContextAttribute
```
public Object getContextAttribute(String key)
```
  - invokeMethod
```
public Object invokeMethod(String methodName)
```
    Convenience method when no arguments are required
    
    Parameters:
    methodName - the name of the method to invoke
    
    Returns:
    the result of the call
  - invokeMethod
```
public Object invokeMethod(String methodName,
                  Object args)
```
    Description copied from interface: GroovyObject
    
    Invokes the given method.
    
    Specified by:
    
    invokeMethod in interface GroovyObject
    
    Overrides:
    
    invokeMethod in class GroovyObjectSupport
    
    Parameters:
    methodName - the name of the method to call
    args - the arguments to use for the method call
    
    Returns:
    the result of invoking the method
  - addAttributeDelegate
```
public Closure addAttributeDelegate(Closure attrDelegate)
```
    Add an attribute delegate so it can intercept attributes being set. Attribute delegates are fired in a FILO pattern, so that nested delegates get first crack.
    
    Parameters:
    attrDelegate - the closure to be called
    
    Returns:
    attrDelegate
  - removeAttributeDelegate
```
public void removeAttributeDelegate(Closure attrDelegate)
```
    Remove the most recently added instance of the attribute delegate.
    
    Parameters:
    attrDelegate - the instance of the closure to be removed
  - addPreInstantiateDelegate
```
public Closure addPreInstantiateDelegate(Closure delegate)
```
    Add a preInstantiate delegate so it can intercept nodes before they are created. PreInstantiate delegates are fired in a FILO pattern, so that nested delegates get first crack.
    
    Parameters:
    delegate - the closure to invoke
    
    Returns:
    delegate
  - removePreInstantiateDelegate
```
public void removePreInstantiateDelegate(Closure delegate)
```
    Remove the most recently added instance of the preInstantiate delegate.
    
    Parameters:
    delegate - the closure to invoke
  - addPostInstantiateDelegate
```
public Closure addPostInstantiateDelegate(Closure delegate)
```
    Add a postInstantiate delegate so it can intercept nodes after they are created. PostInstantiate delegates are fired in a FILO pattern, so that nested delegates get first crack.
    
    Parameters:
    delegate - the closure to invoke
    
    Returns:
    delegate
  - removePostInstantiateDelegate
```
public void removePostInstantiateDelegate(Closure delegate)
```
    Remove the most recently added instance of the postInstantiate delegate.
    
    Parameters:
    delegate - the closure to invoke
  - addPostNodeCompletionDelegate
```
public Closure addPostNodeCompletionDelegate(Closure delegate)
```
    Add a nodeCompletion delegate so it can intercept nodes after they done with building. NodeCompletion delegates are fired in a FILO pattern, so that nested delegates get first crack.
    
    Parameters:
    delegate - the closure to invoke
    
    Returns:
    delegate
  - removePostNodeCompletionDelegate
```
public void removePostNodeCompletionDelegate(Closure delegate)
```
    Remove the most recently added instance of the nodeCompletion delegate.
    
    Parameters:
    delegate - the closure to be removed
  - registerExplicitProperty
```
public void registerExplicitProperty(String name,
                            Closure getter,
                            Closure setter)
```
  - registerExplicitProperty
```
public void registerExplicitProperty(String name,
                            String groupName,
                            Closure getter,
                            Closure setter)
```
  - registerExplicitMethod
```
public void registerExplicitMethod(String name,
                          Closure closure)
```
  - registerExplicitMethod
```
public void registerExplicitMethod(String name,
                          String groupName,
                          Closure closure)
```
  - registerBeanFactory
```
public void registerBeanFactory(String theName,
                       Class beanClass)
```
    Registers a factory for a JavaBean.
    The JavaBean class should have a no-args constructor.
    
    Parameters:
    theName - name of the node
    beanClass - the factory to handle the name
  - registerBeanFactory
```
public void registerBeanFactory(String theName,
                       String groupName,
                       Class beanClass)
```
    Registers a factory for a JavaBean.
    The JavaBean class should have a no-args constructor.
    
    Parameters:
    theName - name of the node
    groupName - thr group to register this node in
    beanClass - the factory to handle the name
  - registerFactory
```
public void registerFactory(String name,
                   Factory factory)
```
    Registers a factory for a node name.
    
    Parameters:
    name - the name of the node
    factory - the factory to return the values
  - registerFactory
```
public void registerFactory(String name,
                   String groupName,
                   Factory factory)
```
    Registers a factory for a node name.
    
    Parameters:
    name - the name of the node
    groupName - thr group to register this node in
    factory - the factory to return the values
  - createNode
```
protected Object createNode(Object name,
                Map attributes,
                Object value)
```
    This method is responsible for instantiating a node and configure its properties.
    
    Parameters:
    name - the name of the node
    attributes - the attributes for the node
    value - the value arguments for the node
    
    Returns:
    the object return from the factory
  - resolveFactory
```
protected Factory resolveFactory(Object name,
                     Map attributes,
                     Object value)
```
    This is a hook for subclasses to plugin a custom strategy for mapping names to factories.
    
    Parameters:
    name - the name of the factory
    attributes - the attributes from the node
    value - value arguments from te node
    
    Returns:
    the Factory associated with name.
  - resolveExplicitMethod
```
protected Closure resolveExplicitMethod(String methodName,
                            Object args)
```
    This is a hook for subclasses to plugin a custom strategy for mapping names to explicit methods.
    
    Parameters:
    methodName - the name of the explicit method
    args - the arguments for the method
    
    Returns:
    the closure for the matched explicit method.
  - resolveExplicitProperty
```
protected Closure[] resolveExplicitProperty(String propertyName)
```
    This is a hook for subclasses to plugin a custom strategy for mapping names to property methods.
    
    Parameters:
    propertyName - the name of the explicit method
    
    Returns:
    the get and set closures (in that order) for the matched explicit property.
  - checkExplicitMethod
```
protected boolean checkExplicitMethod(String methodName,
                          Object args,
                          Reference result)
```
  - dispathNodeCall
```
@Deprecated
protected Object dispathNodeCall(Object name,
                                Object args)
```
    Deprecated.
    
    Use dispatchNodeCall(Object, Object) instead.
  - dispatchNodeCall
```
protected Object dispatchNodeCall(Object name,
                      Object args)
```
  - getName
```
public Object getName(String methodName)
```
    A hook to allow names to be converted into some other object such as a QName in XML or ObjectName in JMX.
    
    Parameters:
    methodName - the name of the desired method
    
    Returns:
    the object representing the name
  - getProxyBuilder
```
protected FactoryBuilderSupport getProxyBuilder()
```
    Proxy builders are useful for changing the building context, thus enabling mix & match builders.
    
    Returns:
    the current builder that serves as a proxy.
  - setProxyBuilder
```
protected void setProxyBuilder(FactoryBuilderSupport proxyBuilder)
```
    Sets the builder to be used as a proxy.
    
    Parameters:
    proxyBuilder - the new proxy
  - getNameMappingClosure
```
public Closure getNameMappingClosure()
```
  - setNameMappingClosure
```
public void setNameMappingClosure(Closure nameMappingClosure)
```
  - handleNodeAttributes
```
protected void handleNodeAttributes(Object node,
                        Map attributes)
```
    Assigns any existing properties to the node.
    It will call attributeDelegates before passing control to the factory that built the node.
    
    Parameters:
    node - the object returned by tne node factory
    attributes - the attributes for the node
  - newContext
```
protected void newContext()
```
    Pushes a new context on the stack.
  - nodeCompleted
```
protected void nodeCompleted(Object parent,
                 Object node)
```
    A hook to allow nodes to be processed once they have had all of their children applied.
    
    Parameters:
    node - the current node being processed
    parent - the parent of the node being processed
  - popContext
```
protected Map<String,Object> popContext()
```
    Removes the last context from the stack.
    
    Returns:
    the content just removed
  - postInstantiate
```
protected void postInstantiate(Object name,
                   Map attributes,
                   Object node)
```
    A hook after the factory creates the node and before attributes are set.
    It will call any registered postInstantiateDelegates, if you override this method be sure to call this impl somewhere in your code.
    
    Parameters:
    name - the name of the node
    attributes - the attributes for the node
    node - the object created by the node factory
  - postNodeCompletion
```
protected Object postNodeCompletion(Object parent,
                        Object node)
```
    A hook to allow nodes to be processed once they have had all of their children applied and allows the actual node object that represents the Markup element to be changed.
    It will call any registered postNodeCompletionDelegates, if you override this method be sure to call this impl at the end of your code.
    
    Parameters:
    node - the current node being processed
    parent - the parent of the node being processed
    
    Returns:
    the node, possibly new, that represents the markup element
  - preInstantiate
```
protected void preInstantiate(Object name,
                  Map attributes,
                  Object value)
```
    A hook before the factory creates the node.
    It will call any registered preInstantiateDelegates, if you override this method be sure to call this impl somewhere in your code.
    
    Parameters:
    name - the name of the node
    attributes - the attributes of the node
    value - the value argument(s) of the node
  - reset
```
protected void reset()
```
    Clears the context stack.
  - setClosureDelegate
```
protected void setClosureDelegate(Closure closure,
                      Object node)
```
    A strategy method to allow derived builders to use builder-trees and switch in different kinds of builders. This method should call the setDelegate() method on the closure which by default passes in this but if node is-a builder we could pass that in instead (or do something wacky too)
    
    Parameters:
    closure - the closure on which to call setDelegate()
    node - the node value that we've just created, which could be a builder
  - setNodeAttributes
```
protected void setNodeAttributes(Object node,
                     Map attributes)
```
    Maps attributes key/values to properties on node.
    
    Parameters:
    node - the object from the node
    attributes - the attributes to be set
  - setParent
```
protected void setParent(Object parent,
             Object child)
```
    Strategy method to establish parent/child relationships.
    
    Parameters:
    parent - the object from the parent node
    child - the object from the child node
  - getContexts
```
protected LinkedList<Map<String,Object>> getContexts()
```
    Returns:
    the stack of available contexts.
  - getContinuationData
```
protected Map<String,Object> getContinuationData()
```
    Stores the thread local states in a Map that can be passed across threads
    
    Returns:
    the map
  - restoreFromContinuationData
```
protected void restoreFromContinuationData(Map<String,Object> data)
```
    Restores the state of the current builder to the same state as an older build. Caution, this will destroy rather than merge the current build context if there is any,
    
    Parameters:
    data - the data retrieved from a compatible getContinuationData call
  - build
```
public Object build(Class viewClass)
```
  - build
```
public Object build(Script script)
```
  - build
```
public Object build(String script,
           GroovyClassLoader loader)
```
  - withBuilder
```
public Object withBuilder(FactoryBuilderSupport builder,
                 Closure closure)
```
    Switches the builder's proxyBuilder during the execution of a closure.
    This is useful to temporary change the building context to another builder without the need for a contrived setup. It will also take care of restoring the previous proxyBuilder when the execution finishes, even if an exception was thrown from inside the closure.
    
    Parameters:
    builder - the temporary builder to switch to as proxyBuilder.
    closure - the closure to be executed under the temporary builder.
    
    Returns:
    the execution result of the closure.
    
    Throws:
    
    RuntimeException - - any exception the closure might have thrown during execution.
  - withBuilder
```
public Object withBuilder(FactoryBuilderSupport builder,
                 String name,
                 Closure closure)
```
    Switches the builder's proxyBuilder during the execution of a closure.
    This is useful to temporary change the building context to another builder without the need for a contrived setup. It will also take care of restoring the previous proxyBuilder when the execution finishes, even if an exception was thrown from inside the closure. Additionally it will use the closure's result as the value for the node identified by 'name'.
    
    Parameters:
    builder - the temporary builder to switch to as proxyBuilder.
    name - the node to build on the 'parent' builder.
    closure - the closure to be executed under the temporary builder.
    
    Returns:
    a node that responds to value of name with the closure's result as its value.
    
    Throws:
    
    RuntimeException - - any exception the closure might have thrown during execution.
  - withBuilder
```
public Object withBuilder(Map attributes,
                 FactoryBuilderSupport builder,
                 String name,
                 Closure closure)
```
    Switches the builder's proxyBuilder during the execution of a closure.
    This is useful to temporary change the building context to another builder without the need for a contrived setup. It will also take care of restoring the previous proxyBuilder when the execution finishes, even if an exception was thrown from inside the closure. Additionally it will use the closure's result as the value for the node identified by 'name' and assign any attributes that might have been set.
    
    Parameters:
    attributes - additional properties for the node on the parent builder.
    builder - the temporary builder to switch to as proxyBuilder.
    name - the node to build on the 'parent' builder.
    closure - the closure to be executed under the temporary builder.
    
    Returns:
    a node that responds to value of name with the closure's result as its value.
    
    Throws:
    
    RuntimeException - - any exception the closure might have thrown during execution.
  - addDisposalClosure
```
public void addDisposalClosure(Closure closure)
```
  - getDisposalClosures
```
public List<Closure> getDisposalClosures()
```
  - dispose
```
public void dispose()
```

Class FactoryBuilderSupport

Field Summary

Constructor Summary

Method Summary

Methods inherited from class groovy.lang.Binding

Methods inherited from class groovy.lang.GroovyObjectSupport

Methods inherited from class java.lang.Object

Field Detail

CURRENT_FACTORY

PARENT_FACTORY

PARENT_NODE

CURRENT_NODE

PARENT_CONTEXT

PARENT_NAME

CURRENT_NAME

OWNER

PARENT_BUILDER

CURRENT_BUILDER

CHILD_BUILDER

SCRIPT_CLASS_NAME

attributeDelegates

preInstantiateDelegates

postInstantiateDelegates

postNodeCompletionDelegates

methodMissingDelegate

propertyMissingDelegate

explicitProperties

explicitMethods

registrationGroup

registrationGroupName

autoRegistrationRunning

autoRegistrationComplete

Constructor Detail

FactoryBuilderSupport

FactoryBuilderSupport

Method Detail

checkValueIsNull

checkValueIsType

checkValueIsTypeNotString

autoRegisterNodes

getVariable

setVariable

getVariables

getProperty

setProperty

getFactories

getExplicitMethods

getExplicitProperties

getLocalFactories

getLocalExplicitMethods

getLocalExplicitProperties

getRegistrationGroups

getRegistrationGroupItems

getAttributeDelegates

getPreInstantiateDelegates

getPostInstantiateDelegates

getPostNodeCompletionDelegates

getMethodMissingDelegate

setMethodMissingDelegate

getPropertyMissingDelegate

setPropertyMissingDelegate

getContext

getCurrent

getCurrentFactory

getCurrentName

getCurrentBuilder

getParentNode

getParentFactory

getParentContext

getParentName

getChildBuilder

getContextAttribute

invokeMethod

invokeMethod

addAttributeDelegate

removeAttributeDelegate

addPreInstantiateDelegate

removePreInstantiateDelegate

addPostInstantiateDelegate

removePostInstantiateDelegate