Grooper Node

STUB

This article is a stub. It contains minimal information on the topic and should be expanded.

Any single item in the Node Tree is a Grooper Node. Also simply referred to as a "node". 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.

There are six main nodes in the Node Tree. These nodes serve the purpose of organizing Grooper objects 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.

All new nodes you add in Grooper are created as a child of one of these nodes or one of their descendant nodes they contain.

For example Project nodes are added as children in the Projects folder at the root of the node tree.
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 nodes.

How do nodes create hierarchy in the Node Tree"

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.

What's the difference between a node and an object?

A "node" is something you add to the Node Tree. An "object" is the type of thing that node is.

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 object type. They are all Data Fields.

BE AWARE: The terms "node" and "object" are so similar many people use the terms interchangeably. You will probably even find occurrences in the Grooper Wiki where we refer to a "node" as an "object".

What is inheritance?

Parent and children nodes pass information to and from each other through "inheritance".

The parent node's object type dictates inheritance. It controls the object types for child nodes that can be created underneath it in the tree hierarchy, as well as what information is passed to and from the parent and child nodes.

The parent node will always determine what object types (if any) can be created as children.
- For example, a Data Model can only have Data Fields, Data Sections or Data Tables as its immediate children.
- However, Data Tables themselves can only have Data Columns as children.
The parent node may simply be a folder containing child objects.
- For example, a Content Model's Local Resources folder.
The parent node may have a more complex inheritance relationship.
- 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.