How to use

isPresent

method

in

japicmp.util.Optional

private static void toJarArchiveComparatorClassPath(Optional<String> classPathOptional, List<String> comparatorClassPath) {
  if (classPathOptional.isPresent()) {
    String classPathAsString = classPathOptional.get();
    Collections.addAll(comparatorClassPath, classPathAsString.split(File.pathSeparator));
  }
}

@XmlAttribute
public String getTitle() {
  String title;
  if (this.titleOptional.isPresent()) {
    title = this.titleOptional.get();
  } else {
    title = "JApiCmp-Report";
  }
  return title;
}

  public boolean hasChanged() {
    boolean hasChanged = false;
    if (oldTypeOptional.isPresent() && newTypeOptional.isPresent()) {
      if (!oldTypeOptional.get().equals(newTypeOptional.get())) {
        hasChanged = true;
      }
    }
    return hasChanged;
  }
}

public boolean hasChangedFromTo(T oldValue, T newValue) {
  boolean hasChanged = false;
  if (oldModifier.isPresent() && newModifier.isPresent()) {
    if (oldModifier.get() == oldValue && newModifier.get() == newValue) {
      hasChanged = true;
    }
  }
  return hasChanged;
}

  public boolean hasChangedTo(T value) {
    boolean hasChangedTo = false;
    if (newModifier.isPresent()) {
      T newValue = newModifier.get();
      if (value == newValue) {
        hasChangedTo = true;
      }
    }
    return hasChangedTo;
  }
}

  public static <T> String optionalToString(Optional<T> optional) {
    if (optional.isPresent()) {
      return optional.get().toString();
    }
    return N_A;
  }
}

public boolean hasChangedFromTo(T oldValue, T newValue) {
  boolean hasChanged = false;
  if (oldModifier.isPresent() && newModifier.isPresent()) {
    if (oldModifier.get() == oldValue && newModifier.get() == newValue) {
      hasChanged = true;
    }
  }
  return hasChanged;
}

  public boolean hasChangedTo(T value) {
    boolean hasChangedTo = false;
    if (newModifier.isPresent()) {
      T newValue = newModifier.get();
      if (value == newValue) {
        hasChangedTo = true;
      }
    }
    return hasChangedTo;
  }
}

@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;
}

private String guessVersion(File file) {
  String name = file.getName();
  Optional<SemanticVersion> semanticVersion = japicmp.versioning.Version.getSemanticVersion(name);
  String version = semanticVersion.isPresent() ? semanticVersion.get().toString() : "n.a.";
  if (name.contains("SNAPSHOT")) {
    version += "-SNAPSHOT";
  }
  return version;
}

public static String toString(Optional<CtMethod> method) {
  if(method == null ) {
    return OptionalHelper.N_A;
  }
  if(method.isPresent()) {
    return method.get().getLongName();
  }
  return OptionalHelper.N_A;
}

private void buildInterfaceMap(JarArchiveComparator.ArchiveType archiveType, Map<String, CtClass> map, CtClass ctInterface) throws NotFoundException {
  Optional<CtClass> loadedInterfaceOptional = this.jarArchiveComparator.loadClass(archiveType, ctInterface.getName());
  if (loadedInterfaceOptional.isPresent()) {
    CtClass loadedInterface = loadedInterfaceOptional.get();
    CtClass[] loadedInterfaceInterfaces = loadedInterface.getInterfaces();
    for (CtClass additionalInterface : loadedInterfaceInterfaces) {
      map.put(additionalInterface.getName(), additionalInterface);
      buildInterfaceMap(archiveType, map, additionalInterface);
    }
  }
}

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.";
}

private Map<String, CtConstructor> createConstructorMap(Optional<CtClass> ctClass) {
  Map<String, CtConstructor> methods = new HashMap<>();
  if (ctClass.isPresent()) {
    for (CtConstructor ctConstructor : ctClass.get().getDeclaredConstructors()) {
      if (options.getFilters().includeBehavior(ctConstructor)) {
        methods.put(ctConstructor.getLongName(), ctConstructor);
      }
    }
  }
  return methods;
}

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;
    }
  }
  return matches;
}

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;
    }
  }
  return matches;
}

  @Override
  public JApiSuperclass callback(JApiClass clazz, Map<String, JApiClass> classMap, JApiChangeStatus changeStatusOfSuperclass) {
    JApiSuperclass ancestor = clazz.getSuperclass();
    if (ancestor.getNewSuperclassName().isPresent() && ancestor.getNewSuperclassName().get().equals(superclass.getOldSuperclassName().get())) {
      matchingAncestors.add(ancestor);
    }
    return ancestor;
  }
});

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, JApiCompatibilityChange.CLASS_NOW_CHECKED_EXCEPTION);
      }
    }
  }
}

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, JApiCompatibilityChange.CLASS_NOW_CHECKED_EXCEPTION);
      }
    }
  }
}

public static boolean hasModifierLevelDecreased(JApiHasAccessModifier hasAccessModifier) {
  JApiModifier<AccessModifier> accessModifier = hasAccessModifier.getAccessModifier();
  if (accessModifier.getOldModifier().isPresent() && accessModifier.getNewModifier().isPresent()) {
    AccessModifier oldModifier = accessModifier.getOldModifier().get();
    AccessModifier newModifier = accessModifier.getNewModifier().get();
    if (newModifier.getLevel() < oldModifier.getLevel()) {
      return true;
    }
  }
  return false;
}