How to use org.datacleaner.result.save

public void saveWithoutUnsafeResultElements() {
  final AnalysisResult safeAnalysisResult = createSafeAnalysisResult();
  saveOrThrow(safeAnalysisResult, _resource);
}

public boolean saveAttempt() {
  try {
    saveOrThrow();
    return true;
  } catch (final SerializationException e) {
    return false;
  }
}

private static void saveResult(final AnalysisResultFuture result, final Resource resultResource) {
  final AnalysisResultSaveHandler analysisResultSaveHandler =
      new AnalysisResultSaveHandler(result, resultResource);
  try {
    analysisResultSaveHandler.saveOrThrow();
  } catch (final SerializationException e) {
    // attempt to save what we can - and then rethrow
    final AnalysisResult safeAnalysisResult = analysisResultSaveHandler.createSafeAnalysisResult();
    if (safeAnalysisResult == null) {
      logger.error("Serialization of result failed without any safe result elements to persist");
    } else {
      final Map<ComponentJob, AnalyzerResult> unsafeResultElements =
          analysisResultSaveHandler.getUnsafeResultElements();
      logger.error("Serialization of result failed with the following unsafe elements: {}",
          unsafeResultElements);
      logger.warn("Partial AnalysisResult will be persisted to filename '{}'",
          resultResource.getQualifiedPath());
      analysisResultSaveHandler.saveWithoutUnsafeResultElements();
    }
    // rethrow the exception regardless
    throw e;
  }
}

    new AnalysisResultSaveHandler(_result.get(), new FileResource(file));
final boolean success = saveHandler.saveAttempt();
if (!success) {
  final AnalysisResult safeAnalysisResult = saveHandler.createSafeAnalysisResult();
  if (safeAnalysisResult == null) {
    WidgetUtils.showErrorMessage("Error writing result to file!", "See the log for error details.");
  } else {
    final Map<ComponentJob, AnalyzerResult> unsafeResultElements =
        saveHandler.getUnsafeResultElements();
    if (confirmation == JOptionPane.OK_OPTION) {
      saveHandler.saveWithoutUnsafeResultElements();

  /**
   * Creates a safe {@link AnalysisResult} for saving
   *
   * @return a new {@link AnalysisResult} or null if it is not possible to
   *         create a result that is safer than the previous.
   */
  public AnalysisResult createSafeAnalysisResult() {
    final Set<ComponentJob> unsafeKeys = getUnsafeResultElements().keySet();
    if (unsafeKeys.isEmpty()) {
      return _analysisResult;
    }

    final Map<ComponentJob, AnalyzerResult> resultMap = new LinkedHashMap<>(_analysisResult.getResultMap());
    for (final ComponentJob unsafeKey : unsafeKeys) {
      resultMap.remove(unsafeKey);
    }

    if (resultMap.isEmpty()) {
      return null;
    }

    return new SimpleAnalysisResult(resultMap, _analysisResult.getCreationDate());
  }
}

final RepositoryFile file = _resultFolder.createFile(resultFilename, new NoopAction<OutputStream>());
final Resource resource = new RepositoryFileResource(file);
final AnalysisResultSaveHandler analysisResultSaveHandler = new AnalysisResultSaveHandler((AnalysisResult) result, resource);
try {
  analysisResultSaveHandler.saveOrThrow();
} catch (SerializationException e) {
  final AnalysisResult safeAnalysisResult = analysisResultSaveHandler.createSafeAnalysisResult();
  if (safeAnalysisResult == null) {
    logger.error("Serialization of result failed without any safe result elements to persist");
  } else {
    final Map<ComponentJob, AnalyzerResult> unsafeResultElements = analysisResultSaveHandler.getUnsafeResultElements();
    logger.error("Serialization of result failed with the following unsafe elements: {}", unsafeResultElements);
    logger.warn("Partial AnalysisResult will be persisted to filename '{}'", resultFilename);
    analysisResultSaveHandler.saveWithoutUnsafeResultElements();

public void saveOrThrow() throws SerializationException {
  saveOrThrow(_analysisResult, _resource);
}