replaced SystemEntitySet by simple HashMap

src/main/java/kieker/analysis/dev/DependencyCreator.java

 package kieker.analysis.dev;
 
 import kieker.analysis.domain.AggregatedOperationCall;
+import kieker.analysis.domain.systemdependency.Component;
+import kieker.analysis.domain.systemdependency.Container;
+import kieker.analysis.domain.systemdependency.Operation;
 import kieker.analysis.domain.systemdependency.SoftwareSystem;
 import kieker.analysis.trace.traversal.OperationCallVisitor;
 
@@ -15,32 +18,9 @@ public class DependencyCreator extends OperationCallVisitor<AggregatedOperationC
 	@Override
 	public void visit(final AggregatedOperationCall operationCall) {
 
-		// softwareSystem.getContainers().contains()
-
-		// SystemEntitySet<Container> containers = softwareSystem.getContainers();
-		// containers.add(new Container(operationCall.getContainer()));
-		// Container container = containers.getByName(operationCall.getContainer());
-		//
-		// Component component;
-		// if (container.getComponents().containsByName(operationCall.getComponent())) {
-		// component = new Component(operationCall.getComponent(), container);
-		// } else {
-		// container.getComponents().add(component); //TODO
-		// }
-		//
-
-		// ist container in software system?
-		// softwareSystem.getContainers().add(e)
-		// wenn nein -> hinzufügen
-		// getContainer
-
-		// ist component in container?
-		// wenn nein -> hinzufügen
-		// getComponent
-
-		// ist operation in component?
-		// wenn nein -> hinzufügen
-		// getOperation
+		Container calleeContainer = softwareSystem.addContainer(operationCall.getContainer());
+		Component calleeComponent = calleeContainer.addComponent(operationCall.getComponent());
+		Operation calleeOperation = calleeComponent.addOperation(operationCall.getOperation());
 
 		// Jetzt die Dependencies eintragen
 	}

src/main/java/kieker/analysis/dev/DependencyCreatorStage.java

 package kieker.analysis.dev;
 
 import kieker.analysis.domain.AggregatedTrace;
-import kieker.analysis.domain.OperationsDependency;
+import kieker.analysis.domain.systemdependency.SoftwareSystem;
+import kieker.analysis.trace.traversal.TraceTraverser;
 
 import teetime.stage.basic.AbstractTransformation;
 
-public class DependencyCreatorStage extends AbstractTransformation<AggregatedTrace, OperationsDependency> {
+public class DependencyCreatorStage extends AbstractTransformation<AggregatedTrace, SoftwareSystem> {
 
-	private final OperationsDependency operationsDependency = new OperationsDependency();
-	// private final DependencyCreator dependencyCreator = new DependencyCreator(operationsDependency);
+	private final SoftwareSystem softwareSystem = new SoftwareSystem();
+	private final DependencyCreator dependencyCreator = new DependencyCreator(softwareSystem);
 
 	@Override
 	protected void execute(final AggregatedTrace trace) {
-		// new TraceTraverser<>(dependencyCreator).traverse(trace);
+		new TraceTraverser<>(dependencyCreator).traverse(trace);
 	}
 
 	@Override
 	public void onTerminating() throws Exception { // NOPMD (the throws clause is forced by the framework)
 
-		this.getOutputPort().send(operationsDependency);
+		this.getOutputPort().send(softwareSystem);
 
 		super.onTerminating();
 	}

src/main/java/kieker/analysis/domain/systemdependency/Component.java

 package kieker.analysis.domain.systemdependency;
 
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
 public class Component extends SystemEntity {
 
 	private final Container container;
-	private final SystemEntitySet<Operation> operations = new SystemEntitySet<>();
+	private final Map<String, Operation> operations = new HashMap<>();
 
-	public Component(final String name, final Container container) {
+	protected Component(final String name, final Container container) {
 		super(name, container.getIdentifier() + ',' + name);
 		this.container = container;
-		container.getComponents().add(this);
 	}
 
 	public Container getContainer() {
 		return container;
 	}
 
-	public SystemEntitySet<Operation> getOperations() {
-		return operations;
+	public Collection<Operation> getOperations() {
+		return operations.values();
+	}
+
+	public Operation addOperation(final String name) {
+		if (this.operations.containsKey(name)) {
+			this.operations.put(name, new Operation(name, this));
+		}
+		return this.operations.get(name);
 	}
 
 }

src/main/java/kieker/analysis/domain/systemdependency/Container.java

 package kieker.analysis.domain.systemdependency;
 
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
 public class Container extends SystemEntity {
 
-	private final SystemEntitySet<Component> components = new SystemEntitySet<>();
+	private final Map<String, Component> components = new HashMap<>();
 
 	public Container(final String name) {
 		super(name, name);
 	}
 
-	public SystemEntitySet<Component> getComponents() {
-		return components;
+	public Collection<Component> getComponents() {
+		return components.values();
+	}
+
+	public Component addComponent(final String name) {
+		if (this.components.containsKey(name)) {
+			this.components.put(name, new Component(name, this));
+		}
+		return this.components.get(name);
 	}
 
 }

src/main/java/kieker/analysis/domain/systemdependency/Operation.java

@@ -4,10 +4,9 @@ public class Operation extends SystemEntity {
 
 	private final Component component;
 
-	public Operation(final String name, final Component component) {
+	protected Operation(final String name, final Component component) {
 		super(name, component.getIdentifier() + ',' + name);
 		this.component = component;
-		component.getOperations().add(this);
 	}
 
 	public Component getComponent() {

src/main/java/kieker/analysis/domain/systemdependency/SoftwareSystem.java

@@ -2,10 +2,12 @@ package kieker.analysis.domain.systemdependency;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
 
 public class SoftwareSystem {
 
-	private final SystemEntitySet<Container> containers = new SystemEntitySet<>();
+	private final Map<String, Container> containers = new HashMap<>();
 
 	private Collection<Dependency<Container>> containerDependencies = new ArrayList<>();
 	private Collection<Dependency<Component>> componentDependencies = new ArrayList<>();
@@ -13,8 +15,15 @@ public class SoftwareSystem {
 
 	public SoftwareSystem() {}
 
-	public SystemEntitySet<Container> getContainers() {
-		return containers;
+	public Collection<Container> getContainers() {
+		return containers.values();
+	}
+
+	public Container addContainer(final String name) {
+		if (this.containers.containsKey(name)) {
+			this.containers.put(name, new Container(name));
+		}
+		return this.containers.get(name);
 	}
 
 	public Collection<Dependency<Container>> getContainerDependencies() {