diff --git a/src/main/java/de/dhbwstuttgart/bytecode/genericsGenerator/GenericsGenerator.java b/src/main/java/de/dhbwstuttgart/bytecode/genericsGenerator/GenericsGenerator.java
index 1e8f9f6e..28c317ed 100644
--- a/src/main/java/de/dhbwstuttgart/bytecode/genericsGenerator/GenericsGenerator.java
+++ b/src/main/java/de/dhbwstuttgart/bytecode/genericsGenerator/GenericsGenerator.java
@@ -1,5 +1,5 @@
 /**
- * 
+ *
  */
 package de.dhbwstuttgart.bytecode.genericsGenerator;
 
@@ -29,186 +29,191 @@ import de.dhbwstuttgart.syntaxtree.Method;
  *
  */
 public class GenericsGenerator {
-	
-	public static GenericsGeneratorResultForClass generateConstraints(final String className, final TPHExtractor tphExtractor,
-			final List<String> tphsClass, final ConstraintsSimplierResult simplifiedConstraints) {
 
-		List<GenericsGeneratorResult> classConstraints = generateConstraintsForClass(tphExtractor,
-				simplifiedConstraints, tphsClass);
+    public static GenericsGeneratorResultForClass generateConstraints(final String className, final TPHExtractor tphExtractor,
+                                                                      final List<String> tphsClass, final ConstraintsSimplierResult simplifiedConstraints) {
+
+        List<GenericsGeneratorResult> classConstraints = generateConstraintsForClass(tphExtractor,
+                simplifiedConstraints, tphsClass);
 //		GenericGeneratorResultsForAllMethods methodsAndConstraints = generateConstraintsForAllMethods(tphExtractor,
 //				simplifiedConstraints, tphsClass);
-		GenericGeneratorResultsForAllMethods methodsAndConstraints = new GenericGeneratorResultsForAllMethods(new ArrayList<>());
-		
-		return new GenericsGeneratorResultForClass(className, classConstraints, methodsAndConstraints);
-	}
+        GenericGeneratorResultsForAllMethods methodsAndConstraints = new GenericGeneratorResultsForAllMethods(new ArrayList<>());
+
+        return new GenericsGeneratorResultForClass(className, classConstraints, methodsAndConstraints);
+    }
 
 
-	/**
-	 * @param tphExtractor
-	 * @param tphsClass
-	 * @return
-	 */
-	public static ConstraintsSimplierResult simplifyConstraints(final TPHExtractor tphExtractor,
-			final List<String> tphsClass) {
-		final List<GenericsGeneratorResult> genericsGeneratorResults = new ArrayList<>();
+    /**
+     * @param tphExtractor
+     * @param tphsClass
+     * @return
+     */
+    public static ConstraintsSimplierResult simplifyConstraints(final TPHExtractor tphExtractor,
+                                                                final List<String> tphsClass) {
+        final List<GenericsGeneratorResult> genericsGeneratorResults = new ArrayList<>();
 
-		ConstraintsSimplierResult simplifiedConstraints = ConstraintsSimplifier.simplifyConstraints(tphExtractor,
-				genericsGeneratorResults, tphsClass);
-		return simplifiedConstraints;
-	}
-	
+        ConstraintsSimplierResult simplifiedConstraints = ConstraintsSimplifier.simplifyConstraints(tphExtractor,
+                genericsGeneratorResults, tphsClass);
+        return simplifiedConstraints;
+    }
 
-	private static List<GenericsGeneratorResult> generateConstraintsForClass(final TPHExtractor tphExtractor,
-			final ConstraintsSimplierResult simplifiedConstraints, final List<String> tphsClass) {
-		final List<GenericsGeneratorResult> constraints = new ArrayList<>();
-		
-		if(tphsClass.isEmpty())
-			return constraints;
-		
-		final List<TPHConstraint> allCons = tphExtractor.allCons;
 
-		final Set<String> visitedTPHs = new HashSet<>();
+    private static List<GenericsGeneratorResult> generateConstraintsForClass(final TPHExtractor tphExtractor,
+                                                                             final ConstraintsSimplierResult simplifiedConstraints, final List<String> tphsClass) {
+        final List<GenericsGeneratorResult> constraints = new ArrayList<>();
 
-		final List<String> methodTPHs = tphExtractor.ListOfMethodsAndTph.stream().map(m -> m.getLocalTphs())
-				.flatMap(l -> l.stream()).collect(Collectors.toList());
-		for (String tph : tphsClass) {
+        if (tphsClass.isEmpty())
+            return constraints;
 
-			if (visitedTPHs.contains(tph))
-				continue;
+        final List<TPHConstraint> allCons = tphExtractor.allCons;
 
-			final LinkedList<String> tphsInRel = GenericsGeneratorUtility
-					.createLinkedListForTPHsInRelationClass(allCons, tphsClass, methodTPHs, visitedTPHs, tph);
-			if(!tphsInRel.isEmpty()) {
-				GenericsGeneratorResult constraint = generateGGResultForClass(tphsInRel, simplifiedConstraints, tphsClass);
-				constraints.add(constraint);
-			}
-		}
+        final Set<String> visitedTPHs = new HashSet<>();
 
-		GenericsGeneratorUtility.addTPHsToClassTPHs(constraints, tphsClass);
-		GenericsGeneratorUtility.removeClassTPHsFromMethodTPHs(tphsClass, tphExtractor);
+        final List<String> methodTPHs = tphExtractor.ListOfMethodsAndTph.stream().map(m -> m.getLocalTphs())
+                .flatMap(l -> l.stream()).collect(Collectors.toList());
 
-		generateGGConstraintsForTPH(tphsClass, constraints, simplifiedConstraints);
+        createConstraintsForClassTphs(simplifiedConstraints, tphsClass, constraints, allCons, visitedTPHs, methodTPHs);
 
-		return constraints;
-	}
+        GenericsGeneratorUtility.addTPHsToClassTPHs(constraints, tphsClass);
+        GenericsGeneratorUtility.removeClassTPHsFromMethodTPHs(tphsClass, tphExtractor);
 
-	private static GenericsGeneratorResult generateGGResultForClass(LinkedList<String> tphsInRel,
-			ConstraintsSimplierResult simplifiedConstraints, List<String> tphsClass) {
-		String subType = tphsInRel.getFirst();
+        generateGGConstraintsForTPH(tphsClass, constraints, simplifiedConstraints);
 
-		String superType = GenericsGeneratorUtility.getNextClassTph(tphsClass, tphsInRel);
+        return constraints;
+    }
 
-		TPHConstraint constraint = new ExtendsConstraint(subType, superType);
+    private static void createConstraintsForClassTphs(ConstraintsSimplierResult simplifiedConstraints, List<String> tphsClass, List<GenericsGeneratorResult> constraints, List<TPHConstraint> allCons, Set<String> visitedTPHs, List<String> methodTPHs) {
+        for (String tph : tphsClass) {
 
-		Set<String> equalSet = GenericsGeneratorUtility
-				.createEqualSet(simplifiedConstraints.getNameReplacementResults(), subType);
+            if (visitedTPHs.contains(tph))
+                continue;
 
-		return new GenericsGeneratorResult(constraint, equalSet);
-	}
+            final LinkedList<String> tphsInRel = GenericsGeneratorUtility
+                    .createLinkedListForTPHsInRelationClass(allCons, tphsClass, methodTPHs, visitedTPHs, tph);
+            if (!tphsInRel.isEmpty()) {
+                GenericsGeneratorResult constraint = generateGGResultForClass(tphsInRel, simplifiedConstraints, tphsClass);
+                constraints.add(constraint);
+            }
+        }
+    }
 
-	private static GenericGeneratorResultsForAllMethods generateConstraintsForAllMethods(
-			final TPHExtractor tphExtractor, ConstraintsSimplierResult simplifiedConstraints, List<String> tphsClass) {
+    private static GenericsGeneratorResult generateGGResultForClass(LinkedList<String> tphsInRel,
+                                                                    ConstraintsSimplierResult simplifiedConstraints, List<String> tphsClass) {
+        String subType = tphsInRel.getFirst();
 
-		final List<MethodAndConstraints> methodsAndConstraints = new ArrayList<>();
-		final GenericGeneratorResultsForAllMethods results = new GenericGeneratorResultsForAllMethods(
-				methodsAndConstraints);
-		tphExtractor.ListOfMethodsAndTph.forEach(m -> {
-			MethodAndConstraints methAndCons = generateConstraintsForMethod(tphExtractor.allCons, m,
-					simplifiedConstraints, tphsClass);
-			methodsAndConstraints.add(methAndCons);
-		});
+        String superType = GenericsGeneratorUtility.getNextClassTph(tphsClass, tphsInRel);
 
-		return results;
-	}
+        TPHConstraint constraint = new ExtendsConstraint(subType, superType);
 
-	public static MethodAndConstraints generateConstraintsForMethod(final List<TPHConstraint> allCons,
-			final MethodAndTPH m, final ConstraintsSimplierResult simplifiedConstraints, List<String> tphsClass) {
-		final List<String> localTphs = m.getLocalTphs();
-		
-		List<GenericsGeneratorResult> constraints = new ArrayList<>();
-		MethodAndConstraints result = new MethodAndConstraints(m.getId(), constraints);
-		
-		if(localTphs.isEmpty())
-			return result;
-		
-		if(localTphs.size() == 1 && tphsClass.isEmpty()) {
-			generateGGConstraintsForTPH(localTphs, constraints, simplifiedConstraints);
-			return result;
-		}
-		
-		final Set<String> visitedTPHs = new HashSet<>();
-		
-		for (String tph : localTphs) {
+        Set<String> equalSet = GenericsGeneratorUtility
+                .createEqualSet(simplifiedConstraints.getNameReplacementResults(), subType);
 
-			if (visitedTPHs.contains(tph))
-				continue;
+        return new GenericsGeneratorResult(constraint, equalSet);
+    }
 
-			final LinkedList<String> tphsInRel = GenericsGeneratorUtility.createLinkedListForTPHsInRelation(allCons,
-					localTphs, tphsClass, visitedTPHs, tph);
-			if(!tphsInRel.isEmpty()) {
-				GenericsGeneratorUtility.removeNotLocalTphs(tphsInRel, localTphs, tphsClass);
-				if(!GenericsGeneratorUtility.isInResult(tphsInRel.getFirst(),constraints)) {
-					GenericsGeneratorResult constraint = generateGGResult(tphsInRel, simplifiedConstraints);
-					constraints.add(constraint);
-				}
-			}
-		}
+    private static GenericGeneratorResultsForAllMethods generateConstraintsForAllMethods(
+            final TPHExtractor tphExtractor, ConstraintsSimplierResult simplifiedConstraints, List<String> tphsClass) {
 
-		generateGGConstraintsForTPH(localTphs, constraints, simplifiedConstraints);
-		return result;
-	}
+        final List<MethodAndConstraints> methodsAndConstraints = new ArrayList<>();
+        final GenericGeneratorResultsForAllMethods results = new GenericGeneratorResultsForAllMethods(
+                methodsAndConstraints);
+        tphExtractor.ListOfMethodsAndTph.forEach(m -> {
+            MethodAndConstraints methAndCons = generateConstraintsForMethod(tphExtractor.allCons, m,
+                    simplifiedConstraints, tphsClass);
+            methodsAndConstraints.add(methAndCons);
+        });
 
-	private static void generateGGConstraintsForTPH(List<String> localTphs,
-			final List<GenericsGeneratorResult> constraints, final ConstraintsSimplierResult simplifiedConstraints) {
+        return results;
+    }
 
-		localTphs.forEach(tph -> {
-			boolean isInSimplifiedConstraints = GenericsGeneratorUtility.isTPHInGenericGeneratorResult(simplifiedConstraints.getGenericsGenResults(), tph);
-			if(isInSimplifiedConstraints) {
-				GenericsGeneratorResult ggResult = GenericsGeneratorUtility.getGenericGeneratorResult(simplifiedConstraints.getGenericsGenResults(),tph).get();
+    public static MethodAndConstraints generateConstraintsForMethod(final List<TPHConstraint> allCons,
+                                                                    final MethodAndTPH m, final ConstraintsSimplierResult simplifiedConstraints, List<String> tphsClass) {
+        final List<String> localTphs = m.getLocalTphs();
+
+        List<GenericsGeneratorResult> constraints = new ArrayList<>();
+        MethodAndConstraints result = new MethodAndConstraints(m.getId(), constraints);
+
+        if (localTphs.isEmpty())
+            return result;
+
+        if (localTphs.size() == 1 && tphsClass.isEmpty()) {
+            generateGGConstraintsForTPH(localTphs, constraints, simplifiedConstraints);
+            return result;
+        }
+
+        final Set<String> visitedTPHs = new HashSet<>();
+
+        for (String tph : localTphs) {
+
+            if (visitedTPHs.contains(tph))
+                continue;
+
+            final LinkedList<String> tphsInRel = GenericsGeneratorUtility.createLinkedListForTPHsInRelation(allCons,
+                    localTphs, tphsClass, visitedTPHs, tph);
+            if (!tphsInRel.isEmpty()) {
+                GenericsGeneratorUtility.removeNotLocalTphs(tphsInRel, localTphs, tphsClass);
+                if (!GenericsGeneratorUtility.isInResult(tphsInRel.getFirst(), constraints)) {
+                    GenericsGeneratorResult constraint = generateGGResult(tphsInRel, simplifiedConstraints);
+                    constraints.add(constraint);
+                }
+            }
+        }
+
+        generateGGConstraintsForTPH(localTphs, constraints, simplifiedConstraints);
+        return result;
+    }
+
+    private static void generateGGConstraintsForTPH(List<String> localTphs,
+                                                    final List<GenericsGeneratorResult> constraints, final ConstraintsSimplierResult simplifiedConstraints) {
+
+        localTphs.forEach(tph -> {
+            boolean isInSimplifiedConstraints = GenericsGeneratorUtility.isTPHInGenericGeneratorResult(simplifiedConstraints.getGenericsGenResults(), tph);
+            if (isInSimplifiedConstraints) {
+                GenericsGeneratorResult ggResult = GenericsGeneratorUtility.getGenericGeneratorResult(simplifiedConstraints.getGenericsGenResults(), tph).get();
 //				GenericsGeneratorUtility.removeGenericGeneratorResult(simplifiedConstraints.getGenericsGenResults(),ggResult);
-				constraints.add(ggResult);
-			} else {
-				boolean isInConstraints = GenericsGeneratorUtility.isTPHInGenericGeneratorResult(constraints, tph);
-				
-				if (!isInConstraints) {
-					GenericsGeneratorResult ggResult = generateGGResult(tph, simplifiedConstraints.getNameReplacementResults());
-					constraints.add(ggResult);
-				}
-			}
-		});
+                constraints.add(ggResult);
+            } else {
+                boolean isInConstraints = GenericsGeneratorUtility.isTPHInGenericGeneratorResult(constraints, tph);
 
-	}
+                if (!isInConstraints) {
+                    GenericsGeneratorResult ggResult = generateGGResult(tph, simplifiedConstraints.getNameReplacementResults());
+                    constraints.add(ggResult);
+                }
+            }
+        });
 
-	private static GenericsGeneratorResult generateGGResult(String tph,
-			List<NameReplacementResult> nameReplacementResults) {
-		String superType = Type.getInternalName(Object.class);
-		TPHConstraint constraint = new ExtendsConstraint(tph, superType);
-		Set<String> equalSet = GenericsGeneratorUtility.createEqualSet(nameReplacementResults, tph);
+    }
 
-		return new GenericsGeneratorResult(constraint, equalSet);
-	}
+    private static GenericsGeneratorResult generateGGResult(String tph,
+                                                            List<NameReplacementResult> nameReplacementResults) {
+        String superType = Type.getInternalName(Object.class);
+        TPHConstraint constraint = new ExtendsConstraint(tph, superType);
+        Set<String> equalSet = GenericsGeneratorUtility.createEqualSet(nameReplacementResults, tph);
 
-	private static GenericsGeneratorResult generateGGResult(final LinkedList<String> tphsInRel,
-			final ConstraintsSimplierResult simplifiedConstraints) {
+        return new GenericsGeneratorResult(constraint, equalSet);
+    }
 
-		String subType = tphsInRel.getFirst();
+    private static GenericsGeneratorResult generateGGResult(final LinkedList<String> tphsInRel,
+                                                            final ConstraintsSimplierResult simplifiedConstraints) {
 
-		if (tphsInRel.size() == 1) {
-			Optional<GenericsGeneratorResult> constraintFromSimplifiedCon = simplifiedConstraints
-					.getGenericsGenResults().stream().filter(g -> g.getConstraint().getLeft().equals(subType))
-					.findFirst();
-			if (constraintFromSimplifiedCon.isPresent())
-				return constraintFromSimplifiedCon.get();
-		}
+        String subType = tphsInRel.getFirst();
 
-		String superType = tphsInRel.size() > 1 ? tphsInRel.getLast() : Type.getInternalName(Object.class);
+        if (tphsInRel.size() == 1) {
+            Optional<GenericsGeneratorResult> constraintFromSimplifiedCon = simplifiedConstraints
+                    .getGenericsGenResults().stream().filter(g -> g.getConstraint().getLeft().equals(subType))
+                    .findFirst();
+            if (constraintFromSimplifiedCon.isPresent())
+                return constraintFromSimplifiedCon.get();
+        }
 
-		TPHConstraint constraint = new ExtendsConstraint(subType, superType);
+        String superType = tphsInRel.size() > 1 ? tphsInRel.getLast() : Type.getInternalName(Object.class);
 
-		Set<String> equalSet = GenericsGeneratorUtility
-				.createEqualSet(simplifiedConstraints.getNameReplacementResults(), subType);
+        TPHConstraint constraint = new ExtendsConstraint(subType, superType);
 
-		return new GenericsGeneratorResult(constraint, equalSet);
-	}
+        Set<String> equalSet = GenericsGeneratorUtility
+                .createEqualSet(simplifiedConstraints.getNameReplacementResults(), subType);
+
+        return new GenericsGeneratorResult(constraint, equalSet);
+    }
 
 }