Node Tree (UI Element)
|
⚠ |
This article was migrated from an older version and has not been updated for the current version of Grooper. This tag will be removed upon article review and update. |
|
This article is about the current version of Grooper. Note that some content may still need to be updated. | |
| 2025 | 2023.1 |
The Node Tree is the hierarchical list of Grooper node objects found in the left panel in the Design Page. It is the basis for navigation and creation in the Design Page.
Resources are created in Grooper by adding new "nodes" to the Node Tree. The Node Tree is called a "tree", because it "branches." Each new node added under another creates a new "branch", or a new level down from the node it is created. What node types can be added under a branch are determined by the node(s) above it.
How do I access the Node Tree?
The Node Tree is accessed from the Design page. More information on navigating the Node Tree and the Design page are found in the Design Page article.
Grooper Nodes
Any single item in the Node Tree is a Grooper Node (also simply referred to as a "node"). Each node has a "Node Type", which defines what that node is, how it is configured and used throughout the Grooper Repository. For example, a Batch is the "node type" that serves as the fundamental document container in Grooper.
Each new node creates a new branch under an existing one, creating the hierarchical structure of the tree.
|
FYI |
In Grooper, nodes and their properties are stored in the database connected to a Grooper Repository. |
How do nodes create hierarchy in the Node Tree?
At the top of the Grooper Repository is the Root node (aka the "Grooper Root").
Under the Root node, there are six main child nodes in the Node Tree. These nodes organize all Grooper nodes according to their node type to assist Node Tree navigation.
- Batches
- Projects
- Processes
- Queues
- File Stores
- Machines
Every Grooper Repository will contain these nodes and their contents, or "child" nodes.
- For example Project nodes are added as children in the "Projects" folder node.
- Content Model nodes are added as children of an individual Project node.
- Batches are nodes created and stored in either the Batches > Production or Batches > Test folder nodes.
When you create a new node, it is added as a "child" of another node. The node containing a child node is called its "parent"
- As nodes get added to other nodes, the node tree branches off into different levels.
- These different branches create the Node Tree's hierarchical structure.
Node Types
Node Types include any configuration object you can add to the Grooper Node Tree. This includes:
- Projects
- Batch Processes and Batch Process Steps
- Batches (and other Batch Objects)
- Content Models (and other Content Types)
- Data Types (and other Extractor Types)
- And more
A full list of Grooper Node Types can be found in the Node Types section of the Glossary article.
What's the difference between a node and an object?
An "object" is a very general computer programming term. It refers to self-contained entities that form the building blocks of modern programming.
A "node" is specific kind of object in Grooper. They are configuration objects added to the Node Tree. They let Grooper Design users configure settings and/or store data necessary for Grooper's document processing. What that node is and what it's for is defined by their "Node Type"
For Example: Here, there are three nodes named "Name" "DOB" and "SSN".
- These are individual nodes in the Node Tree.
- However they share the same Node Type. They are all Data Fields.
Nodes vs Embedded Objects
All nodes are objects, but not all objects are nodes. Objects are just re-usable chunks of code. "Embedded Objects" are configurable objects owned by another object. The exist as part of a larger configuration, such as a node's configuration. Embedded objects are encountered and configured when editing properties in a node's Property Grid.
Example 1:
- A Data Field is a node.
- Data Fields have a property named "Value Extractor". It can be configured in the Data Field's Property Grid.
- When you configure this property you select a Value Extractor (Pattern Match, List Match, Labeled Value etc.). These Value Extractors are embedded objects.
Example 2:
- A Document Type is a node.
- Document Types have a property named "Positive Extractor". It can be configured in the Document Type's Property Grid.
- When you configure this property you select a Value Extractor (Pattern Match, List Match, Labeled Value etc.). These Value Extractors are embedded objects.
Example 3:
- A Content Model is a node.
- Content Models have a property named "Classification Method". It can be configured in the Content Model's Property Grid.
- When you configure this property you select a Classify Method (Rules-Based, Lexical, Labelset-Based etc.). These Classify Methods are embedded objects.
Example 4:
- A Batch Process Step is a node.
- Batch Process Steps have a property named "Activity". It can be configured in the Batch Process Step's Property Grid.
- When you configure this property you select an Activity (Recognize, Extract, Review, etc.). These Activities are embedded objects.
BE AWARE: Because "object" is a very general term, many people use the terms "node" and "object" interchangeably (and, after all, a node is a type of object). You will probably even find occurrences in the Grooper Wiki where we refer to a "node" as an "object".
More on parents and children
Parent nodes determine many things for their children. The parent node's type dictates what its children can be. It controls what possible node types its child nodes can be. Parents and children will also pass information to each other in different ways, depending on their types.
The parent node will always determine what node types (if any) can be created as children.
- This may be more restrictive.
- For Example: A Data Model can only have Data Field, Data Section or Data Table nodes as its immediate children.
- Furthermore, Data Tables themselves can only have Data Columns as children.
- This may be more permissive when the parent node is more of a folder organizing child nodes.
- For Example: A Content Model's Local Resources folder or a Project node.
- Many different kinds of node types can be added to a Local Resources folder.
- Almost every node type can be added to a Project
The parent node's type also determines what information is passed to and from the parent and child nodes.
- For Example: A Content Model will pass its Export Behavior configuration to child Document Types. This way users don't have to configure Export Behavior settings to multiple Document Types using the same export logic.
- For Example: a Data Type's children Value Readers will pass all results they return to the parent Data Type. Those results will then be collated according to the Data Type's configuration
The Grooper Root
At the top of the Grooper Repository is the Root node (aka the "Grooper Root"). It contains all Grooper nodes as its children. It also stores several settings that apply to the connected Grooper Repository, including:
- The Active File Store location.
- Visit the Install and Setup article for more information on Grooper Repositories and File Stores.
- The License Serial# or URL configuration.
- Visit the License Activation article for more information about how to license your Grooper install.
- Any security settings stored in the the Permission Sets.
|
⚠ |
"Root node" is a common term in computer science. Be careful about commonly interchanged words.
|