ConfigNode

java.lang.Object
- fx.codegen.model.ConfigNode

```
public class ConfigNode
extends java.lang.Object
```
Represents nodes within the data model.
Provides a series of attributes and analysis methods to be used in source code templates.

Constructor Summary

Constructors
Constructor and Description

ConfigNode()

ConfigNode(java.lang.String name)

Constructors
Constructor and Description
`ConfigNode()`
`ConfigNode(java.lang.String name)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addChild(ConfigNode configNode)`
`void`	`addPossibleValue(java.lang.String possibleValue)`
`void`	`addRefactoredName(java.lang.String refactoringType, java.lang.String refactoredName)`
`void`	`addRefactoredTypeName(java.lang.String refactoringType, java.lang.String refactoredTypeName)`
`void`	`addSimilarChildGroup(java.util.List<ConfigNode> similarChildGrup)`
`void`	`addSimilarTypesChildGroup(java.util.List<ConfigNode> group)`
`void`	`addUniqueAttributeTypeNode(ConfigNode attributeTypeNode)`
`int`	`countChildren()` Returns the number of child nodes or 0 if the node does not have any children
`boolean`	`equals(java.lang.Object other)`
`java.util.List<ConfigNode>`	`getChildren()`
`java.util.List<ConfigNode>`	`getChildrenWithTypesOrWithKeysOfTypes(java.util.List<java.lang.String> typeNames)` Compiles a list of children having one of the specified types or having type nodes with unique keys of the specified types, to be used for iteration within templates.
`ConfigNode`	`getFirstChildWithOtherTypeNode(ConfigNode typeNode)`
`ConfigNode`	`getFirstChildWithTypeNode(ConfigNode typeNode)`
`ConfigNode`	`getFirstUniqueKeyNode()`
`java.lang.String`	`getName()` The name of the node
`java.util.List<ConfigNode>`	`getNonPrimitiveChildren()` Returns a list of non-primitive children
`java.util.List<ConfigNode>`	`getNonPrimitiveChildrenWithKeysOfTypes(java.util.List<java.lang.String> typeNames)` Compiles a list of non-primitive children with type nodes for which the first unique key has one of the given types `hasNonPrimitiveChildrenWithKeysOfTypes(List)`
`int`	`getNumberOfIncomingReferences()` How many `nodes` in the same `data model` are referencing the current node, excluding self references
`int`	`getNumberOfOutgoingReferences()` How many references to this `node` exist throughout the current `data model`, excluding self references
`int`	`getNumberOfReferences()` The total number of references is the sum of `the number of incoming references` and `the number of outgoing references`
`ConfigNode`	`getParent()` Returns a reference to the parent node, or null in case of top-level nodes.
`java.util.List<java.lang.String>`	`getPossibleValues()` Volatile and not yet usable.
`java.util.List<ConfigNode>`	`getPrimitiveChildrenWithTypes(java.util.List<java.lang.String> typeNames)` Compiles a list of primitive children having one of the given types
`java.util.Map<java.lang.String,java.lang.String>`	`getRefactoredNames()` The results of every name re-factoring `preprocessors` applied to the `data model` can be found in this map.
`java.util.Map<java.lang.String,java.lang.String>`	`getRefactoredTypeNames()` Same as `refactored names`.
`java.util.List<java.util.List<ConfigNode>>`	`getSimilarChildGroups()` Returns a list of the different groups of similar nodes.
`java.util.List<java.util.List<ConfigNode>>`	`getSimilarTypesChildGroups()` Returns a list of groups of child nodes with the same `type nodes`
`java.lang.String`	`getTypeName()` The type of the node may be either detected by one or more of the `preprocessors` applied to the `data model` or explicitly defined by the author.
`ConfigNode`	`getTypeNode()` If the node references another node within the same `data model`, then the referenced node will be set as the current node's type node.
`java.util.List<ConfigNode>`	`getUniqueAttributeTypeNodes()` Returns a consolidated list of references to the `type nodes` of each `child` of the current node.
`boolean`	`hasChildren()` Returns true if the node has child nodes
`boolean`	`hasChildrenWithOtherTypeNode(ConfigNode typeNode)` True if the node has at least one child node which has a `type node` which is different than the given type node
`boolean`	`hasChildrenWithTypeNode(ConfigNode typeNode)` True if the node has at least one child node having the referenced `type node`
`boolean`	`hasChildrenWithTypesOrWithKeysOfTypes(java.util.List<java.lang.String> typeNames)` Returns true if the current node has at least one child with one of the given types or with a type node having the first unique key of the given type
`boolean`	`hasCollections()` Returns true if the current node has at least one child node which qualifies as a collection type.
`boolean`	`hasMappingNodes()` Returns true if the current node has at least one child node for which the type node qualifies as a mapping node.
`boolean`	`hasNonPrimitiveChildrenWithKeysOfTypes(java.util.List<java.lang.String> typeNames)` True if the node has at least one child node which is not a `primitive` and which has a `type node` which has at least one `unique key` which has the given type name Usually works in conjunction with `hasPrimitiveChildrenWithTypes(List)`
`boolean`	`hasNonPrimitiveTypeNodes()` Returns true if the node is not a `primitive` and has a `type node`.
`boolean`	`hasParent()` Returns true if the node is the child of another node (i.e.
`boolean`	`hasPrimitiveChildrenWithTypes(java.util.List<java.lang.String> typeNames)` True if the node has at least one child node which has been identified as a `primitive` and for which the `type name` can be found within the provided list
`boolean`	`hasPrimitiveChildrenWithTypes(java.util.List<java.lang.String> typeNames, java.lang.String dictionaryName)` Similar to the `hasPrimitiveChildrenWithTypes(List)` method, only it uses the node's `re-factored type name` resulted from the re-factoring based on the named dictionary
`boolean`	`hasSelfReferences()`
`boolean`	`hasSimilarChildGroups()`
`boolean`	`hasSimilarTypesChildGroups()`
`boolean`	`hasUniqueKeyNodes()` True if at least one of the child nodes has been identified as an unique key candidate.
`boolean`	`isCollection()` The result of the collection detection analysis.
`boolean`	`isDimensionCandidate()` Any entity which has at least one field that represents an unique key by itself (not combined with other fields) can be used as a dimension in a star or snowflake schema.
`boolean`	`isEnum()` Not yet used - enumeration handling to be implemented
`boolean`	`isFactCandidate()` Any entity which has no unique keys and yet a lot of references to other entities may be a fact in a star or snowflake schema.
`boolean`	`isLastChild()` True if the node has a parent node and is the last in the list of children of its parent node
`boolean`	`isLeaf()` Returns true if the node has a parent, but has no children.
`boolean`	`isMappingNode()` If a given node has exactly two children, both referencing other entities in the project, then the node is considered to be a mapping node.
`boolean`	`isOrphan()` An orphan entity is an entity without `references`, either `incoming` or `outgoing`
`boolean`	`isPrimitive()` Provides information on weather or not the node represents a primitive data type
`boolean`	`isPropertyGroup()` A property group is used in some architectures to group two or more properties of the same entity so that they may be accessed in a more orderly fashion
`boolean`	`isRegistryEntityCandidate()` Within the scope of the CodeGen project, Reference data that may be altered, added to or deleted from is called a registry.
`boolean`	`isSelfReference()` Should be true if the node has at least one child node having the `type node` equal to this node
`boolean`	`isUniqueKey()` Provides information on weather or not the node is candidate for an unique key Note that only `primitive types` may be used as unique keys
`void`	`setChildren(java.util.List<ConfigNode> children)`
`void`	`setCollection(boolean isCollection)`
`void`	`setEnum(boolean isEnum)`
`void`	`setName(java.lang.String name)`
`void`	`setNumberOfIncomingReferences(int numberOfIncomingReferences)`
`void`	`setNumberOfOutgoingReferences(int numberOfOutgoingReferences)`
`void`	`setParent(ConfigNode parent)`
`void`	`setPossibleValues(java.util.List<java.lang.String> possibleValues)`
`void`	`setPrimitive(boolean isPrimitive)`
`void`	`setPropertyGroup(boolean isPropertyGroup)`
`void`	`setRefactoredNames(java.util.Map<java.lang.String,java.lang.String> refactoredNames)`
`void`	`setRefactoredTypeNames(java.util.Map<java.lang.String,java.lang.String> refactoredTypeNames)`
`void`	`setSelfReference(boolean isSelfReference)`
`void`	`setSimilarChildGroups(java.util.List<java.util.List<ConfigNode>> similarChildGroups)`
`void`	`setSimilarTypesChildGroups(java.util.List<java.util.List<ConfigNode>> similarTypesChildGroups)`
`void`	`setTypeName(java.lang.String typeName)`
`void`	`setTypeNode(ConfigNode typeNode)`
`void`	`setUniqueAttributeTypeNodes(java.util.List<ConfigNode> uniqueAttributeTypeNodes)`
`void`	`setUniqueKey(boolean isUniqueKey)`

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

- Constructor Detail
  - ConfigNode
```
public ConfigNode()
```
  - ConfigNode
```
public ConfigNode(java.lang.String name)
```
- Method Detail
  - getName
```
public java.lang.String getName()
```
    The name of the node
  - setName
```
public void setName(java.lang.String name)
```
  - getTypeName
```
public java.lang.String getTypeName()
```
    The type of the node may be either detected by one or more of the preprocessors applied to the data model or explicitly defined by the author. In case of primitive data types, the type name will be one of the names defined in the primitives dictionary. In case of an implicit data type, the type name will be the name of the type node.which has been either detected or referenced by the author.
    
    If a type is explicitly attributed to the node by the author of the data model, then no preprocessor should be allowed to alter this name.
  - setTypeName
```
public void setTypeName(java.lang.String typeName)
```
  - getTypeNode
```
public ConfigNode getTypeNode()
```
    If the node references another node within the same data model, then the referenced node will be set as the current node's type node.
  - setTypeNode
```
public void setTypeNode(ConfigNode typeNode)
```
  - getNumberOfIncomingReferences
```
public int getNumberOfIncomingReferences()
```
    How many nodes in the same data model are referencing the current node, excluding self references
  - setNumberOfIncomingReferences
```
public void setNumberOfIncomingReferences(int numberOfIncomingReferences)
```
  - getNumberOfOutgoingReferences
```
public int getNumberOfOutgoingReferences()
```
    How many references to this node exist throughout the current data model, excluding self references
  - setNumberOfOutgoingReferences
```
public void setNumberOfOutgoingReferences(int numberOfOutgoingReferences)
```
  - isRegistryEntityCandidate
```
public boolean isRegistryEntityCandidate()
```
    Within the scope of the CodeGen project, Reference data that may be altered, added to or deleted from is called a registry. A node is considered to be a registry candidate if it has at least one incoming reference and the number of incoming references is greater than or equal to the number of outgoing references
  - getNumberOfReferences
```
public int getNumberOfReferences()
```
    The total number of references is the sum of the number of incoming references and the number of outgoing references
  - isOrphan
```
public boolean isOrphan()
```
    An orphan entity is an entity without references, either incoming or outgoing
  - getRefactoredTypeNames
```
public java.util.Map<java.lang.String,java.lang.String> getRefactoredTypeNames()
```
    Same as refactored names. May also include language dictionary-based re-factoring, which is useful for templates dedicated to a particular language.
  - setRefactoredTypeNames
```
public void setRefactoredTypeNames(java.util.Map<java.lang.String,java.lang.String> refactoredTypeNames)
```
  - getParent
```
public ConfigNode getParent()
```
    Returns a reference to the parent node, or null in case of top-level nodes.
  - setParent
```
public void setParent(ConfigNode parent)
```
  - getChildren
```
public java.util.List<ConfigNode> getChildren()
```
  - setChildren
```
public void setChildren(java.util.List<ConfigNode> children)
```
  - isPrimitive
```
public boolean isPrimitive()
```
    Provides information on weather or not the node represents a primitive data type
  - setPrimitive
```
public void setPrimitive(boolean isPrimitive)
```
  - getPossibleValues
```
public java.util.List<java.lang.String> getPossibleValues()
```
    Volatile and not yet usable.
  - setPossibleValues
```
public void setPossibleValues(java.util.List<java.lang.String> possibleValues)
```
  - isCollection
```
public boolean isCollection()
```
    The result of the collection detection analysis.
  - setCollection
```
public void setCollection(boolean isCollection)
```
  - isPropertyGroup
```
public boolean isPropertyGroup()
```
    A property group is used in some architectures to group two or more properties of the same entity so that they may be accessed in a more orderly fashion
  - setPropertyGroup
```
public void setPropertyGroup(boolean isPropertyGroup)
```
  - getRefactoredNames
```
public java.util.Map<java.lang.String,java.lang.String> getRefactoredNames()
```
    The results of every name re-factoring preprocessors applied to the data model can be found in this map.
    
    - The keys of the map are the name of the preprocessing result (i.e. "plural-lower-camel-case")
    - The values represent the preprocessing result itself
    
    See Also:
    
    fx.codegen.preprocessor.stock.NodesRefactoringCodegenPreprocessor} , {@link fx.codegen.preprocessor.stock.refactoringconsumers.namesrefactoringconsumers}
  - setRefactoredNames
```
public void setRefactoredNames(java.util.Map<java.lang.String,java.lang.String> refactoredNames)
```
  - addChild
```
public void addChild(ConfigNode configNode)
```
  - addPossibleValue
```
public void addPossibleValue(java.lang.String possibleValue)
```
  - addRefactoredName
```
public void addRefactoredName(java.lang.String refactoringType,
                              java.lang.String refactoredName)
```
  - addRefactoredTypeName
```
public void addRefactoredTypeName(java.lang.String refactoringType,
                                  java.lang.String refactoredTypeName)
```
  - hasChildren
```
public boolean hasChildren()
```
    Returns true if the node has child nodes
  - countChildren
```
public int countChildren()
```
    Returns the number of child nodes or 0 if the node does not have any children
  - hasParent
```
public boolean hasParent()
```
    Returns true if the node is the child of another node (i.e. not a top level node)
  - hasCollections
```
public boolean hasCollections()
```
    Returns true if the current node has at least one child node which qualifies as a collection type.
    
    See Also:
    
    isCollection()
  - isDimensionCandidate
```
public boolean isDimensionCandidate()
```
    Any entity which has at least one field that represents an unique key by itself (not combined with other fields) can be used as a dimension in a star or snowflake schema.
  - isFactCandidate
```
public boolean isFactCandidate()
```
    Any entity which has no unique keys and yet a lot of references to other entities may be a fact in a star or snowflake schema.
  - isEnum
```
public boolean isEnum()
```
    Not yet used - enumeration handling to be implemented
  - setEnum
```
public void setEnum(boolean isEnum)
```
  - isUniqueKey
```
public boolean isUniqueKey()
```
    Provides information on weather or not the node is candidate for an unique key
    
    Note that only primitive types may be used as unique keys
    
    See Also:
    
    DictionaryUniqueKeyResolvingCodegenPreprocessor
  - setUniqueKey
```
public void setUniqueKey(boolean isUniqueKey)
```
  - getUniqueAttributeTypeNodes
```
public java.util.List<ConfigNode> getUniqueAttributeTypeNodes()
```
    Returns a consolidated list of references to the type nodes of each child of the current node.
    
    For example, if if the node named "transfer record" has two nodes named "from stock" and "to stock", both referencing the node named "stock", then the "stock" node will appear only once in the consolidated list.
    
    See Also:
    
    fx.codegen.preprocessor.stock.UniqueAttributeTypesCollectingCodegenPreprocessor}
  - setUniqueAttributeTypeNodes
```
public void setUniqueAttributeTypeNodes(java.util.List<ConfigNode> uniqueAttributeTypeNodes)
```
  - addUniqueAttributeTypeNode
```
public void addUniqueAttributeTypeNode(ConfigNode attributeTypeNode)
```
  - getSimilarChildGroups
```
public java.util.List<java.util.List<ConfigNode>> getSimilarChildGroups()
```
    Returns a list of the different groups of similar nodes. The similarity is usually determined by the node name and the node type. For instance, if a node named "planned activity" has two child nodes named "start time" and "end time". these two child nodes will belong to the same group.
  - setSimilarChildGroups
```
public void setSimilarChildGroups(java.util.List<java.util.List<ConfigNode>> similarChildGroups)
```
  - addSimilarChildGroup
```
public void addSimilarChildGroup(java.util.List<ConfigNode> similarChildGrup)
```
  - hasSimilarChildGroups
```
public boolean hasSimilarChildGroups()
```
  - getSimilarTypesChildGroups
```
public java.util.List<java.util.List<ConfigNode>> getSimilarTypesChildGroups()
```
    Returns a list of groups of child nodes with the same type nodes
    
    See Also:
    
    SimilarTypesChildGroupsIdentifyingCodegenPreprocessor
  - setSimilarTypesChildGroups
```
public void setSimilarTypesChildGroups(java.util.List<java.util.List<ConfigNode>> similarTypesChildGroups)
```
  - addSimilarTypesChildGroup
```
public void addSimilarTypesChildGroup(java.util.List<ConfigNode> group)
```
  - hasSimilarTypesChildGroups
```
public boolean hasSimilarTypesChildGroups()
```
  - isSelfReference
```
public boolean isSelfReference()
```
    Should be true if the node has at least one child node having the type node equal to this node
    
    See Also:
    
    SelfReferenceComputingCodegenPreprocessor
  - setSelfReference
```
public void setSelfReference(boolean isSelfReference)
```
  - hasSelfReferences
```
public boolean hasSelfReferences()
```
  - hasUniqueKeyNodes
```
public boolean hasUniqueKeyNodes()
```
    True if at least one of the child nodes has been identified as an unique key candidate.
    
    See Also:
    
    isUniqueKey()
  - getFirstUniqueKeyNode
```
public ConfigNode getFirstUniqueKeyNode()
```
  - hasNonPrimitiveTypeNodes
```
public boolean hasNonPrimitiveTypeNodes()
```
    Returns true if the node is not a primitive and has a type node. Returns false otherwise.
  - hasMappingNodes
```
public boolean hasMappingNodes()
```
    Returns true if the current node has at least one child node for which the type node qualifies as a mapping node. Returns false otherwise.
    
    See Also:
    
    isMappingNode(), getTypeNode()
  - hasChildrenWithTypeNode
```
public boolean hasChildrenWithTypeNode(ConfigNode typeNode)
```
    True if the node has at least one child node having the referenced type node
  - getFirstChildWithTypeNode
```
public ConfigNode getFirstChildWithTypeNode(ConfigNode typeNode)
```
    See Also:
    
    hasChildrenWithTypeNode(ConfigNode)
  - hasChildrenWithOtherTypeNode
```
public boolean hasChildrenWithOtherTypeNode(ConfigNode typeNode)
```
    True if the node has at least one child node which has a type node which is different than the given type node
  - getFirstChildWithOtherTypeNode
```
public ConfigNode getFirstChildWithOtherTypeNode(ConfigNode typeNode)
```
    See Also:
    
    hasChildrenWithOtherTypeNode(ConfigNode)
  - isMappingNode
```
public boolean isMappingNode()
```
    If a given node has exactly two children, both referencing other entities in the project, then the node is considered to be a mapping node.
  - isLastChild
```
public boolean isLastChild()
```
    True if the node has a parent node and is the last in the list of children of its parent node
  - isLeaf
```
public boolean isLeaf()
```
    Returns true if the node has a parent, but has no children. Returns false otherwise.
  - hasPrimitiveChildrenWithTypes
```
public boolean hasPrimitiveChildrenWithTypes(java.util.List<java.lang.String> typeNames)
```
    True if the node has at least one child node which has been identified as a primitive and for which the type name can be found within the provided list
  - hasPrimitiveChildrenWithTypes
```
public boolean hasPrimitiveChildrenWithTypes(java.util.List<java.lang.String> typeNames,
                                             java.lang.String dictionaryName)
```
    Similar to the hasPrimitiveChildrenWithTypes(List) method, only it uses the node's re-factored type name resulted from the re-factoring based on the named dictionary
    
    See Also:
    
    hasPrimitiveChildrenWithTypes(List), typnamesrefactoringconsumers
  - hasNonPrimitiveChildrenWithKeysOfTypes
```
public boolean hasNonPrimitiveChildrenWithKeysOfTypes(java.util.List<java.lang.String> typeNames)
```
    True if the node has at least one child node which is not a primitive and which has a type node which has at least one unique key which has the given type name
    
    Usually works in conjunction with hasPrimitiveChildrenWithTypes(List)
    
    See Also:
    
    hasChildrenWithTypesOrWithKeysOfTypes(List)
  - hasChildrenWithTypesOrWithKeysOfTypes
```
public boolean hasChildrenWithTypesOrWithKeysOfTypes(java.util.List<java.lang.String> typeNames)
```
    Returns true if the current node has at least one child with one of the given types or with a type node having the first unique key of the given type
    
    See Also:
    
    hasPrimitiveChildrenWithTypes(List), hasNonPrimitiveChildrenWithKeysOfTypes(List)
  - getPrimitiveChildrenWithTypes
```
public java.util.List<ConfigNode> getPrimitiveChildrenWithTypes(java.util.List<java.lang.String> typeNames)
```
    Compiles a list of primitive children having one of the given types
    
    See Also:
    
    hasPrimitiveChildrenWithTypes(List)
  - getNonPrimitiveChildren
```
public java.util.List<ConfigNode> getNonPrimitiveChildren()
```
    Returns a list of non-primitive children
    
    See Also:
    
    isPrimitive
  - getNonPrimitiveChildrenWithKeysOfTypes
```
public java.util.List<ConfigNode> getNonPrimitiveChildrenWithKeysOfTypes(java.util.List<java.lang.String> typeNames)
```
    Compiles a list of non-primitive children with type nodes for which the first unique key has one of the given types hasNonPrimitiveChildrenWithKeysOfTypes(List)
  - getChildrenWithTypesOrWithKeysOfTypes
```
public java.util.List<ConfigNode> getChildrenWithTypesOrWithKeysOfTypes(java.util.List<java.lang.String> typeNames)
```
    Compiles a list of children having one of the specified types or having type nodes with unique keys of the specified types, to be used for iteration within templates.
    
    See Also:
    
    #hasChildrenWithTypesOrWithKeysOfTypes(List)}, {@link #hasPrimitiveChildrenWithTypes(List)}, {@link #hasNonPrimitiveChildrenWithKeysOfTypes(List)}
  - equals
```
public boolean equals(java.lang.Object other)
```
    Overrides:
    
    equals in class java.lang.Object

Class ConfigNode

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ConfigNode

ConfigNode

Method Detail

getName

setName

getTypeName

setTypeName

getTypeNode

setTypeNode

getNumberOfIncomingReferences

setNumberOfIncomingReferences

getNumberOfOutgoingReferences

setNumberOfOutgoingReferences

isRegistryEntityCandidate

getNumberOfReferences

isOrphan

getRefactoredTypeNames

setRefactoredTypeNames

getParent

setParent

getChildren

setChildren

isPrimitive

setPrimitive

getPossibleValues

setPossibleValues

isCollection

setCollection

isPropertyGroup

setPropertyGroup

getRefactoredNames

setRefactoredNames

addChild

addPossibleValue

addRefactoredName

addRefactoredTypeName

hasChildren

countChildren

hasParent

hasCollections

isDimensionCandidate

isFactCandidate

isEnum

setEnum

isUniqueKey

setUniqueKey

getUniqueAttributeTypeNodes

setUniqueAttributeTypeNodes

addUniqueAttributeTypeNode

getSimilarChildGroups

setSimilarChildGroups

addSimilarChildGroup

hasSimilarChildGroups

getSimilarTypesChildGroups

setSimilarTypesChildGroups

addSimilarTypesChildGroup

hasSimilarTypesChildGroups

isSelfReference

setSelfReference

hasSelfReferences

hasUniqueKeyNodes

getFirstUniqueKeyNode

hasNonPrimitiveTypeNodes

hasMappingNodes

hasChildrenWithTypeNode

getFirstChildWithTypeNode

hasChildrenWithOtherTypeNode

getFirstChildWithOtherTypeNode

isMappingNode

isLastChild

isLeaf

hasPrimitiveChildrenWithTypes

hasPrimitiveChildrenWithTypes

hasNonPrimitiveChildrenWithKeysOfTypes

hasChildrenWithTypesOrWithKeysOfTypes