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