How to use

ObjectVersionGraph

in

org.javersion.object

public ObjectVersionManager<O, M> init() {
  this.versionGraph = ObjectVersionGraph.init();
  return this;
}

  @Override
  public ObjectVersionGraph<M> build() {
    return new ObjectVersionGraph<M>(this);
  }
}

@Override
public ListenableFuture<ObjectVersionGraph<M>> reload(Id docId, ObjectVersionGraph<M> oldValue) throws Exception {
  if (!oldValue.isEmpty()) {
    ObjectVersionGraph<M> newValue = oldValue;
    Revision since = oldValue.getTip().getRevision();
    try {
      List<ObjectVersion<M>> updates = versionStore.fetchUpdates(docId, since);
      log.debug("refresh({}): {})", docId, updates.size());
      if (!updates.isEmpty()) {
        newValue = oldValue.commit(updates);
      }
      return immediateFuture(compactIfRequired(newValue));
    } catch (VersionNotFoundException e) {
      // since revision is deleted - reload graph
    }
  }
  return immediateFuture(load(docId));
}

public static <M> Predicate<ObjectVersionGraph<M>> sizeExcludingHeadsExceeds(int compactThreshold) {
  Check.that(compactThreshold > 0, "compactThreshold should be > 0");
  return g -> g.size() - g.getHeads().size() >=  compactThreshold;
}

private void optimizeParentsAndProperties(ObjectVersionGraph<M> oldGraph, ObjectVersionGraph<M> newGraph) {
  newGraph.getVersionNodes().forEach(newVersionNode -> {
    VersionNode<PropertyPath, Object, M> oldVersionNode = oldGraph.getVersionNode(newVersionNode.revision);
    optimizeParents(newVersionNode.revision, oldVersionNode.getParentRevisions(), newVersionNode.getParentRevisions());
    optimizeProperties(newVersionNode.revision, oldVersionNode.getChangeset(), newVersionNode.getChangeset());
  });
}

private ObjectVersionGraph<M> compactIfRequired(ObjectVersionGraph<M> graph) {
  if (graphOptions.optimizeWhen.test(graph)) {
    return graph.optimize(graphOptions.optimizeKeep.apply(graph)).getGraph();
  } else {
    return graph;
  }
}

@Override
public ObjectVersionGraph<M> getGraph(Id docId, Iterable<Revision> revisions) {
  ObjectVersionGraph<M> graph = cacheLoader.apply(docId);
  if (!graph.containsAll(revisions)) {
    return getFullGraph(docId);
  }
  return graph;
}

private void insertOptimizedParentsAndProperties(ObjectVersionGraph<M> optimizedGraph) {
  optimizedGraph.getVersionNodes().forEach(node -> {
    insertParents(node);
    insertProperties(node);
  });
}

private OptimizedGraph<PropertyPath, Object, M, ObjectVersionGraph<M>> optimizedGraph(ObjectVersionGraph<M> graph, Predicate<VersionNode<PropertyPath, Object, M>> keep) {
  OptimizedGraph<PropertyPath, Object, M, ObjectVersionGraph<M>> optimizedGraph = graph.optimize(keep);
  if (optimizedGraph.getSquashedRevisions().isEmpty()) {
    return null;
  }
  if (optimizedGraph.getKeptRevisions().isEmpty()) {
    throw new IllegalArgumentException("keep-predicate didn't match any version");
  }
  return optimizedGraph;
}

  public ObjectVersionGraph<M> getVersionGraph(Id docId) {
    List<ObjectVersion<M>> versions = versionsByDocId.get(docId);
    return versions != null ? ObjectVersionGraph.init(versions) : null;
  }
}

public static <M> ObjectVersionGraph<M> init() {
  return new ObjectVersionGraph<M>();
}

public ObjectVersionManager<O, M> init(Iterable<ObjectVersion<M>> versions) {
  return init(ObjectVersionGraph.init(versions));
}

protected ObjectVersionGraph<M> toVersionGraph(Id docId, FetchResults<Id, M> fetchResults) {
  if (fetchResults.containsKey(docId)) {
    ObjectVersionGraph<M> graph;
    try {
      graph = ObjectVersionGraph.init(fetchResults.getVersions(docId));
      if (options.optimizeWhen.test(graph)) {
        optimizeAsync(docId, graph, false);
      }
    } catch (VersionNotFoundException e) {
      graph = doLoad(docId);
      optimizeAsync(docId, graph, true);
    }
    return graph;
  } else {
    return ObjectVersionGraph.init();
  }
}

protected ObjectVersionGraph<M> doLoad(Id docId) {
  FetchResults<Id, M> results = doFetch(docId, false);
  return results.containsKey(docId) ? results.getVersionGraph(docId) : ObjectVersionGraph.init();
}

@Override
public void optimize(Id docId, Function<ObjectVersionGraph<M>, Predicate<VersionNode<PropertyPath, Object, M>>> keep) {
  options.transactions.writeRequired(() -> {
    ObjectVersionGraph<M> graph;
    try {
      FetchResults<Id, M> fetchResults = doFetch(docId, true);
      graph = ObjectVersionGraph.init(fetchResults.getVersions(docId));
      doOptimize(docId, graph, keep, false);
    } catch (VersionNotFoundException e) {
      graph = doLoad(docId);
      doOptimize(docId, graph, keep, true);
    }
    return null;
  });
}