Examples of org.locationtech.geogig.api.RevTree

org.locationtech.geogig.api.RevTree
Provides an interface for accessing and managing GeoGig revision trees. @see Node

        RevTree revTree = targetDb.getTree(treeId);
        return revTree;
    }


    private Optional<NodeRef> getTreeChild(RevTreeBuilder parent, String childPath) {
        RevTree realParent = parent.build();
        FindTreeChild cmd = command(FindTreeChild.class).setIndex(true).setParent(realParent)
                .setChildPath(childPath);


        Optional<NodeRef> nodeRef = cmd.call();
        return nodeRef;

View Full Code Here

     */
    @Override
    protected ObjectId _call() {
        final ProgressListener progress = getProgressListener();


        final RevTree oldRootTree = resolveRootTree();
        final ObjectDatabase repositoryDatabase = objectDatabase();


        Iterator<DiffEntry> diffs = null;
        long numChanges = 0;
        if (diffSupplier == null) {
            diffs = index().getStaged(pathFilters);
            numChanges = index().countStaged(pathFilters).count();
        } else {
            diffs = diffSupplier.get();
        }


        if (!diffs.hasNext()) {
            return oldRootTree.getId();
        }
        if (progress.isCanceled()) {
            return null;
        }


        Map<String, RevTreeBuilder> repositoryChangedTrees = Maps.newHashMap();
        Map<String, NodeRef> indexChangedTrees = Maps.newHashMap();
        Map<String, ObjectId> changedTreesMetadataId = Maps.newHashMap();
        Set<String> deletedTrees = Sets.newHashSet();
        final boolean moveObjects = this.moveObjects;
        NodeRef ref;
        int i = 0;
        RevTree stageHead = index().getTree();
        while (diffs.hasNext()) {
            if (numChanges != 0) {
                progress.setProgress((float) (++i * 100) / numChanges);
            }
            if (progress.isCanceled()) {
                return null;
            }


            DiffEntry diff = diffs.next();
            // ignore the root entry
            if (NodeRef.ROOT.equals(diff.newName()) || NodeRef.ROOT.equals(diff.oldName())) {
                continue;
            }
            ref = diff.getNewObject();


            if (ref == null) {
                ref = diff.getOldObject();
            }


            final String parentPath = ref.getParentPath();
            final boolean isDelete = ChangeType.REMOVED.equals(diff.changeType());
            final TYPE type = ref.getType();
            if (isDelete && deletedTrees.contains(parentPath)) {
                // this is to avoid re-creating the parentTree for a feature delete after its parent
                // tree delete entry was processed
                continue;
            }
            RevTreeBuilder parentTree = resolveTargetTree(oldRootTree, parentPath,
                    repositoryChangedTrees, changedTreesMetadataId, ObjectId.NULL,
                    repositoryDatabase);
            if (type == TYPE.TREE && !isDelete) {
                // cache the tree
                resolveTargetTree(oldRootTree, ref.name(), repositoryChangedTrees,
                        changedTreesMetadataId, ref.getMetadataId(), repositoryDatabase);
            }


            resolveSourceTreeRef(parentPath, indexChangedTrees, changedTreesMetadataId, stageHead);


            Preconditions.checkState(parentTree != null);


            if (isDelete) {
                String oldName = diff.getOldObject().getNode().getName();
                parentTree.remove(oldName);
                if (TYPE.TREE.equals(type)) {
                    deletedTrees.add(ref.path());
                }
            } else {
                if (moveObjects && ref.getType().equals(TYPE.TREE)) {
                    RevTree tree = stagingDatabase().getTree(ref.objectId());
                    if (!ref.getMetadataId().isNull()) {
                        repositoryDatabase.put(stagingDatabase()
                                .getFeatureType(ref.getMetadataId()));
                    }
                    if (tree.isEmpty()) {
                        repositoryDatabase.put(tree);
                    } else {
                        continue;
                    }
                } else if (moveObjects) {
                    deepMove(ref.getNode());
                }
                parentTree.put(ref.getNode());
            }
        }


        if (progress.isCanceled()) {
            return null;
        }


        // now write back all changed trees
        ObjectId newTargetRootId = oldRootTree.getId();
        RevTreeBuilder directRootEntries = repositoryChangedTrees.remove(NodeRef.ROOT);
        if (directRootEntries != null) {
            RevTree newRoot = directRootEntries.build();
            repositoryDatabase.put(newRoot);
            newTargetRootId = newRoot.getId();
        }
        for (Map.Entry<String, RevTreeBuilder> e : repositoryChangedTrees.entrySet()) {
            String treePath = e.getKey();
            ObjectId metadataId = changedTreesMetadataId.get(treePath);
            RevTreeBuilder treeBuilder = e.getValue();
            RevTree newRoot = getTree(newTargetRootId);
            RevTree tree = treeBuilder.build();
            newTargetRootId = writeBack(newRoot.builder(repositoryDatabase), tree, treePath,
                    metadataId);
        }


        progress.complete();

View Full Code Here

    /**
     * @return the resolved root tree id
     */
    private ObjectId resolveRootTreeId() {
        if (oldRoot != null) {
            RevTree rootTree = oldRoot.get();
            return rootTree.getId();
        }
        ObjectId targetTreeId = command(ResolveTreeish.class).setTreeish(Ref.HEAD).call().get();
        return targetTreeId;
    }

View Full Code Here

    @Override
    protected DiffObjectCount _call() {
        checkState(oldRefSpec != null, "old ref spec not provided");
        checkState(newRefSpec != null, "new ref spec not provided");


        final RevTree oldTree = getTree(oldRefSpec);
        final RevTree newTree = getTree(newRefSpec);


        DiffObjectCount diffCount;
        StagingDatabase index = stagingDatabase();
        PreOrderDiffWalk visitor = new PreOrderDiffWalk(oldTree, newTree, index, index);

View Full Code Here

    /**
     * @return the tree referenced by the old ref, or the head of the index.
     */
    private RevTree getTree(String refSpec) {


        final RevTree headTree;
        Optional<ObjectId> resolved = command(ResolveTreeish.class).setTreeish(refSpec).call();
        if (resolved.isPresent()) {
            ObjectId headTreeId = resolved.get();
            headTree = command(RevObjectParse.class).setObjectId(headTreeId).call(RevTree.class)
                    .get();

View Full Code Here

    @Override
    protected Iterator<DiffEntry> _call() {


        final Optional<String> ref = Optional.fromNullable(refSpec);


        final RevTree oldTree = ref.isPresent() ? getOldTree() : index().getTree();
        final RevTree newTree = workingTree().getTree();


        DiffTree diff = command(DiffTree.class).setReportTrees(this.reportTrees)
                .setOldTree(oldTree.getId()).setNewTree(newTree.getId());
        if (this.pathFilter != null) {
            diff.setPathFilter(ImmutableList.of(pathFilter));
        }
        return diff.call();
    }

View Full Code Here

        final String oldVersion = Optional.fromNullable(refSpec).or(Ref.STAGE_HEAD);


        Optional<ObjectId> headTreeId = command(ResolveTreeish.class).setTreeish(oldVersion).call();
        Preconditions.checkArgument(headTreeId.isPresent(), "Refspec " + oldVersion
                + " does not resolve to a tree");
        final RevTree headTree;
        headTree = command(RevObjectParse.class).setObjectId(headTreeId.get()).call(RevTree.class)
                .get();


        return headTree;
    }

View Full Code Here

     *         {@link Optional#absent()} if it wasn't
     */
    @Override
    protected  Optional<NodeRef> _call() {
        checkNotNull(childPath, "childPath");
        final RevTree tree;
        if (parent == null) {
            ObjectId rootTreeId = command(ResolveTreeish.class).setTreeish(Ref.HEAD).call().get();
            if (rootTreeId.isNull()) {
                return Optional.absent();
            }

View Full Code Here

            String path = toMergeDiff.oldPath() == null ? toMergeDiff.newPath() : toMergeDiff
                    .oldPath();
            if (mergeIntoDiffs.containsKey(path)) {
                RevCommit ancestorCommit = command(RevObjectParse.class)
                        .setRefSpec(ancestor.get().toString()).call(RevCommit.class).get();
                RevTree ancestorTree = command(RevObjectParse.class)
                        .setObjectId(ancestorCommit.getTreeId()).call(RevTree.class).get();
                Optional<NodeRef> ancestorVersion = command(FindTreeChild.class).setChildPath(path)
                        .setParent(ancestorTree).call();
                ObjectId ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion.get()
                        .getNode().getObjectId() : ObjectId.NULL;
                ObjectId theirs = toMergeDiff.getNewObject() == null ? ObjectId.NULL : toMergeDiff
                        .getNewObject().objectId();
                DiffEntry mergeIntoDiff = mergeIntoDiffs.get(path);
                ObjectId ours = mergeIntoDiff.getNewObject() == null ? ObjectId.NULL
                        : mergeIntoDiff.getNewObject().objectId();
                if (!mergeIntoDiff.changeType().equals(toMergeDiff.changeType())) {
                    report.addConflict(new Conflict(path, ancestorVersionId, ours, theirs));
                    continue;
                }
                switch (toMergeDiff.changeType()) {
                case ADDED:
                    if (toMergeDiff.getNewObject().equals(mergeIntoDiff.getNewObject())) {
                        // already added in current branch, no need to do anything
                    } else {
                        TYPE type = command(ResolveObjectType.class).setObjectId(
                                toMergeDiff.getNewObject().objectId()).call();
                        if (TYPE.TREE.equals(type)) {
                            boolean conflict = !toMergeDiff.getNewObject().getMetadataId()
                                    .equals(mergeIntoDiff.getNewObject().getMetadataId());
                            if (conflict) {
                                // In this case, we store the metadata id, not the element id
                                ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion
                                        .get().getMetadataId() : ObjectId.NULL;
                                ours = mergeIntoDiff.getNewObject().getMetadataId();
                                theirs = toMergeDiff.getNewObject().getMetadataId();
                                report.addConflict(new Conflict(path, ancestorVersionId, ours,
                                        theirs));
                            }
                            // if the metadata ids match, it means both branches have added the same
                            // tree, maybe with different content, but there is no need to do
                            // anything. The correct tree is already there and the merge can be run
                            // safely, so we do not add it neither as a conflicted change nor as an
                            // unconflicted one
                        } else {
                            report.addConflict(new Conflict(path, ancestorVersionId, ours, theirs));
                        }
                    }
                    break;
                case REMOVED:
                    // removed by both histories => no conflict and no need to do anything
                    break;
                case MODIFIED:
                    TYPE type = command(ResolveObjectType.class).setObjectId(
                            toMergeDiff.getNewObject().objectId()).call();
                    if (TYPE.TREE.equals(type)) {
                        boolean conflict = !toMergeDiff.getNewObject().getMetadataId()
                                .equals(mergeIntoDiff.getNewObject().getMetadataId());
                        if (conflict) {
                            // In this case, we store the metadata id, not the element id
                            ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion.get()
                                    .getMetadataId() : ObjectId.NULL;
                            ours = mergeIntoDiff.getNewObject().getMetadataId();
                            theirs = toMergeDiff.getNewObject().getMetadataId();
                            report.addConflict(new Conflict(path, ancestorVersionId, ours, theirs));
                        }
                    } else {
                        FeatureDiff toMergeFeatureDiff = command(DiffFeature.class)
                                .setOldVersion(Suppliers.ofInstance(toMergeDiff.getOldObject()))
                                .setNewVersion(Suppliers.ofInstance(toMergeDiff.getNewObject()))
                                .call();
                        FeatureDiff mergeIntoFeatureDiff = command(DiffFeature.class)
                                .setOldVersion(Suppliers.ofInstance(mergeIntoDiff.getOldObject()))
                                .setNewVersion(Suppliers.ofInstance(mergeIntoDiff.getNewObject()))
                                .call();
                        if (toMergeFeatureDiff.conflicts(mergeIntoFeatureDiff)) {
                            report.addConflict(new Conflict(path, ancestorVersionId, ours, theirs));
                        } else {
                            // if the feature types are different we report a conflict and do not
                            // try to perform automerge
                            if (!toMergeDiff.getNewObject().getMetadataId()
                                    .equals(mergeIntoDiff.getNewObject().getMetadataId())) {
                                report.addConflict(new Conflict(path, ancestorVersionId, ours,
                                        theirs));
                            } else if (!toMergeFeatureDiff.equals(mergeIntoFeatureDiff)) {
                                Feature mergedFeature = command(MergeFeaturesOp.class)
                                        .setFirstFeature(mergeIntoDiff.getNewObject())
                                        .setSecondFeature(toMergeDiff.getNewObject())
                                        .setAncestorFeature(mergeIntoDiff.getOldObject()).call();
                                RevFeature revFeature = RevFeatureBuilder.build(mergedFeature);
                                if (revFeature.getId().equals(toMergeDiff.newObjectId())) {
                                    // the resulting merged feature equals the feature to merge from
                                    // the branch, which means that it exists in the repo and there
                                    // is no need to add it
                                    report.addUnconflicted(toMergeDiff);
                                } else {
                                    RevFeatureType featureType = command(RevObjectParse.class)
                                            .setObjectId(
                                                    mergeIntoDiff.getNewObject().getMetadataId())
                                            .call(RevFeatureType.class).get();
                                    FeatureInfo merged = new FeatureInfo(mergedFeature,
                                            featureType, path);
                                    report.addMerged(merged);
                                }
                            }
                        }
                    }
                    break;
                }
            } else {
                // If the element is a tree, not a feature, it might be a conflict even if the other
                // branch has not modified it.
                // If we are removing the tree, we have to make sure that there are no features
                // modified in the other branch under it.
                if (ChangeType.REMOVED.equals(toMergeDiff.changeType())) {
                    TYPE type = command(ResolveObjectType.class).setObjectId(
                            toMergeDiff.oldObjectId()).call();
                    if (TYPE.TREE.equals(type)) {
                        String parentPath = toMergeDiff.oldPath();
                        Set<Entry<String, DiffEntry>> entries = mergeIntoDiffs.entrySet();
                        boolean conflict = false;
                        for (Entry<String, DiffEntry> entry : entries) {
                            if (entry.getKey().startsWith(parentPath)) {
                                if (!ChangeType.REMOVED.equals(entry.getValue().changeType())) {
                                    RevCommit ancestorCommit = command(RevObjectParse.class)
                                            .setRefSpec(ancestor.get().toString())
                                            .call(RevCommit.class).get();
                                    RevTree ancestorTree = command(RevObjectParse.class)
                                            .setObjectId(ancestorCommit.getTreeId())
                                            .call(RevTree.class).get();
                                    Optional<NodeRef> ancestorVersion = command(FindTreeChild.class)
                                            .setChildPath(path).setParent(ancestorTree).call();
                                    ObjectId ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion

View Full Code Here

                    ref.lastIndexOf(':')) : null;
            if (providedRefName != null) {
                Optional<ObjectId> rootTreeId = command(ResolveTreeish.class).setTreeish(
                        providedRefName).call();
                if (rootTreeId.isPresent()) {
                    RevTree rootTree = command(RevObjectParse.class).setObjectId(rootTreeId.get())
                            .call(RevTree.class).get();


                    Optional<NodeRef> treeRef = command(FindTreeChild.class).setChildPath(path)
                            .setIndex(true).setParent(rootTree).call();
                    metadataId = treeRef.isPresent() ? treeRef.get().getMetadataId()
                            : ObjectId.NULL;
                }
            }
        }


        // is it just a ref name?
        Optional<Ref> reference = command(RefParse.class).setName(ref).call();
        if (reference.isPresent()) {
            if (reference.get().getObjectId().isNull()) {
                return Iterators.emptyIterator();
            }
        }
        Optional<RevObject> revObject = command(RevObjectParse.class).setRefSpec(ref).call(
                RevObject.class);


        Optional<NodeRef> treeRef = Optional.absent();


        if (!revObject.isPresent()) {
            if (Ref.WORK_HEAD.equals(ref)) { // we are requesting a listing of the whole working
                                             // tree but it is empty
                return Iterators.emptyIterator();
            }
            // let's try to see if it is a feature type or feature in the working tree
            NodeRef.checkValidPath(ref);


            treeRef = command(FindTreeChild.class).setParent(workingTree().getTree())
                    .setChildPath(ref).setIndex(true).call();


            Preconditions.checkArgument(treeRef.isPresent(), "Invalid reference: %s", ref);
            ObjectId treeId = treeRef.get().objectId();
            metadataId = treeRef.get().getMetadataId();
            revObject = command(RevObjectParse.class).setObjectId(treeId).call(RevObject.class);
        }


        checkArgument(revObject.isPresent(), "Invalid reference: %s", ref);


        final TYPE type = revObject.get().getType();
        switch (type) {
        case FEATURE:
            NodeRef nodeRef = treeRef.isPresent() ? treeRef.get() : null;
            List<NodeRef> nodeRefs = Lists.newArrayList();
            nodeRefs.add(nodeRef);
            // If show trees options is passed in show all trees that contain this feature
            if (this.strategy == Strategy.TREES_ONLY) {
                if (nodeRef != null) {
                    while (!nodeRef.getParentPath().isEmpty()) {
                        treeRef = command(FindTreeChild.class).setParent(workingTree().getTree())
                                .setChildPath(nodeRef.getParentPath()).setIndex(true).call();
                        nodeRef = treeRef.get();
                        nodeRefs.add(nodeRef);
                    }
                }
            }
            return nodeRefs.iterator();
        case COMMIT:
            RevCommit revCommit = (RevCommit) revObject.get();
            ObjectId treeId = revCommit.getTreeId();
            revObject = command(RevObjectParse.class).setObjectId(treeId).call(RevObject.class);
        case TREE:


            DepthTreeIterator.Strategy iterStrategy;


            switch (this.strategy) {
            case CHILDREN:
                iterStrategy = DepthTreeIterator.Strategy.CHILDREN;
                break;
            case FEATURES_ONLY:
                iterStrategy = DepthTreeIterator.Strategy.FEATURES_ONLY;
                break;
            case TREES_ONLY:
                iterStrategy = DepthTreeIterator.Strategy.TREES_ONLY;
                break;
            case DEPTHFIRST:
                iterStrategy = DepthTreeIterator.Strategy.RECURSIVE;
                break;
            case DEPTHFIRST_ONLY_FEATURES:
                iterStrategy = DepthTreeIterator.Strategy.RECURSIVE_FEATURES_ONLY;
                break;
            case DEPTHFIRST_ONLY_TREES:
                iterStrategy = DepthTreeIterator.Strategy.RECURSIVE_TREES_ONLY;
                break;
            default:
                throw new IllegalStateException("Unknown strategy: " + this.strategy);
            }


            RevTree tree = (RevTree) revObject.get();
            ObjectDatabase database = stagingDatabase();
            DepthTreeIterator iter = new DepthTreeIterator(path, metadataId, tree, database,
                    iterStrategy);
            iter.setBoundsFilter(refBoundsFilter);
            return iter;

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.locationtech.geogig.api.RevTree

org.locationtech.geogig.api.plumbing.CatObjectTest

org.locationtech.geogig.api.plumbing.DeepMove$AllTrees

org.locationtech.geogig.api.plumbing.diff.DepthTreeIterator$Buckets

org.locationtech.geogig.api.plumbing.diff.DepthTreeIterator$FeatureBuckets

org.locationtech.geogig.api.plumbing.diff.DepthTreeIterator$Recursive

org.locationtech.geogig.api.plumbing.diff.DepthTreeIterator$TreeBuckets

org.locationtech.geogig.api.plumbing.diff.DepthTreeIteratorTest

org.locationtech.geogig.api.plumbing.diff.DiffCountConsumer

org.locationtech.geogig.api.plumbing.diff.DiffCountConsumerTest

org.locationtech.geogig.api.plumbing.diff.MutableTree

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.