ProjectionIntegrityViolationDetectorInterface
interface ProjectionIntegrityViolationDetectorInterface (View source)
| internal |
interface because different impls.
Constants
| ERROR_CODE_ORPHANED_NON_ROOT_NODE |
|
| ERROR_CODE_AMBIGUOUS_NODE_AGGREGATE_IN_SUBGRAPH |
|
| ERROR_CODE_CHILD_NODE_COVERAGE_IS_NO_SUBSET_OF_PARENT_NODE_COVERAGE |
|
| ERROR_CODE_NODE_AGGREGATE_IS_AMBIGUOUSLY_TYPED |
|
| ERROR_CODE_NODE_AGGREGATE_IS_AMBIGUOUSLY_CLASSIFIED |
|
| ERROR_CODE_NODE_IS_DISCONNECTED_FROM_THE_ROOT |
|
| ERROR_CODE_NODE_DOES_NOT_COVER_ITS_ORIGIN |
|
| ERROR_CODE_NODE_HAS_MISSING_RESTRICTION |
|
| ERROR_CODE_RESTRICTION_INTEGRITY_IS_COMPROMISED |
|
| ERROR_CODE_HIERARCHY_INTEGRITY_IS_COMPROMISED |
|
| ERROR_CODE_SIBLINGS_ARE_AMBIGUOUSLY_SORTED |
|
| ERROR_CODE_REFERENCE_INTEGRITY_IS_COMPROMISED |
|
| ERROR_CODE_REFERENCES_ARE_AMBIGUOUSLY_SORTED |
|
| ERROR_CODE_TETHERED_NODE_IS_UNNAMED |
|
| ERROR_CODE_NODE_HAS_MULTIPLE_PARENTS |
|
Methods
Checks that the hierarchy edges are connected at source (e.g. to "A") and at destination (e.g. to "B")
Two children of the same parent are not allowed to have the same sorting
All tethered nodes must have named parent hierarchy relations
A is marked as hidden, so B and C should have incoming restriction edges.
Checks that the restriction edges are connected at source (e.g. to "A") and at destination (e.g. to "B")
Checks that the reference edges are connected at source (e.g. to "A") and at destination (e.g. to "B")
Checks that references originating at the same origin (and name) have different sortings.
Acyclicity check #1: Checks that per subgraph all nodes are connected to a root node.
Acyclicity check #2: Checks that per subgraph (Dimension Space Point + Content Stream), all nodes have exactly one parent (except root nodes which have none).
Checks that a node has incoming edges connected to a parent node
Checks that per subgraph (Dimension Space Point + Content Stream), a Node Aggregate id does not appear more than once.
Checks that per content stream (NOT per subgraph), a Node Aggregate has the same NodeType in all variants.
Checks that per content stream (NOT per subgraph), a Node Aggregate has the same classification in all variants.
Child nodes must not cover dimension space points that their parents don't.
All nodes must at least cover their origin dimension space point
Details
Result
hierarchyIntegrityIsProvided()
Checks that the hierarchy edges are connected at source (e.g. to "A") and at destination (e.g. to "B")
┌─────┐ │ A │ └─────┘<-- checks that A exists (for each hierarchy edge) │ │ ┌─────┐<-- checks that B exists (for each hierarchy edge) │ B │ └─────┘
Additionally, checks that e.g. dimensionSpacePoint and dimensionSpacePointHash match; and same for originDimensionSpacePoint and originDimensionSpacePointHash.
Additionally, checks that a hierarchy edge (identified by source node aggregate id, target node aggregate id, dimension space point and content stream id) exists at most once.
Result
siblingsAreDistinctlySorted()
Two children of the same parent are not allowed to have the same sorting
┌──────┐ │ PAR │ └──────┘ ╱ ╲ 10╱ ╲10 <--- same sorting value here ┌──▼──┐ ┌─────┐ │ A │ │ B │ └─────┘ └─────┘
Result
tetheredNodesAreNamed()
All tethered nodes must have named parent hierarchy relations
┌─────┐ │ A │ └─────┘ │ <-- T is a tethered node, so the hierarchy relation must be named │ ┌─────┐ │ T │ └─────┘
Result
restrictionsArePropagatedRecursively()
A is marked as hidden, so B and C should have incoming restriction edges.
This test should fail if e.g. in the example below, the restriction edge from A to C is missing.
┌─────┐ │ A │━━┓ └─────┘ ┃ │ ┃ │ ┃ ┌─────┐ ┃ │ B │◀━┛ └─────┘ ┃ │ │ ┃ <-- this Restriction Edge is missing. ┌─────┐ │ C │◀ ┛ └─────┘
Result
restrictionIntegrityIsProvided()
Checks that the restriction edges are connected at source (e.g. to "A") and at destination (e.g. to "B")
┌─────┐ │ A │━━┓ <-- checks that A exists (for each restriction edge) └─────┘ ┃ │ ┃ │ ┃ ┌─────┐ ┃ │ B │◀━┛ <-- checks that B exists (for each restriction edge) └─────┘
Result
referenceIntegrityIsProvided()
Checks that the reference edges are connected at source (e.g. to "A") and at destination (e.g. to "B")
This is violated if node aggregate B does not cover any DSPs that A does (or does not exist at all)
┌─────┐ │ A │━━┓ <-- checks that A exists (for each reference edge) └─────┘ ┃ │ ┃ │ ┃ ┌─────┐ ┃ │ B │◀━┛ <-- checks that B exists (for each reference edge) └─────┘
Result
referencesAreDistinctlySorted()
Checks that references originating at the same origin (and name) have different sortings.
In the example, we have reference edges between A->B, and A->C; both named "ref" with sorting 10 (this is an error!)
┌─────┐ ref - 10 ┌─────┐ │ A │───┬───────▶│ B │ └─────┘ └──┐ └─────┘ └──┐ ┌─────┐ └─▶│ C │ ref - 10 └─────┘ !!ERROR!!
Result
allNodesAreConnectedToARootNodePerSubgraph()
Acyclicity check #1: Checks that per subgraph all nodes are connected to a root node.
┌─────┐ │ A │◀─┐ <-- neither A nor B are root nodes └─────┘ │ │ │ ▼ │ ┌─────┐ │ │ B │──┘ └─────┘
Result
allNodesHaveAtMostOneParentPerSubgraph()
Acyclicity check #2: Checks that per subgraph (Dimension Space Point + Content Stream), all nodes have exactly one parent (except root nodes which have none).
╲ ╱ <-- these two edges are from the same subgraph. ╲ ╱ ┌─▼─▼─┐ │ A │ └─────┘
Result
nonRootNodesHaveParents()
Checks that a node has incoming edges connected to a parent node
───── <-- checks that the parent of "A" exists. │ ┌─────┐<-- checks that this edge exists (for each node) │ A │ └─────┘
Result
nodeAggregateIdsAreUniquePerSubgraph()
Checks that per subgraph (Dimension Space Point + Content Stream), a Node Aggregate id does not appear more than once.
╱ ╲ <-- these two edges are from the same subgraph. ╱ ╲ ┌──▼──┐ ┌──▼──┐ │ B │ │ B │ └─────┘ └─────┘
Result
nodeAggregatesAreConsistentlyTypedPerContentStream()
Checks that per content stream (NOT per subgraph), a Node Aggregate has the same NodeType in all variants.
╱ ╲ <-- these two edges are from the same CONTENT STREAM, ╱ ╲ but are of different Dimension Space Points. ┌──▼──┐ ┌──▼──┐ │ B:T1│ │ B:T2│ └─────┘ └─────┘ ^-----------^-------- B needs to have the same Node Type in this content stream.
Result
nodeAggregatesAreConsistentlyClassifiedPerContentStream()
Checks that per content stream (NOT per subgraph), a Node Aggregate has the same classification in all variants.
╱ ╲ <-- these two edges are from the same CONTENT STREAM, ╱ ╲ but are of different Dimension Space Points. ┌─────▼────┐ ┌─────▼─────┐ │ B:regular│ │ B:tethered│ └──────────┘ └───────────┘ ^-----------^-------- B needs to have a consistent classification in this content stream.
Result
childNodeCoverageIsASubsetOfParentNodeCoverage()
Child nodes must not cover dimension space points that their parents don't.
┌─────┐ │ A │ └─────┘ │ <-- between A and B, only "1 subgraph" relation exists. │ ┌─────┐ │ B │ └─────┘ │ ┃ <-- between B and C, two subgraphs exist (this cannot happen, as this must be smaller │ ┃ or equal than the parents. ┌─────┐ │ C │ └─────┘
Result
allNodesCoverTheirOrigin()
All nodes must at least cover their origin dimension space point
┃ <-- the covered dimension space point is different from the originating ┃ ┌─────┐ │ N │ └─────┘