DataNode

java.lang.Object
- com.screenscraper.datamanager.DataNode

All Implemented Interfaces:

java.lang.Comparable
```
public class DataNode
extends java.lang.Object
implements java.lang.Comparable
```
A DataNode is a temporary storage unit for a chunk of related data. The data it holds is fairly equivalent to a single row of a database table or a node of an xml file. It also contains a AbstractSchema which describes how the data it holds is related to parent and child DataNodes.
For the most part you creation of DataNodes and insertion of data into them should be dealt with by the DataManager via the addData methods, but manual creation is also permitted. A manually created DataNode is added to the DataManager via the addDataNode method of the DataManager.

Constructor Summary

Constructors
Constructor and Description

DataNode(RelationalSchema templateSchema)
Generates a new node based on the schema.

Constructors
Constructor and Description
`DataNode(RelationalSchema templateSchema)` Generates a new node based on the schema.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abortWrite()`
`void`	`addChild(DataNode child)` adds a child to the node
`void`	`addData(java.util.Map<java.lang.String,?> candidateData)` Adds a map of data to the schema, if a key in the map matches up with a key in the node's schema it will store the data, otherwise it will ignore it
`void`	`addData(java.lang.String columnName, DataObject d)`
`void`	`addData(java.lang.String columnName, java.lang.Object value)` Same as other method which takes a Map, except that this one takes only a single name-value pair
`void`	`addParent(DataNode n)`
`void`	`clearData()`
`int`	`compareTo(java.lang.Object o)` This is used to compare DataNode by name/commit time so we can sort by the order they were created when they are in the tree.
`boolean`	`equals(java.lang.Object o)`
`CacheBlock`	`getCacheBlock()` Returns the CacheBlock for the object
`java.util.Set<DataNode>`	`getChildren()`
`java.util.SortedSet<DataNode>`	`getChildren(java.lang.String table)` returns all the descendants of the current node with the name table
`java.util.Set<java.lang.String>`	`getFieldsWritten()` Returns the FieldsWritten for the node.
`boolean`	`getInserted()` returns whether or not the DataNode was written to the database
`java.util.Map<java.lang.String,java.lang.Object>`	`getObjectMap()`
`java.util.Set<DataNode>`	`getParents()`
`RelationalSchema`	`getSchema()`
`DataObject`	`getValue(java.lang.String column)`
`java.util.Map<java.lang.String,DataObject>`	`getValues()`
`int`	`hashCode()`
`boolean`	`isAborted()` Returns if the node has been aborted
`boolean`	`isCommitted()`
`boolean`	`isMergeable()` returns whether the DataNode is mergeable
`boolean`	`isUpdateable()`
`boolean`	`isWriteChildrenOnAbort()` Returns whether or not the children should be written anyway if the node is aborted
`java.lang.String`	`matchCase(java.lang.String inputCase, RelationalSchema s)`
`void`	`removeChild(DataNode n)`
`void`	`removeData(java.lang.String columnName)` Removes a value from the node
`void`	`removeParent(DataNode n)`
`void`	`setCacheBlock(CacheBlock cacheBlock)` Sets the CacheBlock for the object
`void`	`setCommitted()`
`void`	`setFieldsWritten(java.util.Set<java.lang.String> fieldsWritten)` Sets the fields that were actually written for this node
`void`	`setInserted()` Sets that this DataNode has been inserted into the Database
`void`	`setMergeable()` Set the DataNode as being mergeable
`void`	`setUpdateable()` if the writer supports it this will update the values instead of rewriting them, for example on a database it will call an UPDATE on a write that returns a duplicate.
`java.lang.String`	`toString()`
`void`	`writeChildrenOnAbort()` Call this to indicate even if the write for this node is aborted, the children should still be written

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

- Constructor Detail
  - DataNode
```
public DataNode(RelationalSchema templateSchema)
```
    Generates a new node based on the schema. Fills in any empty data points with the AbstractSchema's declared 'defaultValue' attribute, if any.
    
    Parameters:
    
    templateSchema - AbstractSchema for which this DataNode instantiates
- Method Detail
  - getValues
```
@NotNull
public java.util.Map<java.lang.String,DataObject> getValues()
```
  - getChildren
```
@NotNull
public java.util.SortedSet<DataNode> getChildren(java.lang.String table)
```
    returns all the descendants of the current node with the name table
    
    Parameters:
    
    table -
    
    Returns:
    
    a set of DataNode containing children
  - getCacheBlock
```
@Nullable
public CacheBlock getCacheBlock()
```
    Returns the CacheBlock for the object
    
    Returns:
    
    The CacheBlock for the object
  - setCacheBlock
```
public void setCacheBlock(@Nullable
                          CacheBlock cacheBlock)
```
    Sets the CacheBlock for the object
    
    Parameters:
    
    cacheBlock - The new value for CacheBlock
  - setCommitted
```
public void setCommitted()
```
  - isCommitted
```
public boolean isCommitted()
```
  - getValue
```
@Nullable
public DataObject getValue(@NotNull
                                      java.lang.String column)
```
  - addChild
```
public void addChild(@NotNull
                     DataNode child)
```
    adds a child to the node
    
    Parameters:
    
    child -
  - addParent
```
public void addParent(@NotNull
                      DataNode n)
```
  - removeParent
```
public void removeParent(@NotNull
                         DataNode n)
```
  - removeChild
```
public void removeChild(@NotNull
                        DataNode n)
```
  - getParents
```
public java.util.Set<DataNode> getParents()
```
  - getChildren
```
public java.util.Set<DataNode> getChildren()
```
  - addData
```
public void addData(@Nullable
                    java.util.Map<java.lang.String,?> candidateData)
```
    Adds a map of data to the schema, if a key in the map matches up with a key in the node's schema it will store the data, otherwise it will ignore it
    
    Parameters:
    
    candidateData - Map containing name value pairs to try to add to the schema
  - addData
```
public void addData(@NotNull
                    java.lang.String columnName,
                    java.lang.Object value)
```
    Same as other method which takes a Map, except that this one takes only a single name-value pair
    
    Parameters:
    
    columnName - Candidate column name to be added to AbstractSchema's data
    
    value - Candidate value to be added
  - addData
```
public void addData(@NotNull
                    java.lang.String columnName,
                    DataObject d)
```
  - removeData
```
public void removeData(@NotNull
                       java.lang.String columnName)
```
    Removes a value from the node
    
    Parameters:
    
    columnName - The column for which to remove data
  - matchCase
```
@InternalOnly
public java.lang.String matchCase(@NotNull
                                                 java.lang.String inputCase,
                                                 @NotNull
                                                 RelationalSchema s)
```
  - clearData
```
public void clearData()
```
  - getSchema
```
@Nullable
public RelationalSchema getSchema()
```
  - toString
```
@NotNull
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - setUpdateable
```
public void setUpdateable()
```
    if the writer supports it this will update the values instead of rewriting them, for example on a database it will call an UPDATE on a write that returns a duplicate.
  - isUpdateable
```
public boolean isUpdateable()
```
    Returns:
    
    true if update is set for the DataNode
  - setMergeable
```
public void setMergeable()
```
    Set the DataNode as being mergeable
  - isMergeable
```
public boolean isMergeable()
```
    returns whether the DataNode is mergeable
    
    Returns:
    
    true if DataNode is mergable
  - setInserted
```
public void setInserted()
```
    Sets that this DataNode has been inserted into the Database
  - getInserted
```
public boolean getInserted()
```
    returns whether or not the DataNode was written to the database
    
    Returns:
    
    true if the DataNode was inserted
  - abortWrite
```
public void abortWrite()
```
  - writeChildrenOnAbort
```
public void writeChildrenOnAbort()
```
    Call this to indicate even if the write for this node is aborted, the children should still be written
  - isAborted
```
public boolean isAborted()
```
    Returns if the node has been aborted
    
    Returns:
    
    True iff the node has been aborted
  - isWriteChildrenOnAbort
```
public boolean isWriteChildrenOnAbort()
```
    Returns whether or not the children should be written anyway if the node is aborted
    
    Returns:
    
    True iff the children should be written even if the parent is aborted
  - getObjectMap
```
@NotNull
public java.util.Map<java.lang.String,java.lang.Object> getObjectMap()
```
  - compareTo
```
@InternalOnly
public int compareTo(@NotNull
                                    java.lang.Object o)
```
    This is used to compare DataNode by name/commit time so we can sort by the order they were created when they are in the tree. That way newer data will always overwrite old data.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable
    
    Parameters:
    
    o - The other object
    
    Returns:
    
    Ordering based on Schema name -> commitTime
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - setFieldsWritten
```
@InternalOnly
public void setFieldsWritten(@NotNull
                                            java.util.Set<java.lang.String> fieldsWritten)
```
    Sets the fields that were actually written for this node
    
    Parameters:
    
    fieldsWritten - The fields that were written (by name)
  - getFieldsWritten
```
@NotNull
public java.util.Set<java.lang.String> getFieldsWritten()
```
    Returns the FieldsWritten for the node. This is only what was modified/updated
    
    Returns:
    
    The FieldsWritten for the node. This is only what was modified/updated

Class DataNode

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DataNode

Method Detail

getValues

getChildren

getCacheBlock

setCacheBlock

setCommitted

isCommitted

getValue

addChild

addParent

removeParent

removeChild

getParents

getChildren

addData

addData

addData

removeData

matchCase

clearData

getSchema

toString

setUpdateable

isUpdateable

setMergeable

isMergeable

setInserted

getInserted

abortWrite

writeChildrenOnAbort

isAborted

isWriteChildrenOnAbort

getObjectMap

compareTo

hashCode

equals

setFieldsWritten

getFieldsWritten