ltk/org.eclipse.statet.ltk.ui/src/org/eclipse/statet/ltk/ui/sourceediting/EcoReconciler2.java - statet/org.eclipse.statet-ltk - Git at Google

 /*=============================================================================#
  # Copyright (c) 2007, 2019 Stephan Wahlbrink and others.
  #
  # This program and the accompanying materials are made available under the
  # terms of the Eclipse Public License 2.0 which is available at
  # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
  # which is available at https://www.apache.org/licenses/LICENSE-2.0.
  #
  # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
  #
  # Contributors:
  #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
  #=============================================================================*/

 package org.eclipse.statet.ltk.ui.sourceediting;

 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.jobs.ISchedulingRule;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.jface.text.DocumentEvent;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IDocumentListener;
 import org.eclipse.jface.text.IRegion;
 import org.eclipse.jface.text.ITextInputListener;
 import org.eclipse.jface.text.ITextViewer;
 import org.eclipse.jface.text.Region;
 import org.eclipse.jface.text.reconciler.IReconciler;
 import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
 import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.StyledText;
 import org.eclipse.swt.widgets.Event;
 import org.eclipse.swt.widgets.Listener;

 import org.eclipse.statet.jcommons.collections.CopyOnWriteIdentityListSet;
 import org.eclipse.statet.jcommons.collections.ImIdentityList;

 import org.eclipse.statet.ltk.model.core.elements.ISourceUnit;


 /**
  * Reconciler for {@link ISourceEditor}s using Eclipse Job API.
  */
 public class EcoReconciler2 implements IReconciler {


 	public static interface ISourceUnitStrategy {

 		void setInput(ISourceUnit su);

 	}

 	protected static class StrategyEntry {

 		final IReconcilingStrategy strategy;
 		final IReconcilingStrategyExtension strategyExtension;
 		final ISourceUnitStrategy suStrategy;
 		boolean initialed;

 		StrategyEntry(final IReconcilingStrategy strategy) {
 			this.strategy= strategy;
 			this.strategyExtension= (strategy instanceof IReconcilingStrategyExtension) ?
 					(IReconcilingStrategyExtension) strategy : null;
 			this.initialed= false;
 			this.suStrategy= (strategy instanceof ISourceUnitStrategy) ?
 					(ISourceUnitStrategy) strategy : null;
 		}

 		@Override
 		public int hashCode() {
 			return this.strategy.hashCode();
 		}

 		@Override
 		public boolean equals(final Object obj) {
 			if (obj instanceof StrategyEntry) {
 				return ( ((StrategyEntry) obj).strategy == this.strategy);
 			}
 			return false;
 		}
 	}


 	private class ReconcileJob extends Job implements ISchedulingRule {

 		ReconcileJob(final String name) {
 			super("Reconciler '"+name+"'"); //$NON-NLS-1$ //$NON-NLS-2$
 			setPriority(Job.SHORT);
 			setRule(this);
 			setSystem(true);
 			setUser(false);
 		}

 		@Override
 		protected IStatus run(final IProgressMonitor monitor) {
 			if (!monitor.isCanceled()) {
 				processReconcile(monitor);
 			}
 			return Status.OK_STATUS;
 		}

 		@Override
 		public boolean contains(final ISchedulingRule rule) {
 			return rule == this;
 		}

 		@Override
 		public boolean isConflicting(final ISchedulingRule rule) {
 			return rule == this;
 		}
 	}


 	private class VisibleListener implements Listener {
 		@Override
 		public void handleEvent(final Event event) {
 			switch (event.type) {
 			case SWT.Show:
 				EcoReconciler2.this.isEditorVisible= true;
 				return;
 			case SWT.Hide:
 				EcoReconciler2.this.isEditorVisible= false;
 				return;
 			}
 		}
 	}

 	/**
 	 * Internal document listener and text input listener.
 	 */
 	private class DocumentListener implements IDocumentListener, ITextInputListener {

 		@Override
 		public void documentAboutToBeChanged(final DocumentEvent e) {
 		}

 		@Override
 		public void documentChanged(final DocumentEvent e) {
 			scheduleReconcile();
 		}

 		@Override
 		public void inputDocumentAboutToBeChanged(final IDocument oldInput, final IDocument newInput) {
 			if (EcoReconciler2.this.document != null && oldInput == EcoReconciler2.this.document && newInput != EcoReconciler2.this.document) {
 				disconnectDocument();
 			}
 		}

 		@Override
 		public void inputDocumentChanged(final IDocument oldInput, final IDocument newInput) {
 			connectDocument();
 		}
 	}

 	/** Internal document and text input listener. */
 	private final DocumentListener documentListener= new DocumentListener();
 	private VisibleListener visibleListener;
 	/** Job for scheduled background reconciling */
 	private ReconcileJob job;
 	/** The background thread delay. */
 	private int delay= 500;

 	/** The text viewer's document. */
 	private IDocument document;
 	/** The text viewer */
 	private ITextViewer viewer;
 	/** optional editor */
 	private ISourceEditor editor;

 	/** Tells whether this reconciler's editor is active. */
 	private volatile boolean isEditorVisible;

 	/** The current source unit */
 	private ISourceUnit sourceUnit;

 	private final CopyOnWriteIdentityListSet<StrategyEntry> strategies= new CopyOnWriteIdentityListSet<>();


 	/**
 	 * Creates a new reconciler without configuring it.
 	 */
 	public EcoReconciler2() {
 		super();
 	}

 	/**
 	 * Creates a new reconciler without configuring it.
 	 */
 	public EcoReconciler2(final ISourceEditor editor) {
 		super();
 		this.editor= editor;
 	}


 	/**
 	 * Tells the reconciler how long it should wait for further text changes before
 	 * activating the appropriate reconciling strategies.
 	 *
 	 * @param delay the duration in milliseconds of a change collection period.
 	 */
 	public void setDelay(final int delay) {
 		this.delay= delay;
 	}

 	/**
 	 * Returns the input document of the text viewer this reconciler is installed on.
 	 *
 	 * @return the reconciler document
 	 */
 	protected IDocument getDocument() {
 		return this.document;
 	}


 	/**
 	 * Returns the text viewer this reconciler is installed on.
 	 *
 	 * @return the text viewer this reconciler is installed on
 	 */
 	protected ITextViewer getTextViewer() {
 		return this.viewer;
 	}

 	/**
 	 * Tells whether this reconciler's editor is active.
 	 *
 	 * @return <code>true</code> if the editor is active
 	 */
 	protected boolean isEditorVisible() {
 		return this.isEditorVisible;
 	}


 	@Override
 	public void install(final ITextViewer textViewer) {
 		Assert.isNotNull(textViewer);
 		this.viewer= textViewer;

 		this.visibleListener= new VisibleListener();
 		final StyledText textWidget= this.viewer.getTextWidget();
 		textWidget.addListener(SWT.Show, this.visibleListener);
 		textWidget.addListener(SWT.Hide, this.visibleListener);
 		this.isEditorVisible= textWidget.isVisible();

 		this.viewer.addTextInputListener(this.documentListener);
 		connectDocument();
 	}

 	@Override
 	public void uninstall() {
 		if (this.viewer != null) {
 			disconnectDocument();
 			this.viewer.removeTextInputListener(this.documentListener);
 			this.viewer= null;
 		}
 	}

 	protected void connectDocument() {
 		final IDocument document= this.viewer.getDocument();
 		if (document == null || this.document == document) {
 			return;
 		}
 		this.document= document;
 		this.sourceUnit= this.editor.getSourceUnit();
 		reconcilerDocumentChanged(this.document);

 		this.job= new ReconcileJob(getInputName());
 		this.document.addDocumentListener(this.documentListener);

 		scheduleReconcile();
 	}

 	protected String getInputName() {
 		if (this.sourceUnit != null) {
 			return this.sourceUnit.getId();
 		}
 		return "-"; //$NON-NLS-1$
 	}

 	/**
 	 * Hook called when the document whose contents should be reconciled
 	 * has been changed, i.e., the input document of the text viewer this
 	 * reconciler is installed on. Usually, subclasses use this hook to
 	 * inform all their reconciling strategies about the change.
 	 *
 	 * @param newDocument the new reconciler document
 	 */
 	protected void reconcilerDocumentChanged(final IDocument newDocument) {
 	}

 	protected void disconnectDocument() {
 		if (this.document != null) {
 			this.document.removeDocumentListener(this.documentListener);
 			this.document= null;
 			this.sourceUnit= null;
 		}
 		if (this.job != null) {
 			this.job.cancel();
 			this.job= null;
 		}
 	}

 	private synchronized void scheduleReconcile() {
 		if ((this.job.getState() & (Job.SLEEPING | Job.WAITING)) == 0) {
 			aboutToBeReconciled();
 		}
 		this.job.cancel();
 		this.job.schedule(this.delay);
 	}

 	/**
 	 * Hook for subclasses which want to perform some
 	 * action as soon as reconciliation is needed.
 	 * <p>
 	 * Default implementation is to do nothing.
 	 */
 	protected void aboutToBeReconciled() {
 	}

 	protected void processReconcile(final IProgressMonitor monitor) {
 		final IDocument document= getDocument();
 		final ISourceUnit input= this.sourceUnit;
 		if (document == null || input == null) {
 			return;
 		}
 		final IRegion region= new Region(0, document.getLength());
 		final ImIdentityList<StrategyEntry> reconcilingStrategies= getReconcilingStrategies();
 		for (final StrategyEntry s : reconcilingStrategies) {
 			synchronized (s.strategy) {
 				if (s.suStrategy != null && input != null) {
 					s.suStrategy.setInput(input);
 				}
 				else {
 					s.strategy.setDocument(document);
 				}
 				if (!prepareStrategyReconcile(s)) {
 					continue;
 				}
 				if (monitor.isCanceled()) {
 					return;
 				}
 				if (s.strategyExtension != null) {
 					s.strategyExtension.setProgressMonitor(monitor);
 					if (!s.initialed) {
 						s.strategyExtension.initialReconcile();
 						s.initialed= true;
 						continue;
 					}
 				}
 				s.strategy.reconcile(region);
 			}
 		}
 	}

 	protected boolean prepareStrategyReconcile(final StrategyEntry s) {
 		return true;
 	}

 	public void addReconcilingStrategy(final IReconcilingStrategy strategy) {
 		this.strategies.add(new StrategyEntry(strategy));
 	}

 	protected ImIdentityList<StrategyEntry> getReconcilingStrategies() {
 		return this.strategies.toList();
 	}

 	@Override
 	public IReconcilingStrategy getReconcilingStrategy(final String contentType) {
 		return null;
 	}

 }
	/*=============================================================================#
	# Copyright (c) 2007, 2019 Stephan Wahlbrink and others.
	#
	# This program and the accompanying materials are made available under the
	# terms of the Eclipse Public License 2.0 which is available at
	# https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
	# which is available at https://www.apache.org/licenses/LICENSE-2.0.
	#
	# SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
	#
	# Contributors:
	# Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
	#=============================================================================*/

	package org.eclipse.statet.ltk.ui.sourceediting;

	import org.eclipse.core.runtime.Assert;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.core.runtime.jobs.ISchedulingRule;
	import org.eclipse.core.runtime.jobs.Job;
	import org.eclipse.jface.text.DocumentEvent;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IDocumentListener;
	import org.eclipse.jface.text.IRegion;
	import org.eclipse.jface.text.ITextInputListener;
	import org.eclipse.jface.text.ITextViewer;
	import org.eclipse.jface.text.Region;
	import org.eclipse.jface.text.reconciler.IReconciler;
	import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
	import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.StyledText;
	import org.eclipse.swt.widgets.Event;
	import org.eclipse.swt.widgets.Listener;

	import org.eclipse.statet.jcommons.collections.CopyOnWriteIdentityListSet;
	import org.eclipse.statet.jcommons.collections.ImIdentityList;

	import org.eclipse.statet.ltk.model.core.elements.ISourceUnit;


	/**
	* Reconciler for {@link ISourceEditor}s using Eclipse Job API.
	*/
	public class EcoReconciler2 implements IReconciler {


	public static interface ISourceUnitStrategy {

	void setInput(ISourceUnit su);

	}

	protected static class StrategyEntry {

	final IReconcilingStrategy strategy;
	final IReconcilingStrategyExtension strategyExtension;
	final ISourceUnitStrategy suStrategy;
	boolean initialed;

	StrategyEntry(final IReconcilingStrategy strategy) {
	this.strategy= strategy;
	this.strategyExtension= (strategy instanceof IReconcilingStrategyExtension) ?
	(IReconcilingStrategyExtension) strategy : null;
	this.initialed= false;
	this.suStrategy= (strategy instanceof ISourceUnitStrategy) ?
	(ISourceUnitStrategy) strategy : null;
	}

	@Override
	public int hashCode() {
	return this.strategy.hashCode();
	}

	@Override
	public boolean equals(final Object obj) {
	if (obj instanceof StrategyEntry) {
	return ( ((StrategyEntry) obj).strategy == this.strategy);
	}
	return false;
	}
	}


	private class ReconcileJob extends Job implements ISchedulingRule {

	ReconcileJob(final String name) {
	super("Reconciler '"+name+"'"); //$NON-NLS-1$ //$NON-NLS-2$
	setPriority(Job.SHORT);
	setRule(this);
	setSystem(true);
	setUser(false);
	}

	@Override
	protected IStatus run(final IProgressMonitor monitor) {
	if (!monitor.isCanceled()) {
	processReconcile(monitor);
	}
	return Status.OK_STATUS;
	}

	@Override
	public boolean contains(final ISchedulingRule rule) {
	return rule == this;
	}

	@Override
	public boolean isConflicting(final ISchedulingRule rule) {
	return rule == this;
	}
	}


	private class VisibleListener implements Listener {
	@Override
	public void handleEvent(final Event event) {
	switch (event.type) {
	case SWT.Show:
	EcoReconciler2.this.isEditorVisible= true;
	return;
	case SWT.Hide:
	EcoReconciler2.this.isEditorVisible= false;
	return;
	}
	}
	}

	/**
	* Internal document listener and text input listener.
	*/
	private class DocumentListener implements IDocumentListener, ITextInputListener {

	@Override
	public void documentAboutToBeChanged(final DocumentEvent e) {
	}

	@Override
	public void documentChanged(final DocumentEvent e) {
	scheduleReconcile();
	}

	@Override
	public void inputDocumentAboutToBeChanged(final IDocument oldInput, final IDocument newInput) {
	if (EcoReconciler2.this.document != null && oldInput == EcoReconciler2.this.document && newInput != EcoReconciler2.this.document) {
	disconnectDocument();
	}
	}

	@Override
	public void inputDocumentChanged(final IDocument oldInput, final IDocument newInput) {
	connectDocument();
	}
	}

	/** Internal document and text input listener. */
	private final DocumentListener documentListener= new DocumentListener();
	private VisibleListener visibleListener;
	/** Job for scheduled background reconciling */
	private ReconcileJob job;
	/** The background thread delay. */
	private int delay= 500;

	/** The text viewer's document. */
	private IDocument document;
	/** The text viewer */
	private ITextViewer viewer;
	/** optional editor */
	private ISourceEditor editor;

	/** Tells whether this reconciler's editor is active. */
	private volatile boolean isEditorVisible;

	/** The current source unit */
	private ISourceUnit sourceUnit;

	private final CopyOnWriteIdentityListSet<StrategyEntry> strategies= new CopyOnWriteIdentityListSet<>();


	/**
	* Creates a new reconciler without configuring it.
	*/
	public EcoReconciler2() {
	super();
	}

	/**
	* Creates a new reconciler without configuring it.
	*/
	public EcoReconciler2(final ISourceEditor editor) {
	super();
	this.editor= editor;
	}


	/**
	* Tells the reconciler how long it should wait for further text changes before
	* activating the appropriate reconciling strategies.
	*
	* @param delay the duration in milliseconds of a change collection period.
	*/
	public void setDelay(final int delay) {
	this.delay= delay;
	}

	/**
	* Returns the input document of the text viewer this reconciler is installed on.
	*
	* @return the reconciler document
	*/
	protected IDocument getDocument() {
	return this.document;
	}


	/**
	* Returns the text viewer this reconciler is installed on.
	*
	* @return the text viewer this reconciler is installed on
	*/
	protected ITextViewer getTextViewer() {
	return this.viewer;
	}

	/**
	* Tells whether this reconciler's editor is active.
	*
	* @return <code>true</code> if the editor is active
	*/
	protected boolean isEditorVisible() {
	return this.isEditorVisible;
	}


	@Override
	public void install(final ITextViewer textViewer) {
	Assert.isNotNull(textViewer);
	this.viewer= textViewer;

	this.visibleListener= new VisibleListener();
	final StyledText textWidget= this.viewer.getTextWidget();
	textWidget.addListener(SWT.Show, this.visibleListener);
	textWidget.addListener(SWT.Hide, this.visibleListener);
	this.isEditorVisible= textWidget.isVisible();

	this.viewer.addTextInputListener(this.documentListener);
	connectDocument();
	}

	@Override
	public void uninstall() {
	if (this.viewer != null) {
	disconnectDocument();
	this.viewer.removeTextInputListener(this.documentListener);
	this.viewer= null;
	}
	}

	protected void connectDocument() {
	final IDocument document= this.viewer.getDocument();
	if (document == null \|\| this.document == document) {
	return;
	}
	this.document= document;
	this.sourceUnit= this.editor.getSourceUnit();
	reconcilerDocumentChanged(this.document);

	this.job= new ReconcileJob(getInputName());
	this.document.addDocumentListener(this.documentListener);

	scheduleReconcile();
	}

	protected String getInputName() {
	if (this.sourceUnit != null) {
	return this.sourceUnit.getId();
	}
	return "-"; //$NON-NLS-1$
	}

	/**
	* Hook called when the document whose contents should be reconciled
	* has been changed, i.e., the input document of the text viewer this
	* reconciler is installed on. Usually, subclasses use this hook to
	* inform all their reconciling strategies about the change.
	*
	* @param newDocument the new reconciler document
	*/
	protected void reconcilerDocumentChanged(final IDocument newDocument) {
	}

	protected void disconnectDocument() {
	if (this.document != null) {
	this.document.removeDocumentListener(this.documentListener);
	this.document= null;
	this.sourceUnit= null;
	}
	if (this.job != null) {
	this.job.cancel();
	this.job= null;
	}
	}

	private synchronized void scheduleReconcile() {
	if ((this.job.getState() & (Job.SLEEPING \| Job.WAITING)) == 0) {
	aboutToBeReconciled();
	}
	this.job.cancel();
	this.job.schedule(this.delay);
	}

	/**
	* Hook for subclasses which want to perform some
	* action as soon as reconciliation is needed.
	* <p>
	* Default implementation is to do nothing.
	*/
	protected void aboutToBeReconciled() {
	}

	protected void processReconcile(final IProgressMonitor monitor) {
	final IDocument document= getDocument();
	final ISourceUnit input= this.sourceUnit;
	if (document == null \|\| input == null) {
	return;
	}
	final IRegion region= new Region(0, document.getLength());
	final ImIdentityList<StrategyEntry> reconcilingStrategies= getReconcilingStrategies();
	for (final StrategyEntry s : reconcilingStrategies) {
	synchronized (s.strategy) {
	if (s.suStrategy != null && input != null) {
	s.suStrategy.setInput(input);
	}
	else {
	s.strategy.setDocument(document);
	}
	if (!prepareStrategyReconcile(s)) {
	continue;
	}
	if (monitor.isCanceled()) {
	return;
	}
	if (s.strategyExtension != null) {
	s.strategyExtension.setProgressMonitor(monitor);
	if (!s.initialed) {
	s.strategyExtension.initialReconcile();
	s.initialed= true;
	continue;
	}
	}
	s.strategy.reconcile(region);
	}
	}
	}

	protected boolean prepareStrategyReconcile(final StrategyEntry s) {
	return true;
	}

	public void addReconcilingStrategy(final IReconcilingStrategy strategy) {
	this.strategies.add(new StrategyEntry(strategy));
	}

	protected ImIdentityList<StrategyEntry> getReconcilingStrategies() {
	return this.strategies.toList();
	}

	@Override
	public IReconcilingStrategy getReconcilingStrategy(final String contentType) {
	return null;
	}

	}