Clean up

Author: khatchad

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/CannotDetermineStreamOrderingException.java

@@ -27,6 +27,6 @@ public CannotDetermineStreamOrderingException(Throwable cause, Class<?> sourceTy
 	}
 
 	public Class<?> getSourceType() {
-		return sourceType;
+		return this.sourceType;
 	}
 }

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/CannotExtractSpliteratorException.java

@@ -28,6 +28,6 @@ public CannotExtractSpliteratorException(Throwable cause) {
 	}
 
 	public Class<? extends Object> getFromType() {
-		return fromType;
+		return this.fromType;
 	}
 }

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/NoninstantiableException.java

@@ -16,15 +16,15 @@ public NoninstantiableException(String string, Throwable cause, Class<?> sourceT
 	}
 
 	public Object getSourceType() {
-		return sourceType;
+		return this.sourceType;
 	}
 
 	@Override
 	public String toString() {
 		StringBuilder builder = new StringBuilder();
 		builder.append(super.toString() + ", ");
 		builder.append("NoninstantiablePossibleStreamSourceException [sourceType=");
-		builder.append(sourceType);
+		builder.append(this.sourceType);
 		builder.append("]");
 		return builder.toString();
 	}

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/OrderingInference.java

@@ -37,7 +37,7 @@ private Object createInstance(Class<?> clazz) throws NoninstantiableException {
 		try {
 			return clazz.newInstance();
 		} catch (InstantiationException | IllegalAccessException e) {
-			ObjectInstantiator<?> instantiator = objenesis.getInstantiatorOf(clazz);
+			ObjectInstantiator<?> instantiator = this.objenesis.getInstantiatorOf(clazz);
 			try {
 				return instantiator.newInstance();
 			} catch (InstantiationError e2) {
@@ -49,7 +49,7 @@ private Object createInstance(Class<?> clazz) throws NoninstantiableException {
 	private String findStreamCreationMethod(Collection<TypeAbstraction> types) {
 		// find the first one.
 		for (TypeAbstraction typeAbstraction : types) {
-			String methodName = findStreamCreationMethod(typeAbstraction);
+			String methodName = this.findStreamCreationMethod(typeAbstraction);
 
 			if (methodName != null)
 				return methodName;
@@ -73,11 +73,11 @@ private String findStreamCreationMethod(IClass type) {
 
 	private String findStreamCreationMethod(TypeAbstraction typeAbstraction) {
 		IClass type = typeAbstraction.getType();
-		return findStreamCreationMethod(type);
+		return this.findStreamCreationMethod(type);
 	}
 
 	protected IClassHierarchy getClassHierarchy() {
-		return classHierarchy;
+		return this.classHierarchy;
 	}
 
 	private Spliterator<?> getSpliterator(Object instance, String calledMethodName)
@@ -126,21 +126,21 @@ Ordering inferOrdering(Collection<TypeAbstraction> possibleTypes) throws Inconsi
 		if (possibleTypes.isEmpty())
 			return null;
 		else {
-			String methodName = findStreamCreationMethod(possibleTypes);
+			String methodName = this.findStreamCreationMethod(possibleTypes);
 
 			if (methodName == null) {
 				LOGGER.warning(() -> "Can't find stream creation method for: " + possibleTypes);
 				return null;
 			}
 
-			return inferOrdering(possibleTypes, methodName);
+			return this.inferOrdering(possibleTypes, methodName);
 		}
 	}
 
 	Ordering inferOrdering(Collection<TypeAbstraction> possibleTypes, IMethod calledMethod)
 			throws InconsistentPossibleOrderingException, NoniterableException, NoninstantiableException,
 			CannotExtractSpliteratorException {
-		return inferOrdering(possibleTypes, calledMethod.getElementName());
+		return this.inferOrdering(possibleTypes, calledMethod.getElementName());
 	}
 
 	private Ordering inferOrdering(Collection<TypeAbstraction> possibleTypes, String calledMethodName)
@@ -150,7 +150,7 @@ private Ordering inferOrdering(Collection<TypeAbstraction> possibleTypes, String
 
 		for (TypeAbstraction typeAbstraction : possibleTypes) {
 			if (typeAbstraction != TypeAbstraction.TOP) {
-				Ordering ordering = inferOrdering(typeAbstraction, calledMethodName);
+				Ordering ordering = this.inferOrdering(typeAbstraction, calledMethodName);
 
 				if (ret == null)
 					ret = ordering;
@@ -172,10 +172,10 @@ private Ordering inferOrdering(String className, String calledMethodName)
 
 			// is it instantiable?
 			if (!Util.isAbstractType(clazz)) {
-				Object instance = createInstance(clazz);
+				Object instance = this.createInstance(clazz);
 				boolean ordered;
 
-				Spliterator<?> spliterator = getSpliterator(instance, calledMethodName);
+				Spliterator<?> spliterator = this.getSpliterator(instance, calledMethodName);
 
 				if (spliterator == null) {
 					LOGGER.warning("Can't extract spliterator. Defaulting to: " + Ordering.ORDERED);
@@ -217,6 +217,6 @@ private Ordering inferOrdering(TypeAbstraction type, String calledMethodName)
 			return Ordering.ORDERED;
 
 		String binaryName = Util.getBinaryName(typeReference);
-		return inferOrdering(binaryName, calledMethodName);
+		return this.inferOrdering(binaryName, calledMethodName);
 	}
 }

edu.cuny.hunter.streamrefactoring.core/src/edu/cuny/hunter/streamrefactoring/core/analysis/PreconditionFailure.java

@@ -43,6 +43,6 @@ private PreconditionFailure(int code) {
 	}
 
 	public int getCode() {
-		return code;
+		return this.code;
 	}
 }