core/plugins/org.eclipse.dltk.ui/src/org/eclipse/dltk/internal/ui/editor/DocumentAdapter.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2017 IBM Corporation and others.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  *******************************************************************************/
 package org.eclipse.dltk.internal.ui.editor;

 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;

 import org.eclipse.core.filebuffers.FileBuffers;
 import org.eclipse.core.filebuffers.ITextFileBuffer;
 import org.eclipse.core.filebuffers.ITextFileBufferManager;
 import org.eclipse.core.filebuffers.LocationKind;
 import org.eclipse.core.filesystem.IFileStore;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.dltk.core.BufferChangedEvent;
 import org.eclipse.dltk.core.IBuffer;
 import org.eclipse.dltk.core.IBufferChangedListener;
 import org.eclipse.dltk.core.IOpenable;
 import org.eclipse.dltk.core.ModelException;
 import org.eclipse.dltk.ui.DLTKUIPlugin;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.DefaultLineTracker;
 import org.eclipse.jface.text.DocumentEvent;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IDocumentListener;
 import org.eclipse.jface.text.ISynchronizable;
 import org.eclipse.swt.widgets.Display;

 /**
  * Adapts <code>IDocument</code> to <code>IBuffer</code>. Uses the same
  * algorithm as the text widget to determine the buffer's line delimiter. All
  * text inserted into the buffer is converted to this line delimiter. This class
  * is <code>public</code> for test purposes only.
  */
 public class DocumentAdapter implements IBuffer, IDocumentListener {

 	/**
 	 * Internal implementation of a NULL instanceof IBuffer.
 	 */
 	static private class NullBuffer implements IBuffer {
 		@Override
 		public void addBufferChangedListener(IBufferChangedListener listener) {
 		}

 		@Override
 		public void append(char[] text) {
 		}

 		@Override
 		public void append(String text) {
 		}

 		@Override
 		public void close() {
 		}

 		@Override
 		public char getChar(int position) {
 			return 0;
 		}

 		@Override
 		public char[] getCharacters() {
 			return null;
 		}

 		@Override
 		public String getContents() {
 			return null;
 		}

 		@Override
 		public int getLength() {
 			return 0;
 		}

 		@Override
 		public IOpenable getOwner() {
 			return null;
 		}

 		@Override
 		public String getText(int offset, int length) {
 			return null;
 		}

 		@Override
 		public IResource getUnderlyingResource() {
 			return null;
 		}

 		@Override
 		public boolean hasUnsavedChanges() {
 			return false;
 		}

 		@Override
 		public boolean isClosed() {
 			return false;
 		}

 		@Override
 		public boolean isReadOnly() {
 			return true;
 		}

 		@Override
 		public void removeBufferChangedListener(
 				IBufferChangedListener listener) {
 		}

 		@Override
 		public void replace(int position, int length, char[] text) {
 		}

 		@Override
 		public void replace(int position, int length, String text) {
 		}

 		@Override
 		public void save(IProgressMonitor progress, boolean force)
 				throws ModelException {
 		}

 		@Override
 		public void setContents(char[] contents) {
 		}

 		@Override
 		public void setContents(String contents) {
 		}
 	}

 	/** NULL implementing <code>IBuffer</code> */
 	public final static IBuffer NULL = new NullBuffer();

 	/*
 	*
 	 */
 	private IPath fPath;

 	/**
 	 * Executes a document set content call in the ui thread.
 	 */
 	protected class DocumentSetCommand implements Runnable {

 		private String fContents;

 		@Override
 		public void run() {
 			fDocument.set(fContents);
 		}

 		public void set(String contents) {
 			fContents = contents;
 			// Display.getDefault().syncExec(this);
 			DocumentAdapter.run(this);
 		}
 	}

 	/**
 	 * Executes a document replace call in the ui thread.
 	 */
 	protected class DocumentReplaceCommand implements Runnable {

 		private int fOffset;
 		private int fLength;
 		private String fText;

 		@Override
 		public void run() {
 			try {
 				fDocument.replace(fOffset, fLength, fText);
 			} catch (BadLocationException x) {
 				// ignore
 			}
 		}

 		public void replace(int offset, int length, String text) {
 			fOffset = offset;
 			fLength = length;
 			fText = text;
 			Display.getDefault().syncExec(this);
 		}
 	}

 	private static final boolean DEBUG_LINE_DELIMITERS = true;

 	private IOpenable fOwner;
 	private IFile fFile;
 	private ITextFileBuffer fTextFileBuffer;
 	private IDocument fDocument;

 	private DocumentSetCommand fSetCmd = new DocumentSetCommand();
 	private DocumentReplaceCommand fReplaceCmd = new DocumentReplaceCommand();

 	private Set<String> fLegalLineDelimiters;

 	private List<IBufferChangedListener> fBufferListeners = new ArrayList<>(3);
 	private IStatus fStatus;

 	/** @since 4.0 */
 	private LocationKind fLocationKind;

 	/** @since 4.0 */
 	private IFileStore fFileStore;

 	/**
 	 * Constructs a new document adapter.
 	 */
 	public DocumentAdapter(IOpenable owner, IFile file) {

 		fOwner = owner;
 		fFile = file;
 		fPath = fFile.getFullPath();
 		fLocationKind = LocationKind.IFILE;

 		initialize();
 	}

 	/**
 	 * Constructs a new document adapter.
 	 *
 	 *
 	 */
 	public DocumentAdapter(IOpenable owner, IPath path) {
 		Assert.isLegal(path != null);

 		fOwner = owner;
 		fPath = path;
 		fLocationKind = LocationKind.NORMALIZE;

 		initialize();
 	}

 	/**
 	 * Constructs a new document adapter.
 	 *
 	 * @param owner
 	 *            the owner of this buffer
 	 * @param fileStore
 	 *            the file store of the file that backs the buffer
 	 * @param path
 	 *            the path of the file that backs the buffer
 	 * @since 4.0
 	 */
 	public DocumentAdapter(IOpenable owner, IFileStore fileStore, IPath path) {
 		Assert.isLegal(fileStore != null);
 		Assert.isLegal(path != null);
 		fOwner = owner;
 		fFileStore = fileStore;
 		fPath = path;
 		fLocationKind = LocationKind.NORMALIZE;

 		initialize();
 	}

 	private void initialize() {
 		ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
 		try {
 			if (fFileStore != null) {
 				manager.connectFileStore(fFileStore, new NullProgressMonitor());
 				fTextFileBuffer = manager
 						.getFileStoreTextFileBuffer(fFileStore);
 			} else {
 				manager.connect(fPath, fLocationKind,
 						new NullProgressMonitor());
 				fTextFileBuffer = manager.getTextFileBuffer(fPath,
 						fLocationKind);
 			}
 			fDocument = fTextFileBuffer.getDocument();
 		} catch (CoreException x) {
 			fStatus = x.getStatus();
 			fDocument = manager.createEmptyDocument(fPath,
 					LocationKind.NORMALIZE);
 			if (fDocument instanceof ISynchronizable)
 				((ISynchronizable) fDocument).setLockObject(new Object());
 		}
 		fDocument.addPrenotifiedDocumentListener(this);
 	}

 	/**
 	 * Returns the status of this document adapter.
 	 */
 	public IStatus getStatus() {
 		if (fStatus != null)
 			return fStatus;
 		if (fTextFileBuffer != null)
 			return fTextFileBuffer.getStatus();
 		return null;
 	}

 	/**
 	 * Returns the adapted document.
 	 *
 	 * @return the adapted document
 	 */
 	public IDocument getDocument() {
 		return fDocument;
 	}

 	/*
 	 * @see IBuffer#addBufferChangedListener(IBufferChangedListener)
 	 */
 	@Override
 	public void addBufferChangedListener(IBufferChangedListener listener) {
 		Assert.isNotNull(listener);
 		if (!fBufferListeners.contains(listener))
 			fBufferListeners.add(listener);
 	}

 	/*
 	 * @see IBuffer#removeBufferChangedListener(IBufferChangedListener)
 	 */
 	@Override
 	public void removeBufferChangedListener(IBufferChangedListener listener) {
 		Assert.isNotNull(listener);
 		fBufferListeners.remove(listener);
 	}

 	@Override
 	public void append(char[] text) {
 		append(new String(text));
 	}

 	@Override
 	public void append(String text) {
 		if (DEBUG_LINE_DELIMITERS) {
 			validateLineDelimiters(text);
 		}
 		fReplaceCmd.replace(fDocument.getLength(), 0, text);
 	}

 	@Override
 	public void close() {

 		if (isClosed())
 			return;

 		IDocument d = fDocument;
 		fDocument = null;
 		d.removePrenotifiedDocumentListener(this);

 		if (fTextFileBuffer != null) {
 			ITextFileBufferManager manager = FileBuffers
 					.getTextFileBufferManager();
 			try {
 				if (fFileStore != null)
 					manager.disconnectFileStore(fFileStore,
 							new NullProgressMonitor());
 				else
 					manager.disconnect(fPath, fLocationKind,
 							new NullProgressMonitor());
 			} catch (CoreException x) {
 				// ignore
 			}
 			fTextFileBuffer = null;
 		}

 		fireBufferChanged(new BufferChangedEvent(this, 0, 0, null));
 		fBufferListeners.clear();
 	}

 	@Override
 	public char getChar(int position) {
 		try {
 			return fDocument.getChar(position);
 		} catch (BadLocationException x) {
 			throw new ArrayIndexOutOfBoundsException();
 		}
 	}

 	@Override
 	public char[] getCharacters() {
 		String content = getContents();
 		return content == null ? null : content.toCharArray();
 	}

 	@Override
 	public String getContents() {
 		return fDocument.get();
 	}

 	@Override
 	public int getLength() {
 		return fDocument.getLength();
 	}

 	@Override
 	public IOpenable getOwner() {
 		return fOwner;
 	}

 	@Override
 	public String getText(int offset, int length) {
 		try {
 			return fDocument.get(offset, length);
 		} catch (BadLocationException x) {
 			throw new ArrayIndexOutOfBoundsException();
 		}
 	}

 	@Override
 	public IResource getUnderlyingResource() {
 		return fFile;
 	}

 	@Override
 	public boolean hasUnsavedChanges() {
 		return fTextFileBuffer != null ? fTextFileBuffer.isDirty() : false;
 	}

 	@Override
 	public boolean isClosed() {
 		return fDocument == null;
 	}

 	@Override
 	public boolean isReadOnly() {
 		IResource resource = getUnderlyingResource();
 		return resource == null ? true
 				: resource.getResourceAttributes().isReadOnly();
 	}

 	@Override
 	public void replace(int position, int length, char[] text) {
 		replace(position, length, new String(text));
 	}

 	@Override
 	public void replace(int position, int length, String text) {
 		if (DEBUG_LINE_DELIMITERS) {
 			validateLineDelimiters(text);
 		}
 		fReplaceCmd.replace(position, length, text);
 	}

 	@Override
 	public void save(IProgressMonitor progress, boolean force)
 			throws ModelException {
 		try {
 			if (fTextFileBuffer != null)
 				fTextFileBuffer.commit(progress, force);
 		} catch (CoreException e) {
 			throw new ModelException(e);
 		}
 	}

 	@Override
 	public void setContents(char[] contents) {
 		setContents(new String(contents));
 	}

 	@Override
 	public void setContents(String contents) {
 		int oldLength = fDocument.getLength();

 		if (contents == null) {

 			if (oldLength != 0)
 				fSetCmd.set(""); //$NON-NLS-1$

 		} else {

 			// set only if different
 			if (DEBUG_LINE_DELIMITERS) {
 				validateLineDelimiters(contents);
 			}

 			if (!contents.equals(fDocument.get()))
 				fSetCmd.set(contents);
 		}
 	}

 	private void validateLineDelimiters(String contents) {

 		if (fLegalLineDelimiters == null) {
 			// collect all line delimiters in the document
 			HashSet<String> existingDelimiters = new HashSet<>();

 			for (int i = fDocument.getNumberOfLines() - 1; i >= 0; i--) {
 				try {
 					String curr = fDocument.getLineDelimiter(i);
 					if (curr != null) {
 						existingDelimiters.add(curr);
 					}
 				} catch (BadLocationException e) {
 					DLTKUIPlugin.log(e);
 				}
 			}
 			if (existingDelimiters.isEmpty()) {
 				return; // first insertion of a line delimiter: no test
 			}
 			fLegalLineDelimiters = existingDelimiters;

 		}

 		DefaultLineTracker tracker = new DefaultLineTracker();
 		tracker.set(contents);

 		int lines = tracker.getNumberOfLines();
 		if (lines <= 1)
 			return;

 		for (int i = 0; i < lines; i++) {
 			try {
 				String curr = tracker.getLineDelimiter(i);
 				if (curr != null && !fLegalLineDelimiters.contains(curr)) {
 					StringBuffer buf = new StringBuffer(
 							"WARNING: DocumentAdapter added new line delimiter to code: "); //$NON-NLS-1$
 					for (int k = 0; k < curr.length(); k++) {
 						if (k > 0)
 							buf.append(' ');
 						buf.append((int) curr.charAt(k));
 					}
 					IStatus status = new Status(IStatus.WARNING,
 							DLTKUIPlugin.PLUGIN_ID, IStatus.OK, buf.toString(),
 							new Throwable());
 					DLTKUIPlugin.log(status);
 				}
 			} catch (BadLocationException e) {
 				DLTKUIPlugin.log(e);
 			}
 		}
 	}

 	@Override
 	public void documentAboutToBeChanged(DocumentEvent event) {
 		// there is nothing to do here
 	}

 	@Override
 	public void documentChanged(DocumentEvent event) {
 		fireBufferChanged(new BufferChangedEvent(this, event.getOffset(),
 				event.getLength(), event.getText()));
 	}

 	private void fireBufferChanged(BufferChangedEvent event) {
 		if (fBufferListeners != null && fBufferListeners.size() > 0) {
 			Iterator<IBufferChangedListener> e = new ArrayList<>(
 					fBufferListeners).iterator();
 			while (e.hasNext())
 				e.next().bufferChanged(event);
 		}
 	}

 	/**
 	 * Run the given runnable in the UI thread.
 	 *
 	 * @param runnable
 	 *            the runnable
 	 * @since 3.3
 	 */
 	private static final void run(Runnable runnable) {
 		Display currentDisplay = Display.getCurrent();
 		if (currentDisplay != null)
 			runnable.run();
 		else
 			Display.getDefault().syncExec(runnable);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2005, 2017 IBM Corporation and others.
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	*******************************************************************************/
	package org.eclipse.dltk.internal.ui.editor;

	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;

	import org.eclipse.core.filebuffers.FileBuffers;
	import org.eclipse.core.filebuffers.ITextFileBuffer;
	import org.eclipse.core.filebuffers.ITextFileBufferManager;
	import org.eclipse.core.filebuffers.LocationKind;
	import org.eclipse.core.filesystem.IFileStore;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.Assert;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.dltk.core.BufferChangedEvent;
	import org.eclipse.dltk.core.IBuffer;
	import org.eclipse.dltk.core.IBufferChangedListener;
	import org.eclipse.dltk.core.IOpenable;
	import org.eclipse.dltk.core.ModelException;
	import org.eclipse.dltk.ui.DLTKUIPlugin;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.DefaultLineTracker;
	import org.eclipse.jface.text.DocumentEvent;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IDocumentListener;
	import org.eclipse.jface.text.ISynchronizable;
	import org.eclipse.swt.widgets.Display;

	/**
	* Adapts <code>IDocument</code> to <code>IBuffer</code>. Uses the same
	* algorithm as the text widget to determine the buffer's line delimiter. All
	* text inserted into the buffer is converted to this line delimiter. This class
	* is <code>public</code> for test purposes only.
	*/
	public class DocumentAdapter implements IBuffer, IDocumentListener {

	/**
	* Internal implementation of a NULL instanceof IBuffer.
	*/
	static private class NullBuffer implements IBuffer {
	@Override
	public void addBufferChangedListener(IBufferChangedListener listener) {
	}

	@Override
	public void append(char[] text) {
	}

	@Override
	public void append(String text) {
	}

	@Override
	public void close() {
	}

	@Override
	public char getChar(int position) {
	return 0;
	}

	@Override
	public char[] getCharacters() {
	return null;
	}

	@Override
	public String getContents() {
	return null;
	}

	@Override
	public int getLength() {
	return 0;
	}

	@Override
	public IOpenable getOwner() {
	return null;
	}

	@Override
	public String getText(int offset, int length) {
	return null;
	}

	@Override
	public IResource getUnderlyingResource() {
	return null;
	}

	@Override
	public boolean hasUnsavedChanges() {
	return false;
	}

	@Override
	public boolean isClosed() {
	return false;
	}

	@Override
	public boolean isReadOnly() {
	return true;
	}

	@Override
	public void removeBufferChangedListener(
	IBufferChangedListener listener) {
	}

	@Override
	public void replace(int position, int length, char[] text) {
	}

	@Override
	public void replace(int position, int length, String text) {
	}

	@Override
	public void save(IProgressMonitor progress, boolean force)
	throws ModelException {
	}

	@Override
	public void setContents(char[] contents) {
	}

	@Override
	public void setContents(String contents) {
	}
	}

	/** NULL implementing <code>IBuffer</code> */
	public final static IBuffer NULL = new NullBuffer();

	/*
	*
	*/
	private IPath fPath;

	/**
	* Executes a document set content call in the ui thread.
	*/
	protected class DocumentSetCommand implements Runnable {

	private String fContents;

	@Override
	public void run() {
	fDocument.set(fContents);
	}

	public void set(String contents) {
	fContents = contents;
	// Display.getDefault().syncExec(this);
	DocumentAdapter.run(this);
	}
	}

	/**
	* Executes a document replace call in the ui thread.
	*/
	protected class DocumentReplaceCommand implements Runnable {

	private int fOffset;
	private int fLength;
	private String fText;

	@Override
	public void run() {
	try {
	fDocument.replace(fOffset, fLength, fText);
	} catch (BadLocationException x) {
	// ignore
	}
	}

	public void replace(int offset, int length, String text) {
	fOffset = offset;
	fLength = length;
	fText = text;
	Display.getDefault().syncExec(this);
	}
	}

	private static final boolean DEBUG_LINE_DELIMITERS = true;

	private IOpenable fOwner;
	private IFile fFile;
	private ITextFileBuffer fTextFileBuffer;
	private IDocument fDocument;

	private DocumentSetCommand fSetCmd = new DocumentSetCommand();
	private DocumentReplaceCommand fReplaceCmd = new DocumentReplaceCommand();

	private Set<String> fLegalLineDelimiters;

	private List<IBufferChangedListener> fBufferListeners = new ArrayList<>(3);
	private IStatus fStatus;

	/** @since 4.0 */
	private LocationKind fLocationKind;

	/** @since 4.0 */
	private IFileStore fFileStore;

	/**
	* Constructs a new document adapter.
	*/
	public DocumentAdapter(IOpenable owner, IFile file) {

	fOwner = owner;
	fFile = file;
	fPath = fFile.getFullPath();
	fLocationKind = LocationKind.IFILE;

	initialize();
	}

	/**
	* Constructs a new document adapter.
	*
	*
	*/
	public DocumentAdapter(IOpenable owner, IPath path) {
	Assert.isLegal(path != null);

	fOwner = owner;
	fPath = path;
	fLocationKind = LocationKind.NORMALIZE;

	initialize();
	}

	/**
	* Constructs a new document adapter.
	*
	* @param owner
	* the owner of this buffer
	* @param fileStore
	* the file store of the file that backs the buffer
	* @param path
	* the path of the file that backs the buffer
	* @since 4.0
	*/
	public DocumentAdapter(IOpenable owner, IFileStore fileStore, IPath path) {
	Assert.isLegal(fileStore != null);
	Assert.isLegal(path != null);
	fOwner = owner;
	fFileStore = fileStore;
	fPath = path;
	fLocationKind = LocationKind.NORMALIZE;

	initialize();
	}

	private void initialize() {
	ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
	try {
	if (fFileStore != null) {
	manager.connectFileStore(fFileStore, new NullProgressMonitor());
	fTextFileBuffer = manager
	.getFileStoreTextFileBuffer(fFileStore);
	} else {
	manager.connect(fPath, fLocationKind,
	new NullProgressMonitor());
	fTextFileBuffer = manager.getTextFileBuffer(fPath,
	fLocationKind);
	}
	fDocument = fTextFileBuffer.getDocument();
	} catch (CoreException x) {
	fStatus = x.getStatus();
	fDocument = manager.createEmptyDocument(fPath,
	LocationKind.NORMALIZE);
	if (fDocument instanceof ISynchronizable)
	((ISynchronizable) fDocument).setLockObject(new Object());
	}
	fDocument.addPrenotifiedDocumentListener(this);
	}

	/**
	* Returns the status of this document adapter.
	*/
	public IStatus getStatus() {
	if (fStatus != null)
	return fStatus;
	if (fTextFileBuffer != null)
	return fTextFileBuffer.getStatus();
	return null;
	}

	/**
	* Returns the adapted document.
	*
	* @return the adapted document
	*/
	public IDocument getDocument() {
	return fDocument;
	}

	/*
	* @see IBuffer#addBufferChangedListener(IBufferChangedListener)
	*/
	@Override
	public void addBufferChangedListener(IBufferChangedListener listener) {
	Assert.isNotNull(listener);
	if (!fBufferListeners.contains(listener))
	fBufferListeners.add(listener);
	}

	/*
	* @see IBuffer#removeBufferChangedListener(IBufferChangedListener)
	*/
	@Override
	public void removeBufferChangedListener(IBufferChangedListener listener) {
	Assert.isNotNull(listener);
	fBufferListeners.remove(listener);
	}

	@Override
	public void append(char[] text) {
	append(new String(text));
	}

	@Override
	public void append(String text) {
	if (DEBUG_LINE_DELIMITERS) {
	validateLineDelimiters(text);
	}
	fReplaceCmd.replace(fDocument.getLength(), 0, text);
	}

	@Override
	public void close() {

	if (isClosed())
	return;

	IDocument d = fDocument;
	fDocument = null;
	d.removePrenotifiedDocumentListener(this);

	if (fTextFileBuffer != null) {
	ITextFileBufferManager manager = FileBuffers
	.getTextFileBufferManager();
	try {
	if (fFileStore != null)
	manager.disconnectFileStore(fFileStore,
	new NullProgressMonitor());
	else
	manager.disconnect(fPath, fLocationKind,
	new NullProgressMonitor());
	} catch (CoreException x) {
	// ignore
	}
	fTextFileBuffer = null;
	}

	fireBufferChanged(new BufferChangedEvent(this, 0, 0, null));
	fBufferListeners.clear();
	}

	@Override
	public char getChar(int position) {
	try {
	return fDocument.getChar(position);
	} catch (BadLocationException x) {
	throw new ArrayIndexOutOfBoundsException();
	}
	}

	@Override
	public char[] getCharacters() {
	String content = getContents();
	return content == null ? null : content.toCharArray();
	}

	@Override
	public String getContents() {
	return fDocument.get();
	}

	@Override
	public int getLength() {
	return fDocument.getLength();
	}

	@Override
	public IOpenable getOwner() {
	return fOwner;
	}

	@Override
	public String getText(int offset, int length) {
	try {
	return fDocument.get(offset, length);
	} catch (BadLocationException x) {
	throw new ArrayIndexOutOfBoundsException();
	}
	}

	@Override
	public IResource getUnderlyingResource() {
	return fFile;
	}

	@Override
	public boolean hasUnsavedChanges() {
	return fTextFileBuffer != null ? fTextFileBuffer.isDirty() : false;
	}

	@Override
	public boolean isClosed() {
	return fDocument == null;
	}

	@Override
	public boolean isReadOnly() {
	IResource resource = getUnderlyingResource();
	return resource == null ? true
	: resource.getResourceAttributes().isReadOnly();
	}

	@Override
	public void replace(int position, int length, char[] text) {
	replace(position, length, new String(text));
	}

	@Override
	public void replace(int position, int length, String text) {
	if (DEBUG_LINE_DELIMITERS) {
	validateLineDelimiters(text);
	}
	fReplaceCmd.replace(position, length, text);
	}

	@Override
	public void save(IProgressMonitor progress, boolean force)
	throws ModelException {
	try {
	if (fTextFileBuffer != null)
	fTextFileBuffer.commit(progress, force);
	} catch (CoreException e) {
	throw new ModelException(e);
	}
	}

	@Override
	public void setContents(char[] contents) {
	setContents(new String(contents));
	}

	@Override
	public void setContents(String contents) {
	int oldLength = fDocument.getLength();

	if (contents == null) {

	if (oldLength != 0)
	fSetCmd.set(""); //$NON-NLS-1$

	} else {

	// set only if different
	if (DEBUG_LINE_DELIMITERS) {
	validateLineDelimiters(contents);
	}

	if (!contents.equals(fDocument.get()))
	fSetCmd.set(contents);
	}
	}

	private void validateLineDelimiters(String contents) {

	if (fLegalLineDelimiters == null) {
	// collect all line delimiters in the document
	HashSet<String> existingDelimiters = new HashSet<>();

	for (int i = fDocument.getNumberOfLines() - 1; i >= 0; i--) {
	try {
	String curr = fDocument.getLineDelimiter(i);
	if (curr != null) {
	existingDelimiters.add(curr);
	}
	} catch (BadLocationException e) {
	DLTKUIPlugin.log(e);
	}
	}
	if (existingDelimiters.isEmpty()) {
	return; // first insertion of a line delimiter: no test
	}
	fLegalLineDelimiters = existingDelimiters;

	}

	DefaultLineTracker tracker = new DefaultLineTracker();
	tracker.set(contents);

	int lines = tracker.getNumberOfLines();
	if (lines <= 1)
	return;

	for (int i = 0; i < lines; i++) {
	try {
	String curr = tracker.getLineDelimiter(i);
	if (curr != null && !fLegalLineDelimiters.contains(curr)) {
	StringBuffer buf = new StringBuffer(
	"WARNING: DocumentAdapter added new line delimiter to code: "); //$NON-NLS-1$
	for (int k = 0; k < curr.length(); k++) {
	if (k > 0)
	buf.append(' ');
	buf.append((int) curr.charAt(k));
	}
	IStatus status = new Status(IStatus.WARNING,
	DLTKUIPlugin.PLUGIN_ID, IStatus.OK, buf.toString(),
	new Throwable());
	DLTKUIPlugin.log(status);
	}
	} catch (BadLocationException e) {
	DLTKUIPlugin.log(e);
	}
	}
	}

	@Override
	public void documentAboutToBeChanged(DocumentEvent event) {
	// there is nothing to do here
	}

	@Override
	public void documentChanged(DocumentEvent event) {
	fireBufferChanged(new BufferChangedEvent(this, event.getOffset(),
	event.getLength(), event.getText()));
	}

	private void fireBufferChanged(BufferChangedEvent event) {
	if (fBufferListeners != null && fBufferListeners.size() > 0) {
	Iterator<IBufferChangedListener> e = new ArrayList<>(
	fBufferListeners).iterator();
	while (e.hasNext())
	e.next().bufferChanged(event);
	}
	}

	/**
	* Run the given runnable in the UI thread.
	*
	* @param runnable
	* the runnable
	* @since 3.3
	*/
	private static final void run(Runnable runnable) {
	Display currentDisplay = Display.getCurrent();
	if (currentDisplay != null)
	runnable.run();
	else
	Display.getDefault().syncExec(runnable);
	}

	}