Worked on #19

src/main/java/kieker/analysis/TraceAnalysisConfiguration.java

@@ -77,21 +77,26 @@ public class TraceAnalysisConfiguration extends Configuration {
 		GraphMLWriter graphMLWriter = new GraphMLWriter(graphFilesOutputDir);
 		DotGraphWriter dotGraphWriter = new DotGraphWriter(graphFilesOutputDir);
 
-		AggrTraceTraverserStage aggrTraceTraverser = new AggrTraceTraverserStage();
-		final Distributor<NamedGraph> graphDistributor2 = new Distributor<>(new CopyByReferenceStrategy());
-		GraphMLWriter graphMLWriter2 = new GraphMLWriter(graphFilesOutputDir);
-		DotGraphWriter dotGraphWriter2 = new DotGraphWriter(graphFilesOutputDir);
-
 		super.connectPorts(distributor.getNewOutputPort(), traceTraverserStage.getInputPort());
 		super.connectPorts(traceTraverserStage.getOutputPort(), graphDistributor.getInputPort());
 		super.connectPorts(graphDistributor.getNewOutputPort(), graphMLWriter.getInputPort());
 		super.connectPorts(graphDistributor.getNewOutputPort(), dotGraphWriter.getInputPort());
 
+		AggrTraceTraverserStage aggrTraceTraverser = new AggrTraceTraverserStage();
+		final Distributor<NamedGraph> graphDistributor2 = new Distributor<>(new CopyByReferenceStrategy());
+		GraphMLWriter graphMLWriter2 = new GraphMLWriter(graphFilesOutputDir);
+		DotGraphWriter dotGraphWriter2 = new DotGraphWriter(graphFilesOutputDir);
+
 		super.connectPorts(aggregation.getOutputPort(), aggrTraceTraverser.getInputPort());
 		super.connectPorts(aggrTraceTraverser.getOutputPort(), graphDistributor2.getInputPort());
 		super.connectPorts(graphDistributor2.getNewOutputPort(), graphMLWriter2.getInputPort());
 		super.connectPorts(graphDistributor2.getNewOutputPort(), dotGraphWriter2.getInputPort());
 
+		/*
+		 *
+		 *
+		 */
+
 		// TODO Temp Some examples for nested graphs
 
 		/*

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

+package kieker.analysis.dev;
+
+import kieker.analysis.trace.traversal.OperationCallVisitor;
+import kieker.analysis.traceanalysisdomain.AggregatedOperationCall;
+
+public class DependencyCreator extends OperationCallVisitor<AggregatedOperationCall> {
+
+	private final OperationsDependency operationsDependency;
+
+	public DependencyCreator(final OperationsDependency operationsDependency) {
+		this.operationsDependency = operationsDependency;
+	}
+
+	@Override
+	public void visit(final AggregatedOperationCall operationCall) {
+
+		operationsDependency.addCall(operationCall);
+
+	}
+
+	public OperationsDependency getOperationsDependency() {
+		return operationsDependency;
+	}
+
+}

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

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

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

+package kieker.analysis.dev;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import kieker.analysis.traceanalysisdomain.AggregatedOperationCall;
+
+public class OperationsDependency {
+
+	// TODO Move to Domain package
+
+	private final Map<String, List<AggregatedOperationCall>> operations = new HashMap<>();
+
+	private final Map<String, OperationsDependencyRelation> calls = new HashMap<>();
+
+	public void addCall(final AggregatedOperationCall call) {
+		// TODO
+		if (!operations.containsKey("Key")) {
+			operations.put("Key", new ArrayList<>());
+		}
+
+		operations.get("Key").add(call);
+
+		if (!calls.containsKey("Key")) {
+			calls.put("Key", new OperationsDependencyRelation(call.getParent(), call, call.getCalls()));
+		}
+
+		calls.get("Key").addToCalls(call.getCalls());
+
+	}
+
+	private class OperationsDependencyRelation {
+
+		private final AggregatedOperationCall caller;
+
+		private final AggregatedOperationCall callee;
+
+		private int calls;
+
+		public OperationsDependencyRelation(final AggregatedOperationCall caller, final AggregatedOperationCall callee, final int calls) {
+			this.caller = caller;
+			this.callee = callee;
+			this.calls = calls;
+		}
+
+		public void addToCalls(final int calls) {
+			this.calls += calls;
+		}
+
+		public AggregatedOperationCall getCaller() {
+			return caller;
+		}
+
+		public AggregatedOperationCall getCallee() {
+			return callee;
+		}
+
+		public int getCalls() {
+			return calls;
+		}
+	}
+}