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

undocumented

CLIParameter

undocumented

CopyLeft

undocumented

Wikipedia: Copyleft

Cygwin

Cygwin is a 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

undocumented

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

undocumented

Exception

undocumented

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.

Hardlink

undocumented

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.

Wikipedia: MinGW

Mixin-Class

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

MSYS2

undocumented

Wikipedia: 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

undocumented

Overloading

undocumented

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

undocumented

Pre-Order

undocumented

Program

undocumented

PyPI

undocumented

Wikipedia: Python Package Index

PyPy

undocumented

Wikipedia: 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