private void deleteRemovedOperation(UMLOperation operation) { UMLClassBaseDiff classDiff = getUMLClassDiff(operation.getClassName()); if(classDiff != null) classDiff.getRemovedOperations().remove(operation); }
UMLAttribute a2 = diff1.findAttributeInNextClass(pattern.getAfter()); if(candidate.getOriginalVariableDeclaration().isAttribute()) { UMLClassBaseDiff originalClassDiff = getUMLClassDiff(candidate.getOriginalAttribute().getClassName()); if(originalClassDiff != null && originalClassDiff.removedAttributes.contains(candidate.getOriginalAttribute())) { ReplaceAttributeRefactoring ref = new ReplaceAttributeRefactoring(candidate.getOriginalAttribute(), a2, set); UMLAttribute a2 = diff2.findAttributeInNextClass(pattern.getAfter()); if(candidate.getOriginalVariableDeclaration().isAttribute()) { UMLClassBaseDiff originalClassDiff = getUMLClassDiff(candidate.getOriginalAttribute().getClassName()); if(originalClassDiff != null && originalClassDiff.removedAttributes.contains(candidate.getOriginalAttribute())) { MoveAndRenameAttributeRefactoring ref = new MoveAndRenameAttributeRefactoring(candidate.getOriginalAttribute(), a2, set);
private void deleteAddedOperation(UMLOperation operation) { UMLClassBaseDiff classDiff = getUMLClassDiff(operation.getClassName()); if(classDiff != null) classDiff.getAddedOperations().remove(operation); }
private boolean sourceClassImportsSuperclassOfTargetClassAfterRefactoring(String sourceClassName, String targetClassName) { UMLClassBaseDiff targetClassDiff = getUMLClassDiff(targetClassName); if(targetClassDiff != null && targetClassDiff.getSuperclass() != null) { UMLClassBaseDiff superclassOfTargetClassDiff = getUMLClassDiff(targetClassDiff.getSuperclass()); if(superclassOfTargetClassDiff != null) { return sourceClassImportsTargetClassAfterRefactoring(sourceClassName, superclassOfTargetClassDiff.getNextClassName()); } } return false; }
private boolean sourceClassImportsTargetClassAfterRefactoring(String sourceClassName, String targetClassName) { UMLClassBaseDiff classDiff = getUMLClassDiff(sourceClassName); if(classDiff == null) { classDiff = getUMLClassDiff(UMLType.extractTypeObject(sourceClassName)); } if(classDiff != null) { return classDiff.nextClassImportsType(targetClassName); } UMLClass removedClass = getRemovedClass(sourceClassName); if(removedClass == null) { removedClass = looksLikeRemovedClass(UMLType.extractTypeObject(sourceClassName)); } if(removedClass != null) { return removedClass.importsType(targetClassName); } return false; }
private boolean targetClassImportsSourceClassBeforeRefactoring(String sourceClassName, String targetClassName) { UMLClassBaseDiff classDiff = getUMLClassDiff(targetClassName); if(classDiff == null) { classDiff = getUMLClassDiff(UMLType.extractTypeObject(targetClassName)); } if(classDiff != null) { return classDiff.originalClassImportsType(sourceClassName); } UMLClass addedClass = getAddedClass(targetClassName); if(addedClass == null) { addedClass = looksLikeAddedClass(UMLType.extractTypeObject(targetClassName)); } if(addedClass != null) { return addedClass.importsType(sourceClassName); } return false; }
private boolean conflictingExpression(OperationInvocation invocation, UMLOperation addedOperation, Map<String, UMLType> variableTypeMap) { String expression = invocation.getExpression(); if(expression != null && variableTypeMap.containsKey(expression)) { UMLType type = variableTypeMap.get(expression); UMLClassBaseDiff classDiff = getUMLClassDiff(addedOperation.getClassName()); boolean superclassRelationship = false; if(classDiff != null && classDiff.getNewSuperclass() != null && classDiff.getNewSuperclass().equals(type)) { superclassRelationship = true; } if(!addedOperation.getNonQualifiedClassName().equals(type.getClassType()) && !superclassRelationship) { return true; } } return false; }
private void processAddedGeneralization(UMLClass addedClass, Set<UMLClass> subclassSet, UMLGeneralization addedGeneralization) { String parent = addedGeneralization.getParent(); UMLClass subclass = addedGeneralization.getChild(); if(looksLikeSameType(parent, addedClass.getName()) && topLevelOrSameOuterClass(addedClass, subclass) && getAddedClass(subclass.getName()) == null) { UMLClassBaseDiff subclassDiff = getUMLClassDiff(subclass.getName()); if(subclassDiff != null) { detectSubRefactorings(subclassDiff, addedClass, RefactoringType.EXTRACT_SUPERCLASS); } subclassSet.add(subclass); } }
UMLClassBaseDiff sourceClassDiff = getUMLClassDiff(candidate.getSourceClassName()); UMLClassBaseDiff targetClassDiff = getUMLClassDiff(candidate.getTargetClassName()); if(sourceClassDiff != null) { UMLType targetSuperclass = null;
if(className.contains(".") && isNumeric(className.substring(className.lastIndexOf(".")+1, className.length()))) { UMLClassBaseDiff umlClassDiff = getUMLClassDiff(className.substring(0, className.lastIndexOf("."))); attributes.addAll(umlClassDiff.originalClassAttributesOfType(addedOperation.getClassName())); for(UMLAnonymousClass anonymous : umlClassDiff.getOriginalClass().getAnonymousClassList()) { UMLClassBaseDiff umlClassDiff = getUMLClassDiff(className); attributes.addAll(umlClassDiff.originalClassAttributesOfType(addedOperation.getClassName()));
String supplier = addedRealization.getSupplier(); if(looksLikeSameType(supplier, addedClassName) && topLevelOrSameOuterClass(addedClass, addedRealization.getClient()) && getAddedClass(addedRealization.getClient().getName()) == null) { UMLClassBaseDiff clientClassDiff = getUMLClassDiff(addedRealization.getClient().getName()); boolean implementedInterfaceOperations = true; if(clientClassDiff != null) {
private boolean anotherAddedMethodExistsWithBetterMatchingInvocationExpression(OperationInvocation invocation, UMLOperation addedOperation, List<UMLOperation> addedOperations) { String expression = invocation.getExpression(); if(expression != null) { int originalDistance = StringDistance.editDistance(expression, addedOperation.getNonQualifiedClassName()); for(UMLOperation operation : addedOperations) { UMLClassBaseDiff classDiff = getUMLClassDiff(operation.getClassName()); boolean isInterface = classDiff != null ? classDiff.nextClass.isInterface() : false; if(!operation.equals(addedOperation) && addedOperation.equalSignature(operation) && !operation.isAbstract() && !isInterface) { int newDistance = StringDistance.editDistance(expression, operation.getNonQualifiedClassName()); if(newDistance < originalDistance) { return true; } } } } return false; }
visitedClasses.add(subclass); UMLClassBaseDiff subclassDiff = getUMLClassDiff(subclass); if(subclassDiff == null) { subclassDiff = getUMLClassDiff(UMLType.extractTypeObject(subclass));