Glossary

Abstract Class

A abstract class is a type, that cannot be instantiated directly. An abstract class may provide no implementation or an incomplete implementation.

In pyTooling such a type is assumed, when a class contains at least one abstract or mustoverride method and pyToolings meta-class ExtendedType was applied.

If an abstract class is instantiated, an exception is raised.

Abstract Method

An abstract method provides no implementation (no code) and must therefore be implemented by all derived classes.

If an abstract method is called, an exception is raised. Also if, an abstract method is not overridden, an exception is raised when instantiating the class, because the class is abstract.

Ancestor

Ancestors are all direct and indirect predecessors of a node (parent node and parent nodes thereof a.k.a. grandparents, grand-grandparent, …, root node).

In a tree, a node has only a single parent per node, thus a list of ancestors is a direct line from current node to the root node.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R:::mark1 --> A
  A:::mark2 --> BL & B & BR
  B:::mark2 --> CL & C & CR
  C:::mark2 --> DL & D & DR
  DL --> ELN1 & ELN2
  D:::cur --> EL & E & ER
  DR --> ERN1 & ERN2
  E --> F1 & F2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6,font-size:smaller;
  classDef mark1 fill:#69f,stroke:#37f,color:#eee,font-size:smaller;
  classDef mark2 fill:#69f,stroke:#37f,font-size:smaller;
    

Ancestors of the current node are marked in blue.

Base-Class

A base-class is an ancestor class for other classes derived therefrom.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  B(BaseClass)
  C(Class)
  I1(Instance);I2(Instance)

  B:::mark1 --> C:::mark2 -..-> I1 & I2

  classDef node font-size:smaller;
  classDef mark1 fill:#69f,stroke:#37f,color:#eee,font-size:smaller;
  classDef mark2 fill:#69f,stroke:#37f,font-size:smaller;
    

Base-class in a class hierarchy.

Child

Children are all direct successors of a node.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R --> A
  A --> BL & B & BR
  B --> CL & C & CR
  C --> DL & D & DR
  DL --> ELN1 & ELN2
  D:::cur --> EL & E & ER
  EL:::mark2
  E:::mark2
  ER:::mark2
  DR --> ERN1 & ERN2
  E --> F1 & F2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6;
  classDef mark2 fill:#69f,stroke:#37f;
    

Children of the current node are marked in blue.

CLIOption

…

CLIParameter

…

CopyLeft

…

Cygwin

https://en.wikipedia.org/wiki/Cygwin is a https://en.wikipedia.org/wiki/POSIX-compatible programming and runtime environment for Windows.

DAG

A directed acyclic graph (DAG) is a directed graph without backward edges and therefore free of cycles.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph LR
  A(A); B(B); C(C); D(D); E(E); F(F); G(G); H(H); I(I); J(J); K(K)

  A --> B & C & D
  B --> E & F
  C --> E & G
  D --> G & F
  E --> H
  F --> H & I
  G --> I
  H --> J & K
  I --> K & J

  classDef node fill:#eee,stroke:#777,font-size:smaller;
    

A directed acyclic graph.

DG

A directed graph (DG) is a graph where all edges have a direction.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph LR
  A(A); B(B); C(C); D(D); E(E); F(F) ; G(G); H(H); I(I)

  A -.-> B -.-> E
  G --> F
  A --> C --> G --> H --> D
  D -.-> A
  D & F --> B
  I ---> E -.-> F -.-> D

  classDef node fill:#eee,stroke:#777,font-size:smaller;
    

A directed graph with cycles (one cycle is denoted by dotted edges).

Decorator

…

Descendant

Descendants are all direct and indirect successors of a node (child nodes and child nodes thereof a.k.a. grandchild, grand-grandchildren, …).

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R --> A
  A --> BL & B & BR
  B --> CL & C & CR
  C --> DL & D & DR
  DL --> ELN1 & ELN2
  D:::cur --> EL & E & ER
  EL:::mark2
  E:::mark2
  ER:::mark2
  DR --> ERN1 & ERN2
  E --> F1 & F2
  F1:::mark2
  F2:::mark2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6;
  classDef mark2 fill:#69f,stroke:#37f;
    

Descendants of the current node are marked in blue.

Edge

An edge is a relation from vertex to vertex in a graph.

Executable

…

Exception

…

Graph

A graph is a data structure made of vertices (nodes) and vertex-vertex relations called edges.

Special forms of graphs are:

• Graphs with directions: Directed Graph

• Directed Graphs without Cycles: Directed Acyclic Graph

• Directed Acyclic Graph without Side-Edges: Tree

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph LR
  A(A); B(B); C(C); D(D); E(E); F(F) ; G(G); H(H); I(I)

  A --> B --> E
  G --> F
  A --> C --> G --> H --> D
  D -.-> A
  D & F -.-> B
  I ---> E --> F --> D

  classDef node fill:#eee,stroke:#777,font-size:smaller;
    

A directed graph with backward-edges denoted by dotted vertex relations.

Grandchild

Grandchildren are direct successors of a node’s children and therefore indirect successors of a term:node.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R --> A
  A --> BL & B & BR
  B --> CL & C & CR
  C --> DL & D & DR
  DL --> ELN1 & ELN2
  D:::cur --> EL & E & ER
  DR --> ERN1 & ERN2
  E --> F1 & F2
  F1:::mark2
  F2:::mark2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6;
  classDef mark2 fill:#69f,stroke:#37f;
    

Grandchildren of the current node are marked in blue.

Grandparent

A grandparent is direct predecessor of a node’s parent and therefore indirect predecessor of a node.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R --> A
  A --> BL & B & BR
  B:::mark2 --> CL & C & CR
  C --> DL & D & DR
  DL --> ELN1 & ELN2
  D:::cur --> EL & E & ER
  DR --> ERN1 & ERN2
  E --> F1 & F2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6;
  classDef mark2 fill:#69f,stroke:#37f;
    

Grandparent of the current node are marked in blue.

Meta-Class

A meta-class is a class helping to construct classes. Thus, it’s the type of a type.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  T(type)
  ET(MetaClass)
  B(BaseClass)
  M(MixIn)
  C(Class)
  I1(Instance);I2(Instance)

  T --> T
  T:::mark1 --> ET:::mark1 -.class definition.-> B
  B:::mark2 --inheritance--> C:::mark2 -.instantiation..-> I1 & I2
  M --inheritance--> C

  classDef node font-size:smaller;
  classDef mark1 fill:#69f,stroke:#37f,color:#eee,font-size:smaller;
  classDef mark2 fill:#69f,stroke:#37f,font-size:smaller;
    

Relation of meta-classes, classes and instances.

MinGW

Minimalistic GNU for Windows.

Mixin-Class

A mixin classes are classes used as secondary base-classes in multiple inheritance.

MSYS2

…

Mustoverride Method

A must-override method provides a partial implementation (incomplete code) and must therefore be fully implemented by all derived classes.

If a must-override method is not overridden, an exception is raised when instantiating the class, because the class is abstract.

native

A native environment is a platform just with the operating system. There is no additional environment layer like MSYS2.

Node

…

Overloading

…

Parent

A parent is direct predecessor of a node.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R --> A
  A --> BL & B & BR
  B --> CL & C & CR
  C:::mark2 --> DL & D & DR
  DL --> ELN1 & ELN2
  D:::cur --> EL & E & ER
  DR --> ERN1 & ERN2
  E --> F1 & F2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6;
  classDef mark2 fill:#69f,stroke:#37f;
    

Parent of the current node are marked in blue.

Post-Order

…

Pre-Order

…

Program

…

PyPI

…

PyPy

…

Relative

Relatives are siblings and their descendants.

Left relatives are left siblings and all their descendants, whereas right relatives are right siblings and all their descendants.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R --> A
  A --> BL & B & BR
  B --> CL & C & CR
  C --> DL & D & DR
  DL:::mark2 --> ELN1 & ELN2
  ELN1:::mark2
  ELN2:::mark2
  D:::cur --> EL & E & ER
  DR:::mark2 --> ERN1 & ERN2
  ERN1:::mark2
  ERN2:::mark2
  E --> F1 & F2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6;
  classDef mark2 fill:#69f,stroke:#37f;
    

Relatives of the current node are marked in blue.

Root

All nodes in a tree have one common ancestor called root.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R:::mark1 --> A
  A --> BL & B & BR
  B --> CL & C & CR
  C --> DL & D & DR
  DL --> ELN1 & ELN2
  D:::cur --> EL & E & ER
  DR --> ERN1 & ERN2
  E --> F1 & F2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6;
  classDef mark1 fill:#69f,stroke:#37f,color:#eee;
    

Root of the current node are marked in blue.

Sibling

Siblings are all direct child nodes of a node’s parent node except itself.

        %%{init: { "flowchart": { "nodeSpacing": 15, "rankSpacing": 30, "curve": "linear", "useMaxWidth": false } } }%%
graph TD
  R(Root)
  A(...)
  BL(Node); B(GrandParent); BR(Node)
  CL(Uncle); C(Parent); CR(Aunt)
  DL(Sibling); D(Node);  DR(Sibling)
  ELN1(Niece); ELN2(Nephew)
  EL(Child);   E(Child); ER(Child);
  ERN1(Niece);ERN2(Nephew)
  F1(GrandChild); F2(GrandChild)

  R --> A
  A --> BL & B & BR
  B --> CL & C & CR
  C --> DL & D & DR
  DL:::mark2 --> ELN1 & ELN2
  D:::cur --> EL & E & ER
  DR:::mark2 --> ERN1 & ERN2
  E --> F1 & F2

  classDef node fill:#eee,stroke:#777,font-size:smaller;
  classDef cur fill:#9e9,stroke:#6e6;
  classDef mark2 fill:#69f,stroke:#37f;
    

Siblings of the current node are marked in blue.

Singleton

The singleton design pattern ensures only a single instance of a class to exist. If another instance is going to be created, a previously cached instance of that class will be returned.

Slots

…

Tree

A tree is a data structure made of nodes and parent-child relations. All nodes in a tree share one common ancestor call root.

A tree is a special form of a directed acyclic graph (DAG).

UCRT

Universal C Runtime

URI

Uniform Resource Identifier

URL

Uniform Resource Locator

URN

Uniform Resource Name

Vertex

A vertex is a node in a graph. Vertexes in a graph are connected using edges.

WSL

Windows System for Linux