Package org.locationtech.geogig.api.plumbing.diff

Examples of org.locationtech.geogig.api.plumbing.diff.DiffEntry


        diffOp.setCompareIndex(true);
        diffOp.setFilter(path);
        Iterator<DiffEntry> diffs = diffOp.call();
        List<Feature> list = Lists.newArrayList();
        while (diffs.hasNext()) {
            DiffEntry diff = diffs.next();
            if (!diff.changeType().equals(ChangeType.REMOVED) || !noDeletions) {
                RevFeature revFeature = repository.command(RevObjectParse.class)
                        .setObjectId(diff.newObjectId()).call(RevFeature.class).get();
                RevFeatureType revFeatureType = repository.command(RevObjectParse.class)
                        .setObjectId(diff.getNewObject().getMetadataId())
                        .call(RevFeatureType.class).get();
                FeatureBuilder builder = new FeatureBuilder(revFeatureType);
                list.add(builder.build(diff.getNewObject().name(), revFeature));
            }
        }
        return list.toArray(new Feature[0]);
    }
View Full Code Here


    public Feature[] getUnstagedFeatures(String path, boolean noDeletions) {
        Iterator<DiffEntry> diffs = repository.workingTree().getUnstaged(path);
        List<Feature> list = Lists.newArrayList();
        while (diffs.hasNext()) {
            DiffEntry diff = diffs.next();
            if (!diff.changeType().equals(ChangeType.REMOVED) || !noDeletions) {
                RevFeature revFeature = repository.command(RevObjectParse.class)
                        .setObjectId(diff.newObjectId()).call(RevFeature.class).get();
                RevFeatureType revFeatureType = repository.command(RevObjectParse.class)
                        .setObjectId(diff.getNewObject().getMetadataId())
                        .call(RevFeatureType.class).get();
                FeatureBuilder builder = new FeatureBuilder(revFeatureType);
                list.add(builder.build(diff.getNewObject().name(), revFeature));
            }
        }
        return list.toArray(new Feature[0]);
    }
View Full Code Here

        byte[] oidbuffer = new byte[ObjectId.NUM_BYTES];

        long objectCount = 0;

        while (changes.hasNext()) {
            DiffEntry diff = changes.next();

            if (diff.isDelete()) {
                out.write(CHUNK_TYPE.DIFF_ENTRY.value());
            } else {
                // its a change or an addition, new object is guaranteed to be present
                NodeRef newObject = diff.getNewObject();
                ObjectId metadataId = newObject.getMetadataId();
                if (writtenMetadataIds.contains(metadataId)) {
                    out.write(CHUNK_TYPE.OBJECT_AND_DIFF_ENTRY.value());
                } else {
                    out.write(CHUNK_TYPE.METADATA_OBJECT_AND_DIFF_ENTRY.value());
View Full Code Here

            }
            default:
                throw new IllegalStateException("Unknown chunk type: " + chunkType);
            }

            DiffEntry diff = FormatCommonV1.readDiff(data);
            return new DiffPacket(diff, revObj, metadata);
        }
View Full Code Here

        Map<String, RevTreeBuilder> parentTress = Maps.newHashMap();
        Map<String, ObjectId> parentMetadataIds = Maps.newHashMap();
        Set<String> removedTrees = Sets.newHashSet();
        StagingDatabase database = getDatabase();
        while (unstaged.hasNext()) {
            final DiffEntry diff = unstaged.next();
            final String fullPath = diff.oldPath() == null ? diff.newPath() : diff.oldPath();
            final String parentPath = NodeRef.parentPath(fullPath);
            /*
             * TODO: revisit, ideally the list of diff entries would come with one single entry for
             * the whole removed tree instead of that one and every single children of it.
             */
            if (removedTrees.contains(parentPath)) {
                continue;
            }
            if (null == parentPath) {
                // it is the root tree that's been changed, update head and ignore anything else
                ObjectId newRoot = diff.newObjectId();
                updateStageHead(newRoot);
                progress.setProgress(100f);
                progress.complete();
                return;
            }
            RevTreeBuilder parentTree = getParentTree(currentIndexHead, parentPath, parentTress,
                    parentMetadataIds);

            i++;
            progress.setProgress((float) (i * 100) / numChanges);

            NodeRef oldObject = diff.getOldObject();
            NodeRef newObject = diff.getNewObject();
            if (newObject == null) {
                // Delete
                parentTree.remove(oldObject.name());
                if (TYPE.TREE.equals(oldObject.getType())) {
                    removedTrees.add(oldObject.path());
View Full Code Here

    /**
     * Compute the next {@link DiffEntry} that matches our {@link RepositoryFilter}.
     */
    protected DiffEntry computeNext() {
        while (source.hasNext()) {
            DiffEntry input = source.next();

            // HACK: ignore diff entries reporting a change to a tree, the feature changes will come
            // next and the new tree is built from them. I'm not totally sure this is the best way
            // to handle this situation but the unit tests are written expecting this behavior
            // probably as a side effect of a bug in TreeDiffEntryIterator (used to be called by
            // DiffTree) that doesn't report tree changes even is setReportTrees(true) was set.
            if (input.isChange() && input.getOldObject().getType().equals(TYPE.TREE)) {
                continue;
            }
            NodeRef oldObject = filter(input.getOldObject());
            NodeRef newObject;
            if (oldObject != null) {
                newObject = input.getNewObject();
                if (newObject != null) {
                    // we are tracking this object, but we still need to process the new object
                    RevObject object = sourceRepo.command(RevObjectParse.class)
                            .setObjectId(newObject.getNode().getObjectId()).call().get();

                    RevObject metadata = null;
                    if (newObject.getMetadataId() != ObjectId.NULL) {
                        metadata = sourceRepo.command(RevObjectParse.class)
                                .setObjectId(newObject.getMetadataId()).call().get();
                    }
                    processObject(object);
                    processObject(metadata);
                }
            } else {
                newObject = filter(input.getNewObject());
            }

            if (oldObject == null && newObject == null) {
                filtered = true;
                continue;
            }

            return new DiffEntry(oldObject, newObject);
        }
        return endOfData();
    }
View Full Code Here

        if (length < 0) {
            length = Integer.MAX_VALUE;
        }
        int counter = 0;
        while (entries.hasNext() && counter < length) {
            DiffEntry entry = entries.next();
            out.writeStartElement(name);
            writeElement("changeType", entry.changeType().toString());
            NodeRef oldObject = entry.getOldObject();
            NodeRef newObject = entry.getNewObject();
            if (oldObject == null) {
                writeElement("newPath", newObject.path());
                writeElement("newObjectId", newObject.objectId().toString());
                writeElement("path", "");
                writeElement("oldObjectId", ObjectId.NULL.toString());
View Full Code Here

     * @throws XMLStreamException
     */
    public void writeCommitResponse(RevCommit commit, Iterator<DiffEntry> diff)
            throws XMLStreamException {
        int adds = 0, deletes = 0, changes = 0;
        DiffEntry diffEntry;
        while (diff.hasNext()) {
            diffEntry = diff.next();
            switch (diffEntry.changeType()) {
            case ADDED:
                ++adds;
                break;
            case REMOVED:
                ++deletes;
View Full Code Here

            writeElement("Ref", result.getNewRef().localName());
            int added = 0;
            int removed = 0;
            int modified = 0;
            while (iter.hasNext()) {
                DiffEntry entry = iter.next();
                if (entry.changeType() == ChangeType.ADDED) {
                    added++;
                } else if (entry.changeType() == ChangeType.MODIFIED) {
                    modified++;
                } else if (entry.changeType() == ChangeType.REMOVED) {
                    removed++;
                }
            }
            writeElement("Added", Integer.toString(added));
            writeElement("Modified", Integer.toString(modified));
View Full Code Here

    /**
     * @return the next {@link DiffEntry}
     */
    protected DiffEntry computeNext() {
        if (source.hasNext()) {
            DiffEntry next = source.next();
            if (next.getNewObject() != null) {
                NodeRef newObject = next.getNewObject();
                RevObject object = sourceRepo.command(RevObjectParse.class)
                        .setObjectId(newObject.getNode().getObjectId()).call().get();

                RevObject metadata = null;
                if (newObject.getMetadataId() != ObjectId.NULL) {
View Full Code Here

TOP

Related Classes of org.locationtech.geogig.api.plumbing.diff.DiffEntry

Copyright © 2018 www.massapicom. All rights reserved.
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.