DataFlowAnalysis · Nicolas-Boltz · May 6, 2025 · Jan 20, 2025 · Jan 20, 2025 · Jan 27, 2025
diff --git a/...lysis.analysis.dfd/src/org/dataflowanalysis/analysis/dfd/core/DFDCharacteristicValue.java b/...lysis.analysis.dfd/src/org/dataflowanalysis/analysis/dfd/core/DFDCharacteristicValue.java
@@ -36,4 +36,9 @@ public String getValueId() {
     public Label getLabel() {
         return this.label;
     }
+
+    @Override
+    public String toString() {
+        return String.format("%s.%s", this.getTypeName(), this.getValueName());
+    }
 }
diff --git a/...g.dataflowanalysis.analysis.dfd/src/org/dataflowanalysis/analysis/dfd/core/DFDVertex.java b/...g.dataflowanalysis.analysis.dfd/src/org/dataflowanalysis/analysis/dfd/core/DFDVertex.java
@@ -203,7 +203,7 @@ private List<CharacteristicValue> getCharacteristicValuesForPin(Pin pin, Map<Pin
 
     /**
      * Combines all Incoming Labels from relevant input pins
-     * @param assignment Assignment to determine relevant input pins
+     * @param abstractAssignment Assignment to determine relevant input pins
      * @param inputPinsIncomingLabelMap Maps all input pins to all incoming labels
      * @return List of relevant labels
      */

diff --git a/...nalysis.dfd/src/org/dataflowanalysis/analysis/dfd/simple/DFDSimpleTransposeFlowGraph.java b/...nalysis.dfd/src/org/dataflowanalysis/analysis/dfd/simple/DFDSimpleTransposeFlowGraph.java
@@ -1,6 +1,5 @@
 package org.dataflowanalysis.analysis.dfd.simple;
 
-import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.Map;
 import org.dataflowanalysis.analysis.core.AbstractTransposeFlowGraph;
@@ -27,7 +26,6 @@ public DFDSimpleTransposeFlowGraph(AbstractVertex<?> sink) {
     @Override
     public AbstractTransposeFlowGraph evaluate() {
         DFDSimpleVertex newSink = ((DFDSimpleVertex) sink).copy(new IdentityHashMap<>());
-        newSink.unify(new HashSet<>());
         newSink.evaluateDataFlow();
         return new DFDSimpleTransposeFlowGraph(newSink);
     }
@@ -39,7 +37,6 @@ public AbstractTransposeFlowGraph copy() {
 
     public AbstractTransposeFlowGraph copy(Map<DFDSimpleVertex, DFDSimpleVertex> mapping) {
         DFDSimpleVertex copiedSink = ((DFDSimpleVertex) sink).copy(mapping);
-        copiedSink.unify(new HashSet<>());
         return new DFDSimpleTransposeFlowGraph(copiedSink);
     }
 }
diff --git a/...s.dfd/src/org/dataflowanalysis/analysis/dfd/simple/DFDSimpleTransposeFlowGraphFinder.java b/...s.dfd/src/org/dataflowanalysis/analysis/dfd/simple/DFDSimpleTransposeFlowGraphFinder.java
@@ -51,7 +51,6 @@ public List<? extends AbstractTransposeFlowGraph> findTransposeFlowGraphs(List<?
 
         for (Node endNode : getEndNodes(dataFlowDiagram.getNodes())) {
             DFDSimpleVertex sink = determineSinks(endNode);
-            sink.unify(new HashSet<>());
             transposeFlowGraphs.add(new DFDSimpleTransposeFlowGraph(sink));
         }
         return transposeFlowGraphs;
@@ -132,6 +131,9 @@ private boolean verifySimplicity(Node node) {
                         .anyMatch(it -> ((Assignment) it).getInputPins()
                                 .equals(node.getBehavior()
                                         .getInPin()))
+                || node.getBehavior()
+                    .getInPin()
+                    .size() == 0
                 || node.getBehavior()
                         .getOutPin()
                         .size() == 0;

diff --git a/...owanalysis.analysis.dfd/src/org/dataflowanalysis/analysis/dfd/simple/DFDSimpleVertex.java b/...owanalysis.analysis.dfd/src/org/dataflowanalysis/analysis/dfd/simple/DFDSimpleVertex.java
@@ -2,7 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -61,16 +61,13 @@ public void evaluateDataFlow() {
         if (super.isEvaluated()) {
             return;
         }
-
-        previousVertices.forEach(it -> it.evaluateDataFlow());
+        
+        previousVertices.forEach(DFDSimpleVertex::evaluateDataFlow);
 
         List<CharacteristicValue> vertexCharacteristics = determineNodeCharacteristics();
 
-        List<DataCharacteristic> incomingCharacteristics = previousVertices.stream()
-                .map(it -> it.getAllOutgoingDataCharacteristics())
-                .flatMap(List::stream)
-                .collect(Collectors.toList());
-
+        List<DataCharacteristic> incomingCharacteristics = previousVertices.stream().map(AbstractVertex::getAllOutgoingDataCharacteristics).flatMap(List::stream).collect(Collectors.toList());
+
         Map<Pin, Set<Label>> outgoingLabelPerPin = new HashMap<>();
         referencedElement.getBehavior()
                 .getAssignment()
@@ -95,7 +92,7 @@ private List<CharacteristicValue> determineNodeCharacteristics() {
 
     /**
      * Calculates outgoing labels for assignment and adds them into mapOutputPinToOutgoingLabels
-     * @param assignment Assignment to be evaluated
+     * @param abstractAssignment Assignment to be evaluated
      * @param incomingDataCharacteristics incoming characteristics as list
      * @param outgoingLabelPerPin Maps Output Pins to Outgoing Labels, to be filled by method
      */
@@ -129,10 +126,10 @@ private void handleOutgoingAssignments(AbstractAssignment abstractAssignment, Li
                 .collect(Collectors.toSet());
 
         var outPin = abstractAssignment.getOutputPin();
-        if (outPin == null)
+        if (outPin == null) {
             return;
-        if (outgoingLabelPerPin.get(outPin) == null)
-            outgoingLabelPerPin.put(outPin, new HashSet<>());
+        }
+        outgoingLabelPerPin.computeIfAbsent(outPin, k -> new LinkedHashSet<>());
 
         if (abstractAssignment instanceof ForwardingAssignment forwardingAssignment) {
             outgoingLabelPerPin.get(forwardingAssignment.getOutputPin())
@@ -178,12 +175,12 @@ private List<DataCharacteristic> createDataCharacteristicsFromLabels(Map<Pin, Se
      * @param pinToLabelMap Mapping of a pin to the assigned labels
      * @return Returns a list of characteristic values assigned to the given pin
      */
-    private Set<CharacteristicValue> getCharacteristicValuesForPin(Pin pin, Map<Pin, Set<Label>> pinToLabelMap) {
+    private List<CharacteristicValue> getCharacteristicValuesForPin(Pin pin, Map<Pin, Set<Label>> pinToLabelMap) {
         return pinToLabelMap.get(pin)
                 .stream()
                 .map(label -> new DFDCharacteristicValue((LabelType) label.eContainer(), label))
                 .filter(distinctByKey(CharacteristicValue::getValueId))
-                .collect(Collectors.toSet());
+                .collect(Collectors.toList());
     }
 
     /**
@@ -256,7 +253,7 @@ public void unify(Set<DFDSimpleVertex> vertices) {
      * Creates a clone of the vertex without considering data characteristics nor vertex characteristics
      */
     public DFDSimpleVertex copy(Map<DFDSimpleVertex, DFDSimpleVertex> mapping) {
-        Set<DFDSimpleVertex> previousVerticesNew = new HashSet<>();
+        Set<DFDSimpleVertex> previousVerticesNew = new LinkedHashSet<>();
         this.previousVertices.forEach(it -> {
             var newVertice = mapping.getOrDefault(it, it.copy(mapping));
             previousVerticesNew.add(newVertice);
@@ -276,6 +273,15 @@ public List<AbstractVertex<Node>> getPreviousElements() {
                 .map(it -> (AbstractVertex<Node>) it)
                 .toList();
     }
+
+    public boolean equalsSemantically(DFDSimpleVertex other) {
+    	if (this.equals(other)) return true;
+    	if (!this.mapPinToFlow.equals(other.getPinFlowMap())) return false;
+    	if (this.previousVertices.size() == 0 && other.previousVertices.size() == 0) return true;
+    	return this.previousVertices.stream().allMatch(previousVertex -> {
+    		return other.getPreviousElements().stream().map(DFDSimpleVertex.class::cast).anyMatch(it -> it.equalsSemantically(previousVertex));
+    	});
+    }
 
     /**
      * Returns the mapping between pins of the node and the connected input flows connecting the vertex to the previous

diff --git a/...owanalysis.analysis.pcm/src/org/dataflowanalysis/analysis/pcm/core/AbstractPCMVertex.java b/...owanalysis.analysis.pcm/src/org/dataflowanalysis/analysis/pcm/core/AbstractPCMVertex.java
@@ -179,6 +179,7 @@ public Deque<AssemblyContext> getContext() {
         return context;
     }
 
+
     /**
      * Determines whether a vertex is equivalent to another vertex in the context of the PCM model
      * <p/>

diff --git a/...lysis.analysis.pcm/src/org/dataflowanalysis/analysis/pcm/core/PCMCharacteristicValue.java b/...lysis.analysis.pcm/src/org/dataflowanalysis/analysis/pcm/core/PCMCharacteristicValue.java
@@ -4,7 +4,22 @@
 import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.EnumCharacteristicType;
 import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.Literal;
 
-public record PCMCharacteristicValue(EnumCharacteristicType characteristicType, Literal characteristicLiteral) implements CharacteristicValue {
+import java.util.Objects;
+
+public final class PCMCharacteristicValue implements CharacteristicValue {
+    private final EnumCharacteristicType characteristicType;
+    private final Literal characteristicLiteral;
+
+    public PCMCharacteristicValue(EnumCharacteristicType characteristicType, Literal characteristicLiteral) {
+        if (Objects.isNull(characteristicType) || Objects.isNull(characteristicType.getName()) ||  characteristicType.getName().isBlank()) {
+            throw new IllegalArgumentException("Characteristic type cannot be null or empty");
+        }
+        if (Objects.isNull(characteristicLiteral) || Objects.isNull(characteristicLiteral.getName()) ||  characteristicLiteral.getName().isBlank()) {
+            throw new IllegalArgumentException("Characteristic literal cannot be null or empty");
+        }
+        this.characteristicType = characteristicType;
+        this.characteristicLiteral = characteristicLiteral;
+    }
 
     @Override
     public String getTypeName() {
@@ -23,4 +38,32 @@ public String getValueId() {
         return this.characteristicLiteral()
                 .getId();
     }
+
+    @Override
+    public String toString() {
+        return String.format("%s.%s", this.getTypeName(), this.getValueName());
+    }
+
+    public EnumCharacteristicType characteristicType() {
+        return characteristicType;
+    }
+
+    public Literal characteristicLiteral() {
+        return characteristicLiteral;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || obj.getClass() != this.getClass()) return false;
+        var that = (PCMCharacteristicValue) obj;
+        return Objects.equals(this.characteristicType, that.characteristicType) &&
+                Objects.equals(this.characteristicLiteral, that.characteristicLiteral);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(characteristicType, characteristicLiteral);
+    }
+
 }
diff --git a/...ysis.pcm/src/org/dataflowanalysis/analysis/pcm/core/PCMDataCharacteristicsCalculator.java b/...ysis.pcm/src/org/dataflowanalysis/analysis/pcm/core/PCMDataCharacteristicsCalculator.java
@@ -14,6 +14,7 @@
 import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.Literal;
 import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.expressions.And;
 import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.expressions.False;
+import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.expressions.Not;
 import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.expressions.Or;
 import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.expressions.Term;
 import org.dataflowanalysis.pcm.extension.dictionary.characterized.DataDictionaryCharacterized.expressions.True;
@@ -50,7 +51,9 @@ public PCMDataCharacteristicsCalculator(List<DataCharacteristic> initialCharacte
      */
     private void createNodeCharacteristicsContainer(List<CharacteristicValue> vertexCharacteristics) {
         DataCharacteristic vertexCharacteristicsContainer = new DataCharacteristic("container");
-        vertexCharacteristics.forEach(vertexCharacteristicsContainer::addCharacteristic);
+        for (CharacteristicValue vertexCharacteristic : vertexCharacteristics) {
+            vertexCharacteristicsContainer = vertexCharacteristicsContainer.addCharacteristic(vertexCharacteristic);
+        }
         this.currentVariables.add(vertexCharacteristicsContainer);
     }
 
@@ -72,6 +75,9 @@ public void evaluate(ConfidentialityVariableCharacterisation variableCharacteris
 
         AbstractNamedReference reference = variableCharacterisation.getVariableUsage_VariableCharacterisation()
                 .getNamedReference__VariableUsage();
+        if (reference.getReferenceName().isBlank()) {
+            throw new IllegalArgumentException("Variable Name may not be null!");
+        }
         DataCharacteristic existingCharacteristic = this.getDataCharacteristicByReference(reference)
                 .orElse(new DataCharacteristic(reference.getReferenceName()));
 
@@ -178,6 +184,8 @@ private boolean evaluateTerm(Term term, CharacteristicValue characteristicValue)
             return evaluateTerm(andTerm.getLeft(), characteristicValue) && evaluateTerm(andTerm.getRight(), characteristicValue);
         } else if (term instanceof Or orTerm) {
             return evaluateTerm(orTerm.getLeft(), characteristicValue) || evaluateTerm(orTerm.getRight(), characteristicValue);
+        } else if(term instanceof Not notTerm) {
+            return !evaluateTerm(notTerm.getTerm(), characteristicValue);
         } else {
             throw new IllegalArgumentException("Unknown type: " + term.getClass()
                     .getName());
@@ -191,6 +199,9 @@ private boolean evaluateTerm(Term term, CharacteristicValue characteristicValue)
      * @return Returns, whether the characteristic reference evaluates to true or false (or is undefined)
      */
     private boolean evaluateNamedReference(NamedEnumCharacteristicReference characteristicReference, CharacteristicValue characteristicValue) {
+        if(characteristicReference.getNamedReference().getReferenceName().isBlank()) {
+            throw new IllegalArgumentException("Variable Name in right hand side of StoEx may not be blank!");
+        }
         var optionalDataCharacteristic = getDataCharacteristicByReference(characteristicReference.getNamedReference());
         if (optionalDataCharacteristic.isEmpty()) {
             return false;

diff --git a/...wanalysis.analysis.pcm/src/org/dataflowanalysis/analysis/pcm/core/user/UserPCMVertex.java b/...wanalysis.analysis.pcm/src/org/dataflowanalysis/analysis/pcm/core/user/UserPCMVertex.java
@@ -3,6 +3,7 @@
 import java.util.ArrayDeque;
 import java.util.List;
 import java.util.Map;
+
 import org.apache.log4j.Logger;
 import org.dataflowanalysis.analysis.core.CharacteristicValue;
 import org.dataflowanalysis.analysis.core.DataCharacteristic;

diff --git a/.../org.dataflowanalysis.analysis/src/org/dataflowanalysis/analysis/core/AbstractVertex.java b/.../org.dataflowanalysis.analysis/src/org/dataflowanalysis/analysis/core/AbstractVertex.java
@@ -1,9 +1,6 @@
 package org.dataflowanalysis.analysis.core;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 import java.util.stream.Collectors;
 import org.apache.log4j.Logger;
 
@@ -156,37 +153,6 @@ public List<String> getVertexCharacteristicNames(String requiredCharacteristicTy
                 .collect(Collectors.toList());
     }
 
-    /**
-     * Returns a list of data characteristics with the given name
-     * <p>
-     * See {@link AbstractVertex#getVertexCharacteristics(String)} for a similar method for vertex characteristics
-     * @param requiredDataCharacteristicName Name of the data characteristic
-     * @return Returns a list of all data characteristics with the given name
-     */
-    public List<DataCharacteristic> getDataCharacteristics(String requiredDataCharacteristicName) {
-        return this.getAllIncomingDataCharacteristics()
-                .stream()
-                .filter(it -> it.getVariableName()
-                        .equals(requiredDataCharacteristicName))
-                .collect(Collectors.toList());
-    }
-
-    /**
-     * Returns a list of data characteristic names with the given required data characteristic name
-     * <p>
-     * See {@link AbstractVertex#getVertexCharacteristicNames(String)} for a similar method for vertex characteristics
-     * @param requiredDataCharacteristicName Name of the data characteristic
-     * @return Returns a list of all data characteristics with the given name
-     */
-    public List<String> getDataCharacteristicNames(String requiredDataCharacteristicName) {
-        return this.getAllIncomingDataCharacteristics()
-                .stream()
-                .filter(it -> it.getVariableName()
-                        .equals(requiredDataCharacteristicName))
-                .map(DataCharacteristic::variableName)
-                .collect(Collectors.toList());
-    }
-
     /**
      * Returns a map containing the characteristic values with the given characteristic type for each data characteristic
      * <p>
@@ -242,7 +208,7 @@ public String createPrintableNodeInformation() {
      * @return a comma separated list of the format: "CharacteristicType.CharacteristicLiteral,
      * CharacteristicType.CharacteristicLiteral"
      */
-    public String createPrintableCharacteristicsList(List<CharacteristicValue> characteristics) {
+    private String createPrintableCharacteristicsList(List<CharacteristicValue> characteristics) {
         List<String> entries = characteristics.stream()
                 .map(it -> String.format("%s.%s", it.getTypeName(), it.getValueName()))
                 .toList();
-Original file line number
+Diff line change
@@ Expand Up / @@ -179,6 +179,7 @@ public Deque<AssemblyContext> getContext() { @@
             return context;
         }
         /**
          * Determines whether a vertex is equivalent to another vertex in the context of the PCM model
          * <p/>
@@ Expand Down @@