org.eclipse.compare.structuremergeviewer.Differencer Java Examples

@Override
protected Object prepareInput(IProgressMonitor pm) {
	try {
		ResourceNode ancestor = new ResourceNode(file);
		String ancestorContent = getContent(ancestor);
		String leftContent, rightContent;

		leftContent = this.comparisonFailure.getExpected();
		rightContent = this.comparisonFailure.getActual();
		if (!leftContent.equals(ancestorContent))
			getCompareConfiguration().setProperty(ICompareUIConstants.PROP_ANCESTOR_VISIBLE, Boolean.TRUE);
		CompareItem left = new EditableCompareItem("Left", leftContent, file);
		CompareItem right = new CompareItem("Right", rightContent);
		return new DiffNode(null, Differencer.CHANGE | Differencer.DIRECTION_MASK, ancestor, left, right);
	} catch (Throwable t) {
		LOG.error(t.getMessage(), t);
		Exceptions.throwUncheckedException(t);
		return null;
	}
}
 

@Override
protected Object prepareInput(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	initLabels();
	if (monitor != null) {
		monitor.subTask(Policy.bind("PropertyCompareInput.0") + left.getLabel()); //$NON-NLS-1$
	}
	left.getProperties(recursive);
	if (monitor != null && monitor.isCanceled()) {
		return null;
	}
	if (monitor != null) {
		monitor.subTask(Policy.bind("PropertyCompareInput.0") + right.getLabel()); //$NON-NLS-1$
	}
	right.getProperties(recursive);
	if (monitor != null && monitor.isCanceled()) {
		return null;
	}
	return new Differencer().findDifferences(false, monitor,null,null,left,right);
}
 

/**
    * Runs the compare operation and returns the compare result.
    */
protected Object prepareInput(IProgressMonitor monitor){
	initLabels();
	DiffNode diffRoot = new DiffNode(Differencer.NO_CHANGE);
	String localCharset = Utilities.getCharset(resource);
	for (int i = 0; i < logEntries.length; i++) {		
		ITypedElement left = new TypedBufferedContent(resource);
		ResourceRevisionNode right = new ResourceRevisionNode(logEntries[i]);
		try {
			right.setCharset(localCharset);
		} catch (CoreException e) {
		}
		diffRoot.add(new VersionCompareDiffNode(left, right));
	}
	return diffRoot;		
}
 

public void buildTree() {
    for (final ScriptContainer<?> script : scripts) {
        final LeftCompareScript left = new LeftCompareScript(script, adapterFactoryLabelProvider);
        final RightCompareScript right = new RightCompareScript(script, adapterFactoryLabelProvider);
        right.addContentChangeListener(new IContentChangeListener() {

            @Override
            public void contentChanged(final IContentChangeNotifier compareScript) {
                if (compareScript instanceof RightCompareScript) {
                    setDirty(true);
                    if (getViewer() == null || getViewer().getControl().isDisposed()) {
                        return;
                    }
                    getViewer().refresh(true);
                }
            }
        });
        final DiffNode leaf = new DiffNode(null, Differencer.CHANGE, null, left, right);
        final EObject eContainer = script.getModelElement().eContainer();
        Preconditions.checkState(eContainer != null);
        final DiffNode poolNode = buildPathNodes(eContainer, leaf);
        if (((EObjectNode) poolNode.getAncestor()).getElement() instanceof Pool && root.getChildren().length == 0) {
            root.add(poolNode);
        }
    }
}
 

private DiffNode buildPathNodes(final EObject container, final DiffNode node) {
    final DiffNode parentNode = new DiffNode(Differencer.NO_CHANGE);
    node.setParent(parentNode);
    parentNode.add(node);
    final EObjectNode ancestor = new EObjectNode(container, adapterFactoryLabelProvider);
    parentNode.setAncestor(ancestor);
    if (insertParentNode(parentNode)) {
        return parentNode;
    }
    if (container instanceof Pool) {
        return parentNode;
    }
    if (container instanceof ConnectorParameter) {
        return buildPathNodes(container.eContainer().eContainer(), parentNode);
    }
    return buildPathNodes(container.eContainer(), parentNode);
}
 

@Override
protected Object prepareInput(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	CompareConfiguration configuration = getCompareConfiguration();
	configuration.setLeftLabel(this.left.getName());
	configuration.setRightLabel(this.right.getName());
	return new DiffNode(null, Differencer.CHANGE, null, this.left, this.right);
}
 

@Override
protected void postDiffHook(Differencer differencer, IDiffContainer root, IProgressMonitor monitor) {
	if (fStructureCreator.canRewriteTree()) {
		boolean smart= JavaCompareUtilities.getBoolean(getCompareConfiguration(), SMART, false);
		if (smart && root != null)
			fStructureCreator.rewriteTree(differencer, root);
	}
}
 

@Override
protected Object prepareInput(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	Differencer d = new Differencer();
	Object diff = d.findDifferences(false, new NullProgressMonitor(), null, null, new Input(input1), new Input(input2));
	return diff; 
}