From 4f5a8c4e7f8456d6ef5dab80dc79567eb1692c21 Mon Sep 17 00:00:00 2001 From: Guillermo Calvo Date: Fri, 4 Oct 2024 19:23:26 +0200 Subject: [PATCH] Refactor some usages of `Optional` --- .../main/java/japicmp/maven/JApiCmpMojo.java | 2 +- .../cmp/JarArchiveComparatorOptions.java | 8 +- .../japicmp/compat/CompatibilityChanges.java | 122 ++++++------------ .../java/japicmp/model/AccessModifier.java | 5 +- .../java/japicmp/model/JApiAnnotation.java | 6 +- .../japicmp/model/JApiAnnotationElement.java | 30 ++--- .../main/java/japicmp/model/JApiBehavior.java | 90 ++++--------- .../main/java/japicmp/model/JApiClass.java | 117 +++++------------ .../java/japicmp/model/JApiException.java | 28 ++-- .../main/java/japicmp/model/JApiField.java | 10 +- .../model/JApiImplementedInterface.java | 28 +--- .../main/java/japicmp/model/JApiMethod.java | 60 ++------- .../java/japicmp/model/JApiSuperclass.java | 17 +-- .../src/main/java/japicmp/model/JApiType.java | 7 +- .../JavaObjectSerializationCompatibility.java | 36 ++---- .../output/html/HtmlOutputGenerator.java | 5 +- .../incompatible/IncompatibleErrorOutput.java | 8 +- .../markdown/MarkdownOutputGenerator.java | 10 +- .../config/MarkdownMessageOptions.java | 8 +- .../output/stdout/StdoutOutputGenerator.java | 44 ++----- .../output/xml/XmlOutputGenerator.java | 25 ++-- .../output/xml/model/JApiCmpXmlRoot.java | 8 +- .../java/japicmp/util/ModifierHelper.java | 67 +++------- .../java/japicmp/util/OptionalHelper.java | 5 +- .../japicmp/versioning/VersionChange.java | 5 +- 25 files changed, 221 insertions(+), 530 deletions(-) diff --git a/japicmp-maven-plugin/src/main/java/japicmp/maven/JApiCmpMojo.java b/japicmp-maven-plugin/src/main/java/japicmp/maven/JApiCmpMojo.java index 0b2ca762..a66ccaf6 100644 --- a/japicmp-maven-plugin/src/main/java/japicmp/maven/JApiCmpMojo.java +++ b/japicmp-maven-plugin/src/main/java/japicmp/maven/JApiCmpMojo.java @@ -894,7 +894,7 @@ private List resolveDependencyToFile(String parameterName, Depen private String guessVersion(File file) { String name = file.getName(); Optional semanticVersion = japicmp.versioning.Version.getSemanticVersion(name); - String version = semanticVersion.isPresent() ? semanticVersion.get().toString() : "n.a."; + String version = semanticVersion.map(Object::toString).orElse("n.a."); if (name.contains("SNAPSHOT")) { version += "-SNAPSHOT"; } diff --git a/japicmp/src/main/java/japicmp/cmp/JarArchiveComparatorOptions.java b/japicmp/src/main/java/japicmp/cmp/JarArchiveComparatorOptions.java index 78fbea1a..efb53143 100644 --- a/japicmp/src/main/java/japicmp/cmp/JarArchiveComparatorOptions.java +++ b/japicmp/src/main/java/japicmp/cmp/JarArchiveComparatorOptions.java @@ -10,7 +10,7 @@ import java.io.File; import java.util.ArrayList; -import java.util.Collections; +import java.util.Arrays; import java.util.LinkedList; import java.util.List; import java.util.Optional; @@ -103,10 +103,8 @@ private static void toJarArchiveComparatorClassPathMode(Options options, JarArch } private static void toJarArchiveComparatorClassPath(Optional classPathOptional, List comparatorClassPath) { - if (classPathOptional.isPresent()) { - String classPathAsString = classPathOptional.get(); - Collections.addAll(comparatorClassPath, classPathAsString.split(File.pathSeparator)); - } + classPathOptional.map(classPathAsString -> Arrays.asList(classPathAsString.split(File.pathSeparator))) + .ifPresent(comparatorClassPath::addAll); } public Filters getFilters() { diff --git a/japicmp/src/main/java/japicmp/compat/CompatibilityChanges.java b/japicmp/src/main/java/japicmp/compat/CompatibilityChanges.java index b65cd855..1172c6bc 100755 --- a/japicmp/src/main/java/japicmp/compat/CompatibilityChanges.java +++ b/japicmp/src/main/java/japicmp/compat/CompatibilityChanges.java @@ -209,17 +209,8 @@ private void forAllSuperclasses(JApiClass jApiClass, Map JApiSuperclass superclass = jApiClass.getSuperclass(); if (superclass.getNewSuperclassName().isPresent()) { String newSuperclassName = superclass.getNewSuperclassName().get(); - JApiClass foundClass = classMap.get(newSuperclassName); - if (foundClass == null) { - Optional superclassJApiClassOptional = superclass.getJApiClass(); - if (superclassJApiClassOptional.isPresent()) { - foundClass = superclassJApiClassOptional.get(); - } else { - foundClass = loadClass(newSuperclassName, EnumSet.of(Classpath.NEW_CLASSPATH)); - evaluate(Collections.singletonList(foundClass)); - } - classMap.put(foundClass.getFullyQualifiedName(), foundClass); - } + superclass.getJApiClass().ifPresent(x -> classMap.putIfAbsent(newSuperclassName, x)); + JApiClass foundClass = classMap.computeIfAbsent(newSuperclassName, this::loadAndEvaluate); superclass.setJApiClass(foundClass); T returnValue = onSuperclassCallback.callback(foundClass, classMap, superclass.getChangeStatus()); returnValues.add(returnValue); @@ -227,6 +218,12 @@ private void forAllSuperclasses(JApiClass jApiClass, Map } } + private JApiClass loadAndEvaluate(String className) { + JApiClass loaded = loadClass(className, EnumSet.of(Classpath.NEW_CLASSPATH)); + evaluate(Collections.singletonList(loaded)); + return loaded; + } + private enum Classpath { OLD_CLASSPATH, NEW_CLASSPATH @@ -284,15 +281,12 @@ private JApiClass loadClass(String newSuperclassName, EnumSet classpa } private boolean fieldTypeMatches(JApiField field1, JApiField field2) { - boolean matches = true; - JApiType type1 = field1.getType(); - JApiType type2 = field2.getType(); - if (type1.getNewTypeOptional().isPresent() && type2.getNewTypeOptional().isPresent()) { - if (!type1.getNewTypeOptional().get().equals(type2.getNewTypeOptional().get())) { - matches = false; - } + Optional newType1 = field1.getType().getNewTypeOptional(); + Optional newType2 = field2.getType().getNewTypeOptional(); + if (newType1.isPresent() && newType2.isPresent()) { + return newType1.equals(newType2); } - return matches; + return true; } private void checkIfConstructorsHaveChangedIncompatible(JApiClass jApiClass, Map classMap) { @@ -318,7 +312,7 @@ private void checkIfConstructorsHaveChangedIncompatible(JApiClass jApiClass, Map } private static boolean isNotFinal(JApiClass jApiClass) { - return !(jApiClass.getFinalModifier().getNewModifier().isPresent() && jApiClass.getFinalModifier().getNewModifier().get() == FinalModifier.FINAL); + return !jApiClass.getFinalModifier().getNewModifier().map(FinalModifier.FINAL::equals).orElse(false); } private void checkIfMethodsHaveChangedIncompatible(JApiClass jApiClass, Map classMap) { @@ -366,11 +360,9 @@ private void checkIfMethodsHaveChangedIncompatible(JApiClass jApiClass, Map x != FinalModifier.FINAL).orElse(false) && + !method.getStaticModifier().getOldModifier().map(StaticModifier.STATIC::equals).orElse(false)) { addCompatibilityChange(method, JApiCompatibilityChangeType.METHOD_NOW_FINAL); } } @@ -401,10 +393,8 @@ private void checkIfMethodsHaveChangedIncompatible(JApiClass jApiClass, Map { for (JApiMethod superMethod : superclass.getMethods()) { if (areMatching(superMethod, method)) { - if (method.getFinalModifier().getOldModifier().isPresent() - && method.getFinalModifier().getOldModifier().get() == FinalModifier.NON_FINAL - && superMethod.getFinalModifier().getNewModifier().isPresent() - && superMethod.getFinalModifier().getNewModifier().get() == FinalModifier.FINAL) { + if (method.getFinalModifier().getOldModifier().map(FinalModifier.NON_FINAL::equals).orElse(false) + && superMethod.getFinalModifier().getNewModifier().map(FinalModifier.FINAL::equals).orElse(false)) { addCompatibilityChange(superMethod, JApiCompatibilityChangeType.METHOD_NOW_FINAL); return 1; } @@ -542,8 +532,8 @@ private void checkAbstractMethod(JApiClass jApiClass, Map cla } } else if (method.getChangeStatus() == JApiChangeStatus.MODIFIED || method.getChangeStatus() == JApiChangeStatus.UNCHANGED) { JApiModifier abstractModifier = method.getAbstractModifier(); - if (abstractModifier.getOldModifier().isPresent() && abstractModifier.getOldModifier().get() == AbstractModifier.ABSTRACT && - abstractModifier.getNewModifier().isPresent() && abstractModifier.getNewModifier().get() == AbstractModifier.NON_ABSTRACT) { + if (abstractModifier.getOldModifier().map(AbstractModifier.ABSTRACT::equals).orElse(false) && + abstractModifier.getNewModifier().map(AbstractModifier.NON_ABSTRACT::equals).orElse(false)) { // method changed from abstract to default addCompatibilityChange(method, JApiCompatibilityChangeType.METHOD_ABSTRACT_NOW_DEFAULT); } @@ -618,11 +608,7 @@ private List getMethodsInImplementedInterfacesWithSameSignature(fina } private boolean isAbstract(JApiHasAbstractModifier jApiHasAbstractModifier) { - if (jApiHasAbstractModifier.getAbstractModifier().getNewModifier().isPresent()) { - AbstractModifier abstractModifier = jApiHasAbstractModifier.getAbstractModifier().getNewModifier().get(); - return abstractModifier == AbstractModifier.ABSTRACT; - } - return false; + return jApiHasAbstractModifier.getAbstractModifier().getNewModifier().map(AbstractModifier.ABSTRACT::equals).orElse(false); } private void checkIfExceptionIsNowChecked(JApiBehavior behavior) { @@ -637,19 +623,19 @@ private void checkIfExceptionIsNowChecked(JApiBehavior behavior) { } private boolean isClass(final JApiClass jApiClass) { - return jApiClass.getClassType().getNewTypeOptional().isPresent() && jApiClass.getClassType().getNewTypeOptional().get() == JApiClassType.ClassType.CLASS; + return jApiClass.getClassType().getNewTypeOptional().map(JApiClassType.ClassType.CLASS::equals).orElse(false); } private boolean isInterface(final JApiClass jApiClass) { - return jApiClass.getClassType().getNewTypeOptional().isPresent() && jApiClass.getClassType().getNewTypeOptional().get() == JApiClassType.ClassType.INTERFACE; + return jApiClass.getClassType().getNewTypeOptional().map(JApiClassType.ClassType.INTERFACE::equals).orElse(false); } private boolean isAnnotation(final JApiClass jApiClass) { - return jApiClass.getClassType().getNewTypeOptional().isPresent() && jApiClass.getClassType().getNewTypeOptional().get() == JApiClassType.ClassType.ANNOTATION; + return jApiClass.getClassType().getNewTypeOptional().map(JApiClassType.ClassType.ANNOTATION::equals).orElse(false); } private boolean isEnum(final JApiClass jApiClass) { - return jApiClass.getClassType().getNewTypeOptional().isPresent() && jApiClass.getClassType().getNewTypeOptional().get() == JApiClassType.ClassType.ENUM; + return jApiClass.getClassType().getNewTypeOptional().map(JApiClassType.ClassType.ENUM::equals).orElse(false); } private void checkIfMethodHasBeenPulledUp(JApiClass jApiClass, Map classMap, final JApiMethod method, List returnValues) { @@ -693,11 +679,7 @@ private boolean isImplemented(JApiMethod jApiMethod, JApiClass aClass) { } } - if (aClass.getSuperclass() != null && aClass.getSuperclass().getJApiClass().isPresent()) { - aClass = aClass.getSuperclass().getJApiClass().get(); - } else { - aClass = null; - } + aClass = Optional.ofNullable(aClass.getSuperclass()).flatMap(JApiSuperclass::getJApiClass).orElse(null); } return false; } @@ -777,15 +759,11 @@ private void checkIfSuperclassesOrInterfacesChangedIncompatible(final JApiClass addCompatibilityChange(jApiClass, JApiCompatibilityChangeType.FIELD_REMOVED_IN_SUPERCLASS); } if (superclass.getOldSuperclassName().isPresent() && superclass.getNewSuperclassName().isPresent()) { - if (!superclass.getOldSuperclassName().get().equals(superclass.getNewSuperclassName().get())) { - boolean superClassChangedToObject = false; - boolean superClassChangedFromObject = false; - if (!superclass.getOldSuperclassName().get().equals("java.lang.Object") && superclass.getNewSuperclassName().get().equals("java.lang.Object")) { - superClassChangedToObject = true; - } - if (superclass.getOldSuperclassName().get().equals("java.lang.Object") && !superclass.getNewSuperclassName().get().equals("java.lang.Object")) { - superClassChangedFromObject = true; - } + if (!superclass.getOldSuperclassName().equals(superclass.getNewSuperclassName())) { + String oldSuperclassName = superclass.getOldSuperclassName().get(); + String newSuperclassName = superclass.getNewSuperclassName().get(); + boolean superClassChangedToObject = !oldSuperclassName.equals("java.lang.Object") && newSuperclassName.equals("java.lang.Object"); + boolean superClassChangedFromObject = oldSuperclassName.equals("java.lang.Object") && !newSuperclassName.equals("java.lang.Object"); if (superClassChangedToObject) { addCompatibilityChange(superclass, JApiCompatibilityChangeType.SUPERCLASS_REMOVED); } else if (superClassChangedFromObject) { @@ -796,7 +774,7 @@ private void checkIfSuperclassesOrInterfacesChangedIncompatible(final JApiClass final List matchingAncestors = new ArrayList<>(); forAllSuperclasses(jApiClass, classMap, ancestors, (clazz, classMap12, changeStatusOfSuperclass) -> { JApiSuperclass ancestor = clazz.getSuperclass(); - if (ancestor.getNewSuperclassName().isPresent() && ancestor.getNewSuperclassName().get().equals(superclass.getOldSuperclassName().get())) { + if (ancestor.getNewSuperclassName().filter(oldSuperclassName::equals).isPresent()) { matchingAncestors.add(ancestor); } return ancestor; @@ -912,14 +890,9 @@ private void checkIfAbstractMethodAddedInSuperclass(final JApiClass jApiClass, M } if (!isImplemented) { if (jApiMethod.getChangeStatus() == JApiChangeStatus.NEW || changeStatusOfSuperclass == JApiChangeStatus.NEW || changeStatusOfSuperclass == JApiChangeStatus.MODIFIED) { - if (jApiMethod.getAbstractModifier().getNewModifier().isPresent()) { - AbstractModifier abstractModifier = jApiMethod.getAbstractModifier().getNewModifier().get(); - if (abstractModifier == AbstractModifier.ABSTRACT) { - abstractMethods.add(jApiMethod); - } else { - defaultMethods.add(jApiMethod); - } - } + jApiMethod.getAbstractModifier().getNewModifier() + .map(x -> x == AbstractModifier.ABSTRACT ? abstractMethods : defaultMethods) + .ifPresent(methods -> methods.add(jApiMethod)); } } } @@ -944,14 +917,9 @@ private void checkIfAbstractMethodAddedInSuperclass(final JApiClass jApiClass, M } if (!isImplemented) { if (interfaceMethod.getChangeStatus() == JApiChangeStatus.NEW || jApiImplementedInterface.getChangeStatus() == JApiChangeStatus.NEW) { - if (interfaceMethod.getAbstractModifier().getNewModifier().isPresent()) { - AbstractModifier abstractModifier = interfaceMethod.getAbstractModifier().getNewModifier().get(); - if (abstractModifier == AbstractModifier.ABSTRACT) { - abstractMethods.add(interfaceMethod); - } else { - defaultMethods.add(interfaceMethod); - } - } + interfaceMethod.getAbstractModifier().getNewModifier() + .map(x -> x == AbstractModifier.ABSTRACT ? abstractMethods : defaultMethods) + .ifPresent(methods -> methods.add(interfaceMethod)); } } } @@ -1004,12 +972,8 @@ private JApiClass getJApiClass(JApiImplementedInterface implementedInterface, Ma private void checkIfClassNowCheckedException(JApiClass jApiClass) { JApiSuperclass jApiClassSuperclass = jApiClass.getSuperclass(); if (jApiClassSuperclass.getChangeStatus() == JApiChangeStatus.MODIFIED) { - if (jApiClassSuperclass.getNewSuperclassName().isPresent()) { - String fqn = jApiClassSuperclass.getNewSuperclassName().get(); - if ("java.lang.Exception".equals(fqn)) { - addCompatibilityChange(jApiClass, JApiCompatibilityChangeType.CLASS_NOW_CHECKED_EXCEPTION); - } - } + jApiClassSuperclass.getNewSuperclassName().filter("java.lang.Exception"::equals) + .ifPresent(fqn -> addCompatibilityChange(jApiClass, JApiCompatibilityChangeType.CLASS_NOW_CHECKED_EXCEPTION)); } } diff --git a/japicmp/src/main/java/japicmp/model/AccessModifier.java b/japicmp/src/main/java/japicmp/model/AccessModifier.java index 9e9f779c..3b58b703 100644 --- a/japicmp/src/main/java/japicmp/model/AccessModifier.java +++ b/japicmp/src/main/java/japicmp/model/AccessModifier.java @@ -34,10 +34,9 @@ public static String listOfAccessModifier() { } public static Optional toModifier(String accessModifierArg) { - Optional stringOptional = Optional.ofNullable(accessModifierArg); - if (stringOptional.isPresent()) { + if (accessModifierArg != null) { try { - return Optional.of(valueOf(stringOptional.get().toUpperCase())); + return Optional.of(valueOf(accessModifierArg.toUpperCase())); } catch (IllegalArgumentException e) { throw new JApiCmpException(JApiCmpException.Reason.CliError, String.format("Invalid value for option accessModifier: %s. Possible values are: %s.", accessModifierArg, listOfAccessModifier()), e); diff --git a/japicmp/src/main/java/japicmp/model/JApiAnnotation.java b/japicmp/src/main/java/japicmp/model/JApiAnnotation.java index 261408fe..77414ff4 100644 --- a/japicmp/src/main/java/japicmp/model/JApiAnnotation.java +++ b/japicmp/src/main/java/japicmp/model/JApiAnnotation.java @@ -97,11 +97,7 @@ private Map> buildMemberValueMap(Annotation annota if (memberNames != null) { for (String memberName : memberNames) { MemberValue memberValue = annotation.getMemberValue(memberName); - if (memberValue == null) { - map.put(memberName, Optional.empty()); - } else { - map.put(memberName, Optional.of(memberValue)); - } + map.put(memberName, Optional.ofNullable(memberValue)); } } return map; diff --git a/japicmp/src/main/java/japicmp/model/JApiAnnotationElement.java b/japicmp/src/main/java/japicmp/model/JApiAnnotationElement.java index 4ee95870..fb2d620c 100644 --- a/japicmp/src/main/java/japicmp/model/JApiAnnotationElement.java +++ b/japicmp/src/main/java/japicmp/model/JApiAnnotationElement.java @@ -103,6 +103,14 @@ static JApiAnnotationElementValue getMemberValue(MemberValue memberValue) { } } + private static List getElementValues(MemberValue memberValue) { + JApiAnnotationElementValue elementValue = getMemberValue(memberValue); + if(elementValue.getType() == JApiAnnotationElementValue.Type.Array) { + return new ArrayList<>(elementValue.getValues()); + } + return new ArrayList<>(Collections.singleton(elementValue)); + } + @XmlAttribute(name = "name") public String getName() { return name; @@ -127,31 +135,13 @@ public JApiChangeStatus getChangeStatus() { @XmlElementWrapper(name = "oldElementValues") @XmlElement(name = "oldElementValue") public List getOldElementValues() { - List values = new ArrayList<>(); - if (this.oldValue.isPresent()) { - JApiAnnotationElementValue memberValue = getMemberValue(this.oldValue.get()); - if (memberValue.getType() == JApiAnnotationElementValue.Type.Array) { - values.addAll(memberValue.getValues()); - } else { - values.add(memberValue); - } - } - return values; + return this.oldValue.map(JApiAnnotationElement::getElementValues).orElseGet(ArrayList::new); } @XmlElementWrapper(name = "newElementValues") @XmlElement(name = "newElementValue") public List getNewElementValues() { - List values = new ArrayList<>(); - if (this.newValue.isPresent()) { - JApiAnnotationElementValue memberValue = getMemberValue(this.newValue.get()); - if (memberValue.getType() == JApiAnnotationElementValue.Type.Array) { - values.addAll(memberValue.getValues()); - } else { - values.add(memberValue); - } - } - return values; + return this.newValue.map(JApiAnnotationElement::getElementValues).orElseGet(ArrayList::new); } @XmlAttribute diff --git a/japicmp/src/main/java/japicmp/model/JApiBehavior.java b/japicmp/src/main/java/japicmp/model/JApiBehavior.java index 7396f9d7..f47b7455 100644 --- a/japicmp/src/main/java/japicmp/model/JApiBehavior.java +++ b/japicmp/src/main/java/japicmp/model/JApiBehavior.java @@ -10,6 +10,7 @@ import javassist.bytecode.AnnotationsAttribute; import javassist.bytecode.ExceptionsAttribute; +import javassist.bytecode.MethodInfo; import javax.xml.bind.annotation.XmlAttribute; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlElementWrapper; @@ -127,37 +128,19 @@ private List computeExceptionChanges(Optional extractExceptions(Optional methodOptional) { - if (methodOptional.isPresent()) { - ExceptionsAttribute exceptionsAttribute = null; - try { - exceptionsAttribute = methodOptional.get().getMethodInfo().getExceptionsAttribute(); - } catch (NullPointerException ex) { - return Collections.emptyList(); - } - String[] exceptions; - if (exceptionsAttribute != null && exceptionsAttribute.getExceptions() != null) { - exceptions = exceptionsAttribute.getExceptions(); - } else { - exceptions = new String[0]; - } - List list = new ArrayList<>(exceptions.length); - Collections.addAll(list, exceptions); - return list; - } else { - return Collections.emptyList(); - } + return methodOptional + .map(CtBehavior::getMethodInfo) + .map(MethodInfo::getExceptionsAttribute) + .map(ExceptionsAttribute::getExceptions) + .map(Arrays::asList) + .map(ArrayList::new) + .orElseGet(ArrayList::new); } private Optional getLineNumber(Optional methodOptional) { - Optional lineNumberOptional = Optional.empty(); - if (methodOptional.isPresent()) { - CtBehavior ctMethod = methodOptional.get(); - int lineNumber = ctMethod.getMethodInfo().getLineNumber(0); - if (lineNumber >= 0) { - lineNumberOptional = Optional.of(lineNumber); - } - } - return lineNumberOptional; + return methodOptional.map(CtBehavior::getMethodInfo) + .map(info -> info.getLineNumber(0)) + .filter(number -> number >= 0); } @SuppressWarnings("unchecked") @@ -227,42 +210,25 @@ private JApiChangeStatus evaluateChangeStatus(JApiChangeStatus changeStatus) { } protected JApiAttribute extractSyntheticAttribute(Optional oldBehaviorOptional, Optional newBehaviorOptional) { - JApiAttribute jApiAttribute = new JApiAttribute<>(JApiChangeStatus.UNCHANGED, Optional.of(SyntheticAttribute.SYNTHETIC), Optional.of(SyntheticAttribute.SYNTHETIC)); - if (oldBehaviorOptional.isPresent() && newBehaviorOptional.isPresent()) { - CtBehavior oldBehavior = oldBehaviorOptional.get(); - CtBehavior newBehavior = newBehaviorOptional.get(); - byte[] attributeOldBehavior = oldBehavior.getAttribute(Constants.JAVA_CONSTPOOL_ATTRIBUTE_SYNTHETIC); - byte[] attributeNewBehavior = newBehavior.getAttribute(Constants.JAVA_CONSTPOOL_ATTRIBUTE_SYNTHETIC); - if (attributeOldBehavior != null && attributeNewBehavior != null) { - jApiAttribute = new JApiAttribute<>(JApiChangeStatus.UNCHANGED, Optional.of(SyntheticAttribute.SYNTHETIC), Optional.of(SyntheticAttribute.SYNTHETIC)); - } else if (attributeOldBehavior != null) { - jApiAttribute = new JApiAttribute<>(JApiChangeStatus.MODIFIED, Optional.of(SyntheticAttribute.SYNTHETIC), Optional.of(SyntheticAttribute.NON_SYNTHETIC)); - } else if (attributeNewBehavior != null) { - jApiAttribute = new JApiAttribute<>(JApiChangeStatus.MODIFIED, Optional.of(SyntheticAttribute.NON_SYNTHETIC), Optional.of(SyntheticAttribute.SYNTHETIC)); - } else { - jApiAttribute = new JApiAttribute<>(JApiChangeStatus.UNCHANGED, Optional.of(SyntheticAttribute.NON_SYNTHETIC), Optional.of(SyntheticAttribute.NON_SYNTHETIC)); - } - } else { - if (oldBehaviorOptional.isPresent()) { - CtBehavior ctBehavior = oldBehaviorOptional.get(); - byte[] attribute = ctBehavior.getAttribute(Constants.JAVA_CONSTPOOL_ATTRIBUTE_SYNTHETIC); - if (attribute != null) { - jApiAttribute = new JApiAttribute<>(JApiChangeStatus.REMOVED, Optional.of(SyntheticAttribute.SYNTHETIC), Optional.empty()); - } else { - jApiAttribute = new JApiAttribute<>(JApiChangeStatus.REMOVED, Optional.of(SyntheticAttribute.NON_SYNTHETIC), Optional.empty()); - } - } - if (newBehaviorOptional.isPresent()) { - CtBehavior ctBehavior = newBehaviorOptional.get(); - byte[] attribute = ctBehavior.getAttribute(Constants.JAVA_CONSTPOOL_ATTRIBUTE_SYNTHETIC); - if (attribute != null) { - jApiAttribute = new JApiAttribute<>(JApiChangeStatus.NEW, Optional.empty(), Optional.of(SyntheticAttribute.SYNTHETIC)); - } else { - jApiAttribute = new JApiAttribute<>(JApiChangeStatus.NEW, Optional.empty(), Optional.of(SyntheticAttribute.NON_SYNTHETIC)); - } + Optional oldAttribute = oldBehaviorOptional.map(this::extractSyntheticAttribute); + Optional newAttribute = newBehaviorOptional.map(this::extractSyntheticAttribute); + if (oldAttribute.isPresent() && newAttribute.isPresent()) { + if (oldAttribute.equals(newAttribute)) { + return new JApiAttribute<>(JApiChangeStatus.UNCHANGED, oldAttribute, newAttribute); } + return new JApiAttribute<>(JApiChangeStatus.MODIFIED, oldAttribute, newAttribute); + } + if (oldAttribute.isPresent()) { + return new JApiAttribute<>(JApiChangeStatus.REMOVED, oldAttribute, Optional.empty()); } - return jApiAttribute; + if (newAttribute.isPresent()) { + return new JApiAttribute<>(JApiChangeStatus.NEW, Optional.empty(), newAttribute); + } + return new JApiAttribute<>(JApiChangeStatus.UNCHANGED, Optional.of(SyntheticAttribute.SYNTHETIC), Optional.of(SyntheticAttribute.SYNTHETIC)); + } + + private SyntheticAttribute extractSyntheticAttribute(CtBehavior behavior) { + return behavior.getAttribute(Constants.JAVA_CONSTPOOL_ATTRIBUTE_SYNTHETIC) == null ? SyntheticAttribute.NON_SYNTHETIC : SyntheticAttribute.SYNTHETIC; } public boolean hasSameParameter(JApiMethod method) { diff --git a/japicmp/src/main/java/japicmp/model/JApiClass.java b/japicmp/src/main/java/japicmp/model/JApiClass.java index 196bce49..e8039385 100644 --- a/japicmp/src/main/java/japicmp/model/JApiClass.java +++ b/japicmp/src/main/java/japicmp/model/JApiClass.java @@ -4,6 +4,7 @@ import japicmp.cmp.JarArchiveComparatorOptions; import japicmp.exception.JApiCmpException; import japicmp.util.*; +import java.util.stream.Stream; import javassist.*; import javassist.bytecode.AnnotationsAttribute; import javassist.bytecode.ClassFile; @@ -103,25 +104,13 @@ public SignatureParser newSignatureParser() { } private JApiClassFileFormatVersion extractClassFileFormatVersion(Optional oldClassOptional, Optional newClassOptional) { - if (oldClassOptional.isPresent() && newClassOptional.isPresent()) { - CtClass oldClass = oldClassOptional.get(); - CtClass newClass = newClassOptional.get(); - ClassFile classFileOld = oldClass.getClassFile(); - ClassFile classFileNew = newClass.getClassFile(); - return new JApiClassFileFormatVersion(classFileOld.getMajorVersion(), classFileOld.getMinorVersion(), classFileNew.getMajorVersion(), classFileNew.getMinorVersion()); - } else { - if (oldClassOptional.isPresent()) { - CtClass oldClass = oldClassOptional.get(); - ClassFile classFileOld = oldClass.getClassFile(); - return new JApiClassFileFormatVersion(classFileOld.getMajorVersion(), classFileOld.getMinorVersion(), -1, -1); - } - if (newClassOptional.isPresent()) { - CtClass newClass = newClassOptional.get(); - ClassFile classFileNew = newClass.getClassFile(); - return new JApiClassFileFormatVersion(-1, -1, classFileNew.getMajorVersion(), classFileNew.getMinorVersion()); - } - return new JApiClassFileFormatVersion(-1, -1, -1, -1); - } + Optional oldClassFile = oldClassOptional.map(CtClass::getClassFile); + Optional newClassFile = newClassOptional.map(CtClass::getClassFile); + int majorVersionOld = oldClassFile.map(ClassFile::getMajorVersion).orElse(-1); + int minorVersionOld = oldClassFile.map(ClassFile::getMinorVersion).orElse(-1); + int majorVersionNew = newClassFile.map(ClassFile::getMajorVersion).orElse(-1); + int minorVersionNew = newClassFile.map(ClassFile::getMinorVersion).orElse(-1); + return new JApiClassFileFormatVersion(majorVersionOld, minorVersionOld, majorVersionNew, minorVersionNew); } private void computeAnnotationChanges(List annotations, Optional oldClassOptional, Optional newClassOptional) { @@ -231,14 +220,9 @@ private void computeFieldChanges(List fields, Optional oldCl } private void enhanceGenericTypeToField(CtField field, List genericTypes) { - if (field.getGenericSignature() != null) { - SignatureParser signatureParser = new SignatureParser(); - List parsedParameters = signatureParser.parseTypes(field.getGenericSignature()); - if (!parsedParameters.isEmpty()) { - SignatureParser.ParsedParameter parsedParameter = parsedParameters.get(0); - SignatureParser.copyGenericParameters(parsedParameter, genericTypes); - } - } + Optional.ofNullable(field.getGenericSignature()) + .map(new SignatureParser()::parseTypes).map(List::stream).flatMap(Stream::findFirst) + .ifPresent(parsedParameter -> SignatureParser.copyGenericParameters(parsedParameter, genericTypes)); } private boolean includeField(JApiField jApiField) { @@ -309,41 +293,18 @@ private Optional getSuperclass(CtClass ctClass) { } private void computeInterfaceChanges(List interfacesArg, Optional oldClassOptional, Optional newClassOptional) { - if (oldClassOptional.isPresent() && newClassOptional.isPresent()) { - CtClass oldClass = oldClassOptional.get(); - CtClass newClass = newClassOptional.get(); - Map interfaceMapOldClass = buildInterfaceMap(oldClass, JarArchiveComparator.ArchiveType.OLD); - Map interfaceMapNewClass = buildInterfaceMap(newClass, JarArchiveComparator.ArchiveType.NEW); - for (CtClass oldInterface : interfaceMapOldClass.values()) { - CtClass ctClassFound = interfaceMapNewClass.get(oldInterface.getName()); - if (ctClassFound != null) { - JApiImplementedInterface jApiClass = new JApiImplementedInterface(oldInterface, oldInterface.getName(), JApiChangeStatus.UNCHANGED); - interfacesArg.add(jApiClass); - } else { - JApiImplementedInterface jApiClass = new JApiImplementedInterface(oldInterface, oldInterface.getName(), JApiChangeStatus.REMOVED); - interfacesArg.add(jApiClass); - } - } - for (CtClass newInterface : interfaceMapNewClass.values()) { - CtClass ctClassFound = interfaceMapOldClass.get(newInterface.getName()); - if (ctClassFound == null) { - JApiImplementedInterface jApiClass = new JApiImplementedInterface(newInterface, newInterface.getName(), JApiChangeStatus.NEW); - interfacesArg.add(jApiClass); - } - } - } else { - if (oldClassOptional.isPresent()) { - Map interfaceMap = buildInterfaceMap(oldClassOptional.get(), JarArchiveComparator.ArchiveType.OLD); - for (CtClass ctClass : interfaceMap.values()) { - JApiImplementedInterface jApiClass = new JApiImplementedInterface(ctClass, ctClass.getName(), JApiChangeStatus.REMOVED); - interfacesArg.add(jApiClass); - } - } else if (newClassOptional.isPresent()) { - Map interfaceMap = buildInterfaceMap(newClassOptional.get(), JarArchiveComparator.ArchiveType.NEW); - for (CtClass ctClass : interfaceMap.values()) { - JApiImplementedInterface jApiClass = new JApiImplementedInterface(ctClass, ctClass.getName(), JApiChangeStatus.NEW); - interfacesArg.add(jApiClass); - } + Map interfaceMapOldClass = oldClassOptional.map(oldClass -> buildInterfaceMap(oldClass, JarArchiveComparator.ArchiveType.OLD)).orElseGet(Collections::emptyMap); + Map interfaceMapNewClass = newClassOptional.map(newClass -> buildInterfaceMap(newClass, JarArchiveComparator.ArchiveType.NEW)).orElseGet(Collections::emptyMap); + for (CtClass oldInterface : interfaceMapOldClass.values()) { + CtClass ctClassFound = interfaceMapNewClass.get(oldInterface.getName()); + JApiChangeStatus interfaceStatus = ctClassFound != null ? JApiChangeStatus.UNCHANGED : JApiChangeStatus.REMOVED; + JApiImplementedInterface jApiClass = new JApiImplementedInterface(oldInterface, oldInterface.getName(), interfaceStatus); + interfacesArg.add(jApiClass); + } + for (CtClass newInterface : interfaceMapNewClass.values()) { + if (interfaceMapOldClass.get(newInterface.getName()) == null) { + JApiImplementedInterface jApiClass = new JApiImplementedInterface(newInterface, newInterface.getName(), JApiChangeStatus.NEW); + interfacesArg.add(jApiClass); } } } @@ -361,10 +322,7 @@ private void buildInterfaceMap(CtClass ctClass, JarArchiveComparator.ArchiveType map.put(ctInterface.getName(), ctInterface); buildInterfaceMap(archiveType, map, ctInterface); } - Optional superClassOptional = getSuperclass(ctClass); - if (superClassOptional.isPresent()) { - buildInterfaceMap(superClassOptional.get(), archiveType, map); - } + getSuperclass(ctClass).ifPresent(superClass -> buildInterfaceMap(superClass, archiveType, map)); } catch (NotFoundException e) { if (!options.getIgnoreMissingClasses().ignoreClass(e.getMessage())) { throw JApiCmpException.forClassLoading(e, "Class not found: " + e.getMessage(), jarArchiveComparator); @@ -373,11 +331,9 @@ private void buildInterfaceMap(CtClass ctClass, JarArchiveComparator.ArchiveType } private void buildInterfaceMap(JarArchiveComparator.ArchiveType archiveType, Map map, CtClass ctInterface) throws NotFoundException { - Optional loadedInterfaceOptional = this.jarArchiveComparator.loadClass(archiveType, ctInterface.getName()); - if (loadedInterfaceOptional.isPresent()) { - CtClass loadedInterface = loadedInterfaceOptional.get(); - CtClass[] loadedInterfaceInterfaces = loadedInterface.getInterfaces(); - for (CtClass additionalInterface : loadedInterfaceInterfaces) { + CtClass loadedInterface = this.jarArchiveComparator.loadClass(archiveType, ctInterface.getName()).orElse(null); + if (loadedInterface != null) { + for (CtClass additionalInterface : loadedInterface.getInterfaces()) { map.put(additionalInterface.getName(), additionalInterface); buildInterfaceMap(archiveType, map, additionalInterface); } @@ -526,18 +482,11 @@ private void sortConstructorsIntoLists(JApiClass jApiClass, Mapempty(), jarArchiveComparator); - addParametersToMethod(methodDescriptorParser, jApiConstructor); - if (includeConstructor(jApiConstructor)) { - constructors.add(jApiConstructor); - } - } else { - JApiConstructor jApiConstructor = new JApiConstructor(jApiClass, ctMethod.getName(), JApiChangeStatus.UNCHANGED, Optional.of(ctMethod), Optional.of(foundMethod), jarArchiveComparator); - addParametersToMethod(methodDescriptorParser, jApiConstructor); - if (includeConstructor(jApiConstructor)) { - constructors.add(jApiConstructor); - } + JApiChangeStatus constructorStatus = foundMethod == null ? JApiChangeStatus.REMOVED : JApiChangeStatus.UNCHANGED; + JApiConstructor jApiConstructor = new JApiConstructor(jApiClass, ctMethod.getName(), constructorStatus, Optional.of(ctMethod), Optional.ofNullable(foundMethod), jarArchiveComparator); + addParametersToMethod(methodDescriptorParser, jApiConstructor); + if (includeConstructor(jApiConstructor)) { + constructors.add(jApiConstructor); } } for (CtConstructor ctMethod : newConstructorsMap.values()) { @@ -545,7 +494,7 @@ private void sortConstructorsIntoLists(JApiClass jApiClass, Mapempty(), Optional.of(ctMethod), jarArchiveComparator); + JApiConstructor jApiConstructor = new JApiConstructor(jApiClass, ctMethod.getName(), JApiChangeStatus.NEW, Optional.empty(), Optional.of(ctMethod), jarArchiveComparator); addParametersToMethod(methodDescriptorParser, jApiConstructor); if (includeConstructor(jApiConstructor)) { constructors.add(jApiConstructor); diff --git a/japicmp/src/main/java/japicmp/model/JApiException.java b/japicmp/src/main/java/japicmp/model/JApiException.java index 74f6ea25..0fd1857e 100644 --- a/japicmp/src/main/java/japicmp/model/JApiException.java +++ b/japicmp/src/main/java/japicmp/model/JApiException.java @@ -1,6 +1,7 @@ package japicmp.model; import japicmp.cmp.JarArchiveComparator; +import java.util.function.Predicate; import javassist.CtClass; import javax.xml.bind.annotation.XmlAttribute; @@ -18,26 +19,13 @@ public JApiException(JarArchiveComparator jarArchiveComparator, String name, Opt } private boolean isCheckedException(Optional ctClassOptional, JarArchiveComparator jarArchiveComparator) throws OutOfMemoryError { - boolean checkedException = false; - if (ctClassOptional.isPresent()) { - boolean subClassOfException = false; - CtClass ctClass = ctClassOptional.get(); - Optional exceptionOptional = jarArchiveComparator.loadClass(JarArchiveComparator.ArchiveType.NEW, Exception.class.getName()); - if (exceptionOptional.isPresent()) { - if (ctClass.subclassOf(exceptionOptional.get())) { - subClassOfException = true; - } - } - if (subClassOfException) { - Optional runtimeExceptionOptional = jarArchiveComparator.loadClass(JarArchiveComparator.ArchiveType.NEW, RuntimeException.class.getName()); - if (runtimeExceptionOptional.isPresent()) { - if (!ctClass.subclassOf(runtimeExceptionOptional.get())) { - checkedException = true; - } - } - } - } - return checkedException; + Predicate isException = x -> isSubclassOf(Exception.class, x, jarArchiveComparator); + Predicate isNotRuntimeException = x -> !isSubclassOf(RuntimeException.class, x, jarArchiveComparator); + return ctClassOptional.filter(isException.and(isNotRuntimeException)).isPresent(); + } + + private static boolean isSubclassOf(Class clazz, CtClass ctClass, JarArchiveComparator jarArchiveComparator) { + return jarArchiveComparator.loadClass(JarArchiveComparator.ArchiveType.NEW, clazz.getName()).map(ctClass::subclassOf).orElse(false); } @XmlAttribute(name = "name") diff --git a/japicmp/src/main/java/japicmp/model/JApiField.java b/japicmp/src/main/java/japicmp/model/JApiField.java index f5eb25dc..8b84c194 100644 --- a/japicmp/src/main/java/japicmp/model/JApiField.java +++ b/japicmp/src/main/java/japicmp/model/JApiField.java @@ -267,14 +267,8 @@ public JApiChangeStatus getChangeStatus() { @XmlAttribute(name = "name") public String getName() { - String name = "n.a."; - if (oldFieldOptional.isPresent()) { - name = oldFieldOptional.get().getName(); - } - if (newFieldOptional.isPresent()) { - name = newFieldOptional.get().getName(); - } - return name; + return oldFieldOptional.map(CtField::getName) + .orElseGet(() -> newFieldOptional.map(CtField::getName).orElse("n.a.")); } @XmlTransient diff --git a/japicmp/src/main/java/japicmp/model/JApiImplementedInterface.java b/japicmp/src/main/java/japicmp/model/JApiImplementedInterface.java index c7b5833c..6aac39dc 100644 --- a/japicmp/src/main/java/japicmp/model/JApiImplementedInterface.java +++ b/japicmp/src/main/java/japicmp/model/JApiImplementedInterface.java @@ -36,35 +36,15 @@ public JApiChangeStatus getChangeStatus() { @Override @XmlAttribute public boolean isBinaryCompatible() { - boolean binaryCompatible = true; - for (JApiCompatibilityChange compatibilityChange : compatibilityChanges) { - if (!compatibilityChange.isBinaryCompatible()) { - binaryCompatible = false; - } - } - if (binaryCompatible && correspondingJApiClass.isPresent()) { - if (!correspondingJApiClass.get().isBinaryCompatible()) { - binaryCompatible = false; - } - } - return binaryCompatible; + return compatibilityChanges.stream().allMatch(JApiCompatibilityChange::isBinaryCompatible) + && correspondingJApiClass.map(JApiClass::isBinaryCompatible).orElse(true); } @Override @XmlAttribute public boolean isSourceCompatible() { - boolean sourceCompatible = true; - for (JApiCompatibilityChange compatibilityChange : compatibilityChanges) { - if (!compatibilityChange.isSourceCompatible()) { - sourceCompatible = false; - } - } - if (sourceCompatible && correspondingJApiClass.isPresent()) { - if (!correspondingJApiClass.get().isSourceCompatible()) { - sourceCompatible = false; - } - } - return sourceCompatible; + return compatibilityChanges.stream().allMatch(JApiCompatibilityChange::isSourceCompatible) + && correspondingJApiClass.map(JApiClass::isSourceCompatible).orElse(true); } @XmlElementWrapper(name = "compatibilityChanges") diff --git a/japicmp/src/main/java/japicmp/model/JApiMethod.java b/japicmp/src/main/java/japicmp/model/JApiMethod.java index 4780521f..241cb18a 100644 --- a/japicmp/src/main/java/japicmp/model/JApiMethod.java +++ b/japicmp/src/main/java/japicmp/model/JApiMethod.java @@ -80,52 +80,26 @@ private SignatureParser.ParsedParameter computeReturnTypeGenericSignature(CtMeth } public boolean hasSameReturnType(JApiMethod otherMethod) { - boolean haveSameReturnType = false; JApiReturnType otherReturnType = otherMethod.getReturnType(); if (otherReturnType.getChangeStatus() == JApiChangeStatus.UNCHANGED || otherReturnType.getChangeStatus() == JApiChangeStatus.MODIFIED) { if (this.returnType.getChangeStatus() == JApiChangeStatus.UNCHANGED || this.returnType.getChangeStatus() == JApiChangeStatus.MODIFIED) { - if (otherReturnType.getOldReturnType().equals(this.returnType.getOldReturnType()) && otherReturnType.getNewReturnType().equals(this.returnType.getNewReturnType())) { - haveSameReturnType = true; - } - } else if (this.returnType.getChangeStatus() == JApiChangeStatus.NEW) { - if (otherReturnType.getNewReturnType().equals(this.returnType.getNewReturnType())) { - haveSameReturnType = true; - } - } else if (this.returnType.getChangeStatus() == JApiChangeStatus.REMOVED) { - if (otherReturnType.getOldReturnType().equals(this.returnType.getOldReturnType())) { - haveSameReturnType = true; - } - } - } else if (otherReturnType.getChangeStatus() == JApiChangeStatus.NEW) { - if (this.returnType.getChangeStatus() == JApiChangeStatus.UNCHANGED || this.returnType.getChangeStatus() == JApiChangeStatus.MODIFIED) { - if (otherReturnType.getNewReturnType().equals(this.returnType.getNewReturnType())) { - haveSameReturnType = true; - } + return otherReturnType.getOldReturnType().equals(this.returnType.getOldReturnType()) + && otherReturnType.getNewReturnType().equals(this.returnType.getNewReturnType()); } else if (this.returnType.getChangeStatus() == JApiChangeStatus.NEW) { - if (otherReturnType.getNewReturnType().equals(this.returnType.getNewReturnType())) { - haveSameReturnType = true; - } - } else if (this.returnType.getChangeStatus() == JApiChangeStatus.REMOVED) { - if (otherReturnType.getNewReturnType().equals(this.returnType.getOldReturnType())) { - haveSameReturnType = true; - } + return otherReturnType.getNewReturnType().equals(this.returnType.getNewReturnType()); } - } else { - if (this.returnType.getChangeStatus() == JApiChangeStatus.UNCHANGED || this.returnType.getChangeStatus() == JApiChangeStatus.MODIFIED) { - if (otherReturnType.getOldReturnType().equals(this.returnType.getNewReturnType())) { - haveSameReturnType = true; - } - } else if (this.returnType.getChangeStatus() == JApiChangeStatus.NEW) { - if (otherReturnType.getOldReturnType().equals(this.returnType.getNewReturnType())) { - haveSameReturnType = true; - } - } else if (this.returnType.getChangeStatus() == JApiChangeStatus.REMOVED) { - if (otherReturnType.getOldReturnType().equals(this.returnType.getOldReturnType())) { - haveSameReturnType = true; - } + return otherReturnType.getOldReturnType().equals(returnType.getOldReturnType()); + } + if (otherReturnType.getChangeStatus() == JApiChangeStatus.NEW) { + if (this.returnType.getChangeStatus() == JApiChangeStatus.REMOVED) { + return otherReturnType.getNewReturnType().equals(this.returnType.getOldReturnType()); } + return otherReturnType.getNewReturnType().equals(this.returnType.getNewReturnType()); + } + if (returnType.getChangeStatus() == JApiChangeStatus.REMOVED) { + return otherReturnType.getOldReturnType().equals(this.returnType.getOldReturnType()); } - return haveSameReturnType; + return otherReturnType.getOldReturnType().equals(this.returnType.getNewReturnType()); } public boolean hasSameSignature(JApiMethod jApiMethod) { @@ -161,13 +135,7 @@ public String toString() } public static String toString(Optional method) { - if(method == null ) { - return OptionalHelper.N_A; - } - if(method.isPresent()) { - return method.get().getLongName(); - } - return OptionalHelper.N_A; + return method.map(CtMethod::getLongName).orElse(OptionalHelper.N_A); } @Override diff --git a/japicmp/src/main/java/japicmp/model/JApiSuperclass.java b/japicmp/src/main/java/japicmp/model/JApiSuperclass.java index 2c20bd93..f41feb09 100644 --- a/japicmp/src/main/java/japicmp/model/JApiSuperclass.java +++ b/japicmp/src/main/java/japicmp/model/JApiSuperclass.java @@ -77,12 +77,12 @@ public Optional getNewSuperclass() { @XmlTransient public Optional getOldSuperclassName() { - return oldSuperclassOptional.isPresent() ? Optional.of(oldSuperclassOptional.get().getName()) : Optional.empty(); + return oldSuperclassOptional.map(CtClass::getName); } @XmlTransient public Optional getNewSuperclassName() { - return newSuperclassOptional.isPresent() ? Optional.of(newSuperclassOptional.get().getName()) : Optional.empty(); + return newSuperclassOptional.map(CtClass::getName); } @XmlAttribute(name = "changeStatus") @@ -149,21 +149,12 @@ public JApiClass getJApiClassOwning() { public String toString() { - String oldSuperClass = "n.a."; - if(oldSuperclassOptional.isPresent()) { - oldSuperClass = oldSuperclassOptional.get().getName(); - } - String newSuperClass = "n.a."; - if(newSuperclassOptional.isPresent()) { - newSuperClass = newSuperclassOptional.get().getName(); - } - return "JApiSuperclass [jApiClass=" + jApiClass + ", oldSuperclass=" - + oldSuperClass + + oldSuperclassOptional.map(CtClass::getName).orElse("n.a.") + ", newSuperclass=" - + newSuperClass + + newSuperclassOptional.map(CtClass::getName).orElse("n.a.") + ", changeStatus=" + changeStatus + ", compatibilityChanges=" diff --git a/japicmp/src/main/java/japicmp/model/JApiType.java b/japicmp/src/main/java/japicmp/model/JApiType.java index 3b762878..012ebe56 100644 --- a/japicmp/src/main/java/japicmp/model/JApiType.java +++ b/japicmp/src/main/java/japicmp/model/JApiType.java @@ -44,12 +44,9 @@ public String getNewValue() { } public boolean hasChanged() { - boolean hasChanged = false; if (oldTypeOptional.isPresent() && newTypeOptional.isPresent()) { - if (!oldTypeOptional.get().equals(newTypeOptional.get())) { - hasChanged = true; - } + return !oldTypeOptional.equals(newTypeOptional); } - return hasChanged; + return false; } } diff --git a/japicmp/src/main/java/japicmp/model/JavaObjectSerializationCompatibility.java b/japicmp/src/main/java/japicmp/model/JavaObjectSerializationCompatibility.java index b2e2af8c..f22c0edf 100644 --- a/japicmp/src/main/java/japicmp/model/JavaObjectSerializationCompatibility.java +++ b/japicmp/src/main/java/japicmp/model/JavaObjectSerializationCompatibility.java @@ -106,9 +106,7 @@ private void computeChangeStatus(JApiClass jApiClass) { state = checkChanges(jApiClass); if (!state.isIncompatible()) { if (jApiSerialVersionUid.getSerialVersionUidInClassOld().isPresent() && jApiSerialVersionUid.getSerialVersionUidInClassNew().isPresent()) { - Long suidOld = jApiSerialVersionUid.getSerialVersionUidInClassOld().get(); - Long suidNew = jApiSerialVersionUid.getSerialVersionUidInClassNew().get(); - if (suidOld.equals(suidNew)) { + if (jApiSerialVersionUid.getSerialVersionUidInClassOld().equals(jApiSerialVersionUid.getSerialVersionUidInClassNew())) { state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_COMPATIBLE; } else { state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_SERIALVERSIONUID_MODIFIED; @@ -159,9 +157,7 @@ private void computeChangeStatus(JApiClass jApiClass) { } else { if (!isEnum(jApiClass)) { //default serialVersionUID is ignored for enums (section 1.12 "Serialization of Enum Constants") if (jApiSerialVersionUid.getSerialVersionUidDefaultOld().isPresent() && jApiSerialVersionUid.getSerialVersionUidDefaultNew().isPresent()) { - Long defaultOld = jApiSerialVersionUid.getSerialVersionUidDefaultOld().get(); - Long defaultNew = jApiSerialVersionUid.getSerialVersionUidDefaultNew().get(); - if (defaultOld.equals(defaultNew)) { + if (jApiSerialVersionUid.getSerialVersionUidDefaultOld().equals(jApiSerialVersionUid.getSerialVersionUidDefaultNew())) { state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_COMPATIBLE; } else { state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_DEFAULT_SERIALVERSIONUID_CHANGED; @@ -180,7 +176,7 @@ private void computeChangeStatus(JApiClass jApiClass) { } private boolean isEnum(JApiClass jApiClass) { - return jApiClass.getClassType().getNewTypeOptional().isPresent() && jApiClass.getClassType().getNewTypeOptional().get() == JApiClassType.ClassType.ENUM; + return jApiClass.getClassType().getNewTypeOptional().map(JApiClassType.ClassType.ENUM::equals).orElse(false); } /** @@ -220,12 +216,8 @@ private JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChan private JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus checkChangesForClassType(JApiClass jApiClass, JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus state) { JApiClassType classType = jApiClass.getClassType(); - if (classType.getChangeStatus() == JApiChangeStatus.MODIFIED) { - JApiClassType.ClassType oldClassType = classType.getOldTypeOptional().get(); - JApiClassType.ClassType newClassType = classType.getNewTypeOptional().get(); - if (oldClassType != newClassType) { - state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_CLASS_TYPE_MODIFIED; - } + if (classType.getChangeStatus() == JApiChangeStatus.MODIFIED && !classType.getOldTypeOptional().equals(classType.getNewTypeOptional())) { + state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_CLASS_TYPE_MODIFIED; } return state; } @@ -271,22 +263,16 @@ private JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChan private JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus checkChangesForFields(JApiClass jApiClass, JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus state) { for (JApiField field : jApiClass.getFields()) { - if (field.getChangeStatus() == JApiChangeStatus.REMOVED) { - if (!"serialVersionUID".equals(field.getName())) { - state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_FIELD_REMOVED; - } + if (field.getChangeStatus() == JApiChangeStatus.REMOVED && !SERIAL_VERSION_UID.equals(field.getName())) { + state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_FIELD_REMOVED; } JApiModifier staticModifier = field.getStaticModifier(); - if (staticModifier.getOldModifier().isPresent() && staticModifier.getNewModifier().isPresent()) { - if (staticModifier.getOldModifier().get() == StaticModifier.NON_STATIC && staticModifier.getNewModifier().get() == StaticModifier.STATIC) { - state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_FIELD_CHANGED_FROM_NONSTATIC_TO_STATIC; - } + if (staticModifier.getOldModifier().map(StaticModifier.NON_STATIC::equals).orElse(false) && staticModifier.getNewModifier().map(StaticModifier.STATIC::equals).orElse(false)) { + state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_FIELD_CHANGED_FROM_NONSTATIC_TO_STATIC; } JApiModifier transientModifier = field.getTransientModifier(); - if (transientModifier.getOldModifier().isPresent() && transientModifier.getNewModifier().isPresent()) { - if (transientModifier.getOldModifier().get() == TransientModifier.NON_TRANSIENT && transientModifier.getNewModifier().get() == TransientModifier.TRANSIENT) { - state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_FIELD_CHANGED_FROM_NONTRANSIENT_TO_TRANSIENT; - } + if (transientModifier.getOldModifier().map(TransientModifier.NON_TRANSIENT::equals).orElse(false) && transientModifier.getNewModifier().map(TransientModifier.TRANSIENT::equals).orElse(false)) { + state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_FIELD_CHANGED_FROM_NONTRANSIENT_TO_TRANSIENT; } if (field.getType().getChangeStatus() == JApiChangeStatus.MODIFIED) { state = JApiJavaObjectSerializationCompatibility.JApiJavaObjectSerializationChangeStatus.SERIALIZABLE_INCOMPATIBLE_FIELD_TYPE_MODIFIED; diff --git a/japicmp/src/main/java/japicmp/output/html/HtmlOutputGenerator.java b/japicmp/src/main/java/japicmp/output/html/HtmlOutputGenerator.java index 4d270107..761b9ef2 100644 --- a/japicmp/src/main/java/japicmp/output/html/HtmlOutputGenerator.java +++ b/japicmp/src/main/java/japicmp/output/html/HtmlOutputGenerator.java @@ -643,9 +643,6 @@ private Map mapOf(String... args) { } private String getTitle() { - if (this.htmlOutputGeneratorOptions.getTitle().isPresent()) { - return this.htmlOutputGeneratorOptions.getTitle().get(); - } - return "japicmp-Report"; + return this.htmlOutputGeneratorOptions.getTitle().orElse("japicmp-Report"); } } diff --git a/japicmp/src/main/java/japicmp/output/incompatible/IncompatibleErrorOutput.java b/japicmp/src/main/java/japicmp/output/incompatible/IncompatibleErrorOutput.java index 8cea38b0..0d9cce61 100644 --- a/japicmp/src/main/java/japicmp/output/incompatible/IncompatibleErrorOutput.java +++ b/japicmp/src/main/java/japicmp/output/incompatible/IncompatibleErrorOutput.java @@ -89,15 +89,11 @@ public Void generate() { List newVersions = new ArrayList<>(); for (JApiCmpArchive file : options.getOldArchives()) { Optional semanticVersion = file.getVersion().getSemanticVersion(); - if (semanticVersion.isPresent()) { - oldVersions.add(semanticVersion.get()); - } + semanticVersion.ifPresent(oldVersions::add); } for (JApiCmpArchive file : options.getNewArchives()) { Optional semanticVersion = file.getVersion().getSemanticVersion(); - if (semanticVersion.isPresent()) { - newVersions.add(semanticVersion.get()); - } + semanticVersion.ifPresent(newVersions::add); } VersionChange versionChange = new VersionChange(oldVersions, newVersions, ignoreMissingOldVersion, ignoreMissingNewVersion); if (!versionChange.isAllMajorVersionsZero() || options.isErrorOnSemanticIncompatibilityForMajorVersionZero()) { diff --git a/japicmp/src/main/java/japicmp/output/markdown/MarkdownOutputGenerator.java b/japicmp/src/main/java/japicmp/output/markdown/MarkdownOutputGenerator.java index 647d9b28..1dd408f7 100644 --- a/japicmp/src/main/java/japicmp/output/markdown/MarkdownOutputGenerator.java +++ b/japicmp/src/main/java/japicmp/output/markdown/MarkdownOutputGenerator.java @@ -289,7 +289,7 @@ private String renderClassSimpleName(JApiClass clazz) { private String renderClassType(JApiClass clazz) { final JApiClassType classType = clazz.getClassType(); - return renderChange(classType, md.message.getClassType(classType.getOldTypeOptional()), md.message.getClassType(classType.getNewTypeOptional())); + return renderChange(classType, classType.getOldTypeOptional().map(md.message::getClassType).orElse(EMPTY), classType.getNewTypeOptional().map(md.message::getClassType).orElse(EMPTY)); } private String renderClassSuperclass(JApiClass clazz) { @@ -512,12 +512,8 @@ private String renderParameterType(JApiBehavior method, JApiParameter parameter, } private String renderMemberValue(Optional optionalValue) { - if (!optionalValue.isPresent()) { - return EMPTY; - } - final String fullValue = formatMemberValue(optionalValue.get(), false); - final String simpleValue = formatMemberValue(optionalValue.get(), true); - return renderCodeWithTooltip(fullValue, simpleValue); + return optionalValue.map(x -> renderCodeWithTooltip(formatMemberValue(x, false), formatMemberValue(x, true))) + .orElse(EMPTY); } private String renderReturnType(JApiMethod method) { diff --git a/japicmp/src/main/java/japicmp/output/markdown/config/MarkdownMessageOptions.java b/japicmp/src/main/java/japicmp/output/markdown/config/MarkdownMessageOptions.java index 97195f8b..c02c3da1 100644 --- a/japicmp/src/main/java/japicmp/output/markdown/config/MarkdownMessageOptions.java +++ b/japicmp/src/main/java/japicmp/output/markdown/config/MarkdownMessageOptions.java @@ -12,7 +12,6 @@ import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Map; -import java.util.Optional; public class MarkdownMessageOptions { @@ -151,11 +150,8 @@ public String getSummaryMessage(String semver) { } } - public String getClassType(Optional classType) { - if (!classType.isPresent()) { - return EMPTY; - } - switch (classType.get()) { + public String getClassType(JApiClassType.ClassType classType) { + switch (classType) { case ANNOTATION: return typeAnnotation; case INTERFACE: diff --git a/japicmp/src/main/java/japicmp/output/stdout/StdoutOutputGenerator.java b/japicmp/src/main/java/japicmp/output/stdout/StdoutOutputGenerator.java index 171e1d44..2f349e5b 100644 --- a/japicmp/src/main/java/japicmp/output/stdout/StdoutOutputGenerator.java +++ b/japicmp/src/main/java/japicmp/output/stdout/StdoutOutputGenerator.java @@ -284,9 +284,7 @@ private String elementValueList2String(List values) if (sb.length() > 0) { sb.append(","); } - if (value.getName().isPresent()) { - sb.append(value.getName().get()).append("="); - } + value.getName().ifPresent(name -> sb.append(name).append("=")); if (value.getType() != Type.Array && value.getType() != Type.Annotation) { if (value.getType() == Type.Enum) { sb.append(value.getFullyQualifiedName()).append(".").append(value.getValueString()); @@ -491,30 +489,22 @@ private String bridgeModifierAsString(JApiHasBridgeModifier modifier) { } private String modifierAsString(JApiModifier modifier, T notPrintValue) { + final Optional oldModifier = modifier.getOldModifier().filter(x -> x != notPrintValue); + final Optional newModifier = modifier.getNewModifier().filter(x -> x != notPrintValue); if (modifier.getOldModifier().isPresent() && modifier.getNewModifier().isPresent()) { if (modifier.getChangeStatus() == JApiChangeStatus.MODIFIED) { return modifier.getNewModifier().get() + " (<- " + modifier.getOldModifier().get() + ") "; } else if (modifier.getChangeStatus() == JApiChangeStatus.NEW) { - if (modifier.getNewModifier().get() != notPrintValue) { - return modifier.getNewModifier().get() + "(+) "; - } + return newModifier.map(x -> x + "(+) ").orElse(""); } else if (modifier.getChangeStatus() == JApiChangeStatus.REMOVED) { - if (modifier.getOldModifier().get() != notPrintValue) { - return modifier.getOldModifier().get() + "(-) "; - } + return oldModifier.map(x -> x + "(-) ").orElse(""); } else { - if (modifier.getNewModifier().get() != notPrintValue) { - return modifier.getNewModifier().get() + " "; - } - } - } else if (modifier.getOldModifier().isPresent()) { - if (modifier.getOldModifier().get() != notPrintValue) { - return modifier.getOldModifier().get() + "(-) "; - } - } else if (modifier.getNewModifier().isPresent()) { - if (modifier.getNewModifier().get() != notPrintValue) { - return modifier.getNewModifier().get() + "(+) "; + return newModifier.map(x -> x + " ").orElse(""); } + } else if (oldModifier.isPresent()) { + return oldModifier.get() + "(-) "; + } else if (newModifier.isPresent()) { + return newModifier.get() + "(+) "; } return ""; } @@ -531,12 +521,9 @@ private String fieldTypeChangeAsString(JApiField field) { } else { return type.getNewTypeOptional().get(); } - } else if (type.getOldTypeOptional().isPresent() && !type.getNewTypeOptional().isPresent()) { - return type.getOldTypeOptional().get(); - } else if (!type.getOldTypeOptional().isPresent() && type.getNewTypeOptional().isPresent()) { - return type.getNewTypeOptional().get(); } - return "n.a."; + return type.getOldTypeOptional() + .orElseGet(() -> type.getNewTypeOptional().orElse("n.a.")); } private void processSuperclassChanges(StringBuilder sb, JApiClass jApiClass) { @@ -549,12 +536,9 @@ private void processSuperclassChanges(StringBuilder sb, JApiClass jApiClass) { private String superclassChangeAsString(JApiSuperclass jApiSuperclass) { if (jApiSuperclass.getOldSuperclassName().isPresent() && jApiSuperclass.getNewSuperclassName().isPresent()) { return jApiSuperclass.getNewSuperclassName().get() + " (<- " + jApiSuperclass.getOldSuperclassName().get() + ")"; - } else if (jApiSuperclass.getOldSuperclassName().isPresent() && !jApiSuperclass.getNewSuperclassName().isPresent()) { - return jApiSuperclass.getOldSuperclassName().get(); - } else if (!jApiSuperclass.getOldSuperclassName().isPresent() && jApiSuperclass.getNewSuperclassName().isPresent()) { - return jApiSuperclass.getNewSuperclassName().get(); } - return "n.a."; + return jApiSuperclass.getOldSuperclassName() + .orElseGet(() -> jApiSuperclass.getNewSuperclassName().orElse("n.a.")); } private void processInterfaceChanges(StringBuilder sb, JApiClass jApiClass) { diff --git a/japicmp/src/main/java/japicmp/output/xml/XmlOutputGenerator.java b/japicmp/src/main/java/japicmp/output/xml/XmlOutputGenerator.java index 6a7b9541..7e66ca64 100644 --- a/japicmp/src/main/java/japicmp/output/xml/XmlOutputGenerator.java +++ b/japicmp/src/main/java/japicmp/output/xml/XmlOutputGenerator.java @@ -53,17 +53,20 @@ public XmlOutput generate() { } public static List writeToFiles(Options options, XmlOutput xmlOutput) { + return xmlOutput.getXmlOutputStream() + .flatMap(out -> options.getXmlOutputFile().map(file -> writeToFiles(out, file, xmlOutput))) + .orElseGet(ArrayList::new); + } + + private static List writeToFiles(ByteArrayOutputStream outputStream, String xmlOutputFile, XmlOutput xmlOutput) { List filesWritten = new ArrayList<>(); try { - if (xmlOutput.getXmlOutputStream().isPresent() && options.getXmlOutputFile().isPresent()) { - File xmlFile = new File(options.getXmlOutputFile().get()); - try (FileOutputStream fos = new FileOutputStream(xmlFile)) { - ByteArrayOutputStream outputStream = xmlOutput.getXmlOutputStream().get(); - outputStream.writeTo(fos); - filesWritten.add(xmlFile); - } catch (IOException e) { - throw new JApiCmpException(JApiCmpException.Reason.IoException, "Failed to write XML file '" + xmlFile.getAbsolutePath() + "': " + e.getMessage(), e); - } + File xmlFile = new File(xmlOutputFile); + try (FileOutputStream fos = new FileOutputStream(xmlFile)) { + outputStream.writeTo(fos); + filesWritten.add(xmlFile); + } catch (IOException e) { + throw new JApiCmpException(JApiCmpException.Reason.IoException, "Failed to write XML file '" + xmlFile.getAbsolutePath() + "': " + e.getMessage(), e); } } finally { try { @@ -136,9 +139,7 @@ private JApiCmpXmlRoot createRootElement(List jApiClasses, Options op jApiCmpXmlRoot.setPackagesExclude(filtersAsString(options.getExcludes(), false)); jApiCmpXmlRoot.setIgnoreMissingClasses(options.getIgnoreMissingClasses().isIgnoreAllMissingClasses()); jApiCmpXmlRoot.setIgnoreMissingClassesByRegularExpressions(regExAsString(options.getIgnoreMissingClasses().getIgnoreMissingClassRegularExpression())); - if (xmlOutputGeneratorOptions.getTitle().isPresent()) { - jApiCmpXmlRoot.setTitle(xmlOutputGeneratorOptions.getTitle().get()); - } + xmlOutputGeneratorOptions.getTitle().ifPresent(jApiCmpXmlRoot::setTitle); jApiCmpXmlRoot.setSemanticVersioning(xmlOutputGeneratorOptions.getSemanticVersioningInformation()); return jApiCmpXmlRoot; } diff --git a/japicmp/src/main/java/japicmp/output/xml/model/JApiCmpXmlRoot.java b/japicmp/src/main/java/japicmp/output/xml/model/JApiCmpXmlRoot.java index 0d906cfc..38be48df 100644 --- a/japicmp/src/main/java/japicmp/output/xml/model/JApiCmpXmlRoot.java +++ b/japicmp/src/main/java/japicmp/output/xml/model/JApiCmpXmlRoot.java @@ -120,13 +120,7 @@ public void setIgnoreMissingClasses(boolean ignoreMissingClasses) { @XmlAttribute public String getTitle() { - String title; - if (this.titleOptional.isPresent()) { - title = this.titleOptional.get(); - } else { - title = "JApiCmp-Report"; - } - return title; + return this.titleOptional.orElse("JApiCmp-Report"); } public void setTitle(String title) { diff --git a/japicmp/src/main/java/japicmp/util/ModifierHelper.java b/japicmp/src/main/java/japicmp/util/ModifierHelper.java index 314e1c4e..9a938b17 100644 --- a/japicmp/src/main/java/japicmp/util/ModifierHelper.java +++ b/japicmp/src/main/java/japicmp/util/ModifierHelper.java @@ -68,20 +68,12 @@ public static AccessModifier translateToModifierLevel(int modifier) { public static boolean isNotPrivate(JApiHasAccessModifier jApiHasAccessModifier) { JApiModifier accessModifier = jApiHasAccessModifier.getAccessModifier(); - if (accessModifier.getOldModifier().isPresent() && accessModifier.getNewModifier().isPresent()) { - if (accessModifier.getNewModifier().get().getLevel() > AccessModifier.PRIVATE.getLevel() || accessModifier.getOldModifier().get().getLevel() > AccessModifier.PRIVATE.getLevel()) { - return true; - } - } else if (!accessModifier.getOldModifier().isPresent() && accessModifier.getNewModifier().isPresent()) { - if (accessModifier.getNewModifier().get().getLevel() > AccessModifier.PRIVATE.getLevel()) { - return true; - } - } else if (accessModifier.getOldModifier().isPresent() && !accessModifier.getNewModifier().isPresent()) { - if (accessModifier.getOldModifier().get().getLevel() > AccessModifier.PRIVATE.getLevel()) { - return true; - } - } - return false; + return accessModifier.getOldModifier().map(ModifierHelper::isNotPrivate).orElse(false) + || accessModifier.getNewModifier().map(ModifierHelper::isNotPrivate).orElse(false); + } + + private static boolean isNotPrivate(AccessModifier accessModifier) { + return accessModifier != AccessModifier.PRIVATE; } public static boolean hasModifierLevelDecreased(JApiHasAccessModifier hasAccessModifier) { @@ -246,51 +238,26 @@ public static Optional getNewModifierName(JApiModifier getModifierName(Optional> modifier) { - return !modifier.isPresent() || IGNORED_MODIFIERS.contains(modifier.get()) ? Optional.empty() : - Optional.of(modifier.get().name().toLowerCase()); + return modifier.filter(x -> !IGNORED_MODIFIERS.contains(x)) + .map(Enum::name) + .map(String::toLowerCase); } private static boolean hasSyntheticAttribute(JApiAttribute syntheticAttribute) { - boolean hasSyntheticAttribute = false; + final boolean oldIsSynthetic = syntheticAttribute.getOldAttribute().map(SyntheticAttribute.SYNTHETIC::equals).orElse(false); + final boolean newIsSynthetic = syntheticAttribute.getNewAttribute().map(SyntheticAttribute.SYNTHETIC::equals).orElse(false); if (syntheticAttribute.getOldAttribute().isPresent() && syntheticAttribute.getNewAttribute().isPresent()) { - SyntheticAttribute oldAttribute = syntheticAttribute.getOldAttribute().get(); - SyntheticAttribute newAttribute = syntheticAttribute.getNewAttribute().get(); - if (oldAttribute == SyntheticAttribute.SYNTHETIC && newAttribute == SyntheticAttribute.SYNTHETIC) { - hasSyntheticAttribute = true; - } - } else if (syntheticAttribute.getOldAttribute().isPresent()) { - SyntheticAttribute oldAttribute = syntheticAttribute.getOldAttribute().get(); - if (oldAttribute == SyntheticAttribute.SYNTHETIC) { - hasSyntheticAttribute = true; - } - } else if (syntheticAttribute.getNewAttribute().isPresent()) { - SyntheticAttribute newAttribute = syntheticAttribute.getNewAttribute().get(); - if (newAttribute == SyntheticAttribute.SYNTHETIC) { - hasSyntheticAttribute = true; - } + return oldIsSynthetic && newIsSynthetic; } - return hasSyntheticAttribute; + return oldIsSynthetic || newIsSynthetic; } private static boolean hasSyntheticModifier(JApiModifier syntheticModifier) { - boolean hasSyntheticModifier = false; + final boolean oldIsSynthetic = syntheticModifier.getOldModifier().map(SyntheticModifier.SYNTHETIC::equals).orElse(false); + final boolean newIsSynthetic = syntheticModifier.getNewModifier().map(SyntheticModifier.SYNTHETIC::equals).orElse(false); if (syntheticModifier.getOldModifier().isPresent() && syntheticModifier.getNewModifier().isPresent()) { - SyntheticModifier oldModifier = syntheticModifier.getOldModifier().get(); - SyntheticModifier newModifier = syntheticModifier.getNewModifier().get(); - if (oldModifier == SyntheticModifier.SYNTHETIC && newModifier == SyntheticModifier.SYNTHETIC) { - hasSyntheticModifier = true; - } - } else if (syntheticModifier.getOldModifier().isPresent()) { - SyntheticModifier oldModifier = syntheticModifier.getOldModifier().get(); - if (oldModifier == SyntheticModifier.SYNTHETIC) { - hasSyntheticModifier = true; - } - } else if (syntheticModifier.getNewModifier().isPresent()) { - SyntheticModifier newModifier = syntheticModifier.getNewModifier().get(); - if (newModifier == SyntheticModifier.SYNTHETIC) { - hasSyntheticModifier = true; - } + return oldIsSynthetic && newIsSynthetic; } - return hasSyntheticModifier; + return oldIsSynthetic || newIsSynthetic; } } diff --git a/japicmp/src/main/java/japicmp/util/OptionalHelper.java b/japicmp/src/main/java/japicmp/util/OptionalHelper.java index b1affeb8..a2c6c96c 100644 --- a/japicmp/src/main/java/japicmp/util/OptionalHelper.java +++ b/japicmp/src/main/java/japicmp/util/OptionalHelper.java @@ -10,9 +10,6 @@ private OptionalHelper() { } public static String optionalToString(Optional optional) { - if (optional.isPresent()) { - return optional.get().toString(); - } - return N_A; + return optional.map(Object::toString).orElse(N_A); } } diff --git a/japicmp/src/main/java/japicmp/versioning/VersionChange.java b/japicmp/src/main/java/japicmp/versioning/VersionChange.java index f78a933a..7247ad46 100644 --- a/japicmp/src/main/java/japicmp/versioning/VersionChange.java +++ b/japicmp/src/main/java/japicmp/versioning/VersionChange.java @@ -49,10 +49,7 @@ public Optional computeChangeType() throws JApiCmpEx for (int i=0; i changeTypeOptional = oldVersion.computeChangeType(newVersion); - if (changeTypeOptional.isPresent()) { - changeTypes.add(changeTypeOptional.get()); - } + oldVersion.computeChangeType(newVersion).ifPresent(changeTypes::add); } SemanticVersion.ChangeType maxRank = SemanticVersion.ChangeType.UNCHANGED; for (SemanticVersion.ChangeType changeType : changeTypes) {