org.eclipse.text/src/org/eclipse/jface/text/TextUtilities.java - platform/eclipse.platform.text - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2015 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jface.text;

 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.runtime.Assert;


 /**
  * A collection of text functions.
  * <p>
  * This class is neither intended to be instantiated nor subclassed.
  * </p>
  * @noinstantiate This class is not intended to be instantiated by clients.
  * @noextend This class is not intended to be subclassed by clients.
  */
 public class TextUtilities {

 	/**
 	 * Default line delimiters used by the text functions of this class.
 	 */
 	public final static String[] DELIMITERS= new String[] { "\n", "\r", "\r\n" }; //$NON-NLS-3$ //$NON-NLS-2$ //$NON-NLS-1$

 	/**
 	 * Default line delimiters used by these text functions.
 	 *
 	 * @deprecated use DELIMITERS instead
 	 */
 	@Deprecated
 	public final static String[] fgDelimiters= DELIMITERS;


 	/**
 	 * Determines which one of default line delimiters appears first in the list. If none of them the
 	 * hint is returned.
 	 *
 	 * @param text the text to be checked
 	 * @param hint the line delimiter hint
 	 * @return the line delimiter
 	 */
 	public static String determineLineDelimiter(String text, String hint) {
 		try {
 			int[] info= indexOf(DELIMITERS, text, 0);
 			return DELIMITERS[info[1]];
 		} catch (ArrayIndexOutOfBoundsException x) {
 		}
 		return hint;
 	}

 	/**
 	 * Returns the starting position and the index of the first matching search string
 	 * in the given text that is greater than the given offset. If more than one search
 	 * string matches with the same starting position then the longest one is returned.
 	 *
 	 * @param searchStrings the strings to search for
 	 * @param text the text to be searched
 	 * @param offset the offset at which to start the search
 	 * @return an <code>int[]</code> with two elements where the first is the starting offset, the second the index of the found
 	 * 		search string in the given <code>searchStrings</code> array, returns <code>[-1, -1]</code> if no match exists
 	 */
 	public static int[] indexOf(String[] searchStrings, String text, int offset) {

 		int[] result= { -1, -1 };
 		int zeroIndex= -1;

 		for (int i= 0; i < searchStrings.length; i++) {

 			int length= searchStrings[i].length();

 			if (length == 0) {
 				zeroIndex= i;
 				continue;
 			}

 			int index= text.indexOf(searchStrings[i], offset);
 			if (index >= 0) {

 				if (result[0] == -1) {
 					result[0]= index;
 					result[1]= i;
 				} else if (index < result[0]) {
 					result[0]= index;
 					result[1]= i;
 				} else if (index == result[0] && length > searchStrings[result[1]].length()) {
 					result[0]= index;
 					result[1]= i;
 				}
 			}
 		}

 		if (zeroIndex > -1 && result[0] == -1) {
 			result[0]= 0;
 			result[1]= zeroIndex;
 		}

 		return result;
 	}

 	/**
 	 * Returns the index of the longest search string with which the given text ends or
 	 * <code>-1</code> if none matches.
 	 *
 	 * @param searchStrings the strings to search for
 	 * @param text the text to search
 	 * @return the index in <code>searchStrings</code> of the longest string with which <code>text</code> ends or <code>-1</code>
 	 */
 	public static int endsWith(String[] searchStrings, String text) {

 		int index= -1;

 		for (int i= 0; i < searchStrings.length; i++) {
 			if (text.endsWith(searchStrings[i])) {
 				if (index == -1 || searchStrings[i].length() > searchStrings[index].length())
 					index= i;
 			}
 		}

 		return index;
 	}

 	/**
 	 * Returns the index of the longest search string with which the given text starts or <code>-1</code>
 	 * if none matches.
 	 *
 	 * @param searchStrings the strings to search for
 	 * @param text the text to search
 	 * @return the index in <code>searchStrings</code> of the longest string with which <code>text</code> starts or <code>-1</code>
 	 */
 	public static int startsWith(String[] searchStrings, String text) {

 		int index= -1;

 		for (int i= 0; i < searchStrings.length; i++) {
 			if (text.startsWith(searchStrings[i])) {
 				if (index == -1 || searchStrings[i].length() > searchStrings[index].length())
 					index= i;
 			}
 		}

 		return index;
 	}

 	/**
 	 * Returns the index of the first compare string that equals the given text or <code>-1</code>
 	 * if none is equal.
 	 *
 	 * @param compareStrings the strings to compare with
 	 * @param text the text to check
 	 * @return the index of the first equal compare string or <code>-1</code>
 	 */
 	public static int equals(String[] compareStrings, String text) {
 		for (int i= 0; i < compareStrings.length; i++) {
 			if (text.equals(compareStrings[i]))
 				return i;
 		}
 		return -1;
 	}

 	/**
 	 * Returns a document event which is an accumulation of a list of document events,
 	 * <code>null</code> if the list of documentEvents is empty.
 	 * The document of the document events are ignored.
 	 *
 	 * @param unprocessedDocument the document to which the document events would be applied
 	 * @param documentEvents the list of document events to merge
 	 * @return returns the merged document event
 	 * @throws BadLocationException might be thrown if document is not in the correct state with respect to document events
 	 */
 	public static DocumentEvent mergeUnprocessedDocumentEvents(IDocument unprocessedDocument, List<? extends DocumentEvent> documentEvents) throws BadLocationException {

 		if (documentEvents.size() == 0)
 			return null;

 		final Iterator<? extends DocumentEvent> iterator= documentEvents.iterator();
 		final DocumentEvent firstEvent= iterator.next();

 		// current merged event
 		final IDocument document= unprocessedDocument;
 		int offset= firstEvent.getOffset();
 		int length= firstEvent.getLength();
 		final StringBuffer text= new StringBuffer(firstEvent.getText() == null ? "" : firstEvent.getText()); //$NON-NLS-1$

 		while (iterator.hasNext()) {

 			final int delta= text.length() - length;

 			final DocumentEvent event= iterator.next();
 			final int eventOffset= event.getOffset();
 			final int eventLength= event.getLength();
 			final String eventText= event.getText() == null ? "" : event.getText(); //$NON-NLS-1$

 			// event is right from merged event
 			if (eventOffset > offset + length + delta) {
 				final String string= document.get(offset + length, (eventOffset - delta) - (offset + length));
 				text.append(string);
 				text.append(eventText);

 				length= (eventOffset - delta) + eventLength - offset;

 			// event is left from merged event
 			} else if (eventOffset + eventLength < offset) {
 				final String string= document.get(eventOffset + eventLength, offset - (eventOffset + eventLength));
 				text.insert(0, string);
 				text.insert(0, eventText);

 				length= offset + length - eventOffset;
 				offset= eventOffset;

 			// events overlap each other
 			} else {
 				final int start= Math.max(0, eventOffset - offset);
 				final int end= Math.min(text.length(), eventLength + eventOffset - offset);
 				text.replace(start, end, eventText);

 				offset= Math.min(offset, eventOffset);
 				final int totalDelta= delta + eventText.length() - eventLength;
 				length= text.length() - totalDelta;
 			}
 		}

 		return new DocumentEvent(document, offset, length, text.toString());
 	}

 	/**
 	 * Returns a document event which is an accumulation of a list of document events,
 	 * <code>null</code> if the list of document events is empty.
 	 * The document events being merged must all refer to the same document, to which
 	 * the document changes have been already applied.
 	 *
 	 * @param documentEvents the list of document events to merge
 	 * @return returns the merged document event
 	 * @throws BadLocationException might be thrown if document is not in the correct state with respect to document events
 	 */
 	public static DocumentEvent mergeProcessedDocumentEvents(List<? extends DocumentEvent> documentEvents) throws BadLocationException {

 		if (documentEvents.size() == 0)
 			return null;

 		final ListIterator<? extends DocumentEvent> iterator= documentEvents.listIterator(documentEvents.size());
 		final DocumentEvent firstEvent= iterator.previous();

 		// current merged event
 		final IDocument document= firstEvent.getDocument();
 		int offset= firstEvent.getOffset();
 		int length= firstEvent.getLength();
 		int textLength= firstEvent.getText() == null ? 0 : firstEvent.getText().length();

 		while (iterator.hasPrevious()) {

 			final int delta= length - textLength;

 			final DocumentEvent event= iterator.previous();
 			final int eventOffset= event.getOffset();
 			final int eventLength= event.getLength();
 			final int eventTextLength= event.getText() == null ? 0 : event.getText().length();

 			// event is right from merged event
 			if (eventOffset > offset + textLength + delta) {
 				length= (eventOffset - delta) - (offset + textLength) + length + eventLength;
 				textLength= (eventOffset - delta) + eventTextLength - offset;

 			// event is left from merged event
 			} else if (eventOffset + eventTextLength < offset) {
 				length= offset - (eventOffset + eventTextLength) + length + eventLength;
 				textLength= offset + textLength - eventOffset;
 				offset= eventOffset;

 			// events overlap each other
 			} else {
 				final int start= Math.max(0, eventOffset - offset);
 				final int end= Math.min(length, eventTextLength + eventOffset - offset);
 				length += eventLength - (end - start);

 				offset= Math.min(offset, eventOffset);
 				final int totalDelta= delta + eventLength - eventTextLength;
 				textLength= length - totalDelta;
 			}
 		}

 		final String text= document.get(offset, textLength);
 		return new DocumentEvent(document, offset, length, text);
 	}

 	/**
 	 * Removes all connected document partitioners from the given document and stores them
 	 * under their partitioning name in a map. This map is returned. After this method has been called
 	 * the given document is no longer connected to any document partitioner.
 	 *
 	 * @param document the document
 	 * @return the map containing the removed partitioners
 	 */
 	public static Map<String, IDocumentPartitioner> removeDocumentPartitioners(IDocument document) {
 		Map<String, IDocumentPartitioner> partitioners= new HashMap<>();
 		if (document instanceof IDocumentExtension3) {
 			IDocumentExtension3 extension3= (IDocumentExtension3) document;
 			String[] partitionings= extension3.getPartitionings();
 			for (int i= 0; i < partitionings.length; i++) {
 				IDocumentPartitioner partitioner= extension3.getDocumentPartitioner(partitionings[i]);
 				if (partitioner != null) {
 					extension3.setDocumentPartitioner(partitionings[i], null);
 					partitioner.disconnect();
 					partitioners.put(partitionings[i], partitioner);
 				}
 			}
 		} else {
 			IDocumentPartitioner partitioner= document.getDocumentPartitioner();
 			if (partitioner != null) {
 				document.setDocumentPartitioner(null);
 				partitioner.disconnect();
 				partitioners.put(IDocumentExtension3.DEFAULT_PARTITIONING, partitioner);
 			}
 		}
 		return partitioners;
 	}

 	/**
 	 * Connects the given document with all document partitioners stored in the given map under
 	 * their partitioning name. This method cleans the given map.
 	 *
 	 * @param document the document
 	 * @param partitioners the map containing the partitioners to be connected
 	 * @since 3.0
 	 */
 	public static void addDocumentPartitioners(IDocument document, Map<String, ? extends IDocumentPartitioner> partitioners) {
 		if (document instanceof IDocumentExtension3) {
 			IDocumentExtension3 extension3= (IDocumentExtension3) document;
 			Iterator<String> e= partitioners.keySet().iterator();
 			while (e.hasNext()) {
 				String partitioning= e.next();
 				IDocumentPartitioner partitioner= partitioners.get(partitioning);
 				partitioner.connect(document);
 				extension3.setDocumentPartitioner(partitioning, partitioner);
 			}
 			partitioners.clear();
 		} else {
 			IDocumentPartitioner partitioner= partitioners.get(IDocumentExtension3.DEFAULT_PARTITIONING);
 			partitioner.connect(document);
 			document.setDocumentPartitioner(partitioner);
 		}
 	}

 	/**
 	 * Returns the content type at the given offset of the given document.
 	 *
 	 * @param document the document
 	 * @param partitioning the partitioning to be used
 	 * @param offset the offset
 	 * @param preferOpenPartitions <code>true</code> if precedence should be
 	 *        given to a open partition ending at <code>offset</code> over a
 	 *        closed partition starting at <code>offset</code>
 	 * @return the content type at the given offset of the document
 	 * @throws BadLocationException if offset is invalid in the document
 	 * @since 3.0
 	 */
 	public static String getContentType(IDocument document, String partitioning, int offset, boolean preferOpenPartitions) throws BadLocationException {
 		if (document instanceof IDocumentExtension3) {
 			IDocumentExtension3 extension3= (IDocumentExtension3) document;
 			try {
 				return extension3.getContentType(partitioning, offset, preferOpenPartitions);
 			} catch (BadPartitioningException x) {
 				return IDocument.DEFAULT_CONTENT_TYPE;
 			}
 		}

 		return document.getContentType(offset);
 	}

 	/**
 	 * Returns the partition of the given offset of the given document.
 	 *
 	 * @param document the document
 	 * @param partitioning the partitioning to be used
 	 * @param offset the offset
 	 * @param preferOpenPartitions <code>true</code> if precedence should be
 	 *        given to a open partition ending at <code>offset</code> over a
 	 *        closed partition starting at <code>offset</code>
 	 * @return the content type at the given offset of this viewer's input
 	 *         document
 	 * @throws BadLocationException if offset is invalid in the given document
 	 * @since 3.0
 	 */
 	public static ITypedRegion getPartition(IDocument document, String partitioning, int offset, boolean preferOpenPartitions) throws BadLocationException {
 		if (document instanceof IDocumentExtension3) {
 			IDocumentExtension3 extension3= (IDocumentExtension3) document;
 			try {
 				return extension3.getPartition(partitioning, offset, preferOpenPartitions);
 			} catch (BadPartitioningException x) {
 				return new TypedRegion(0, document.getLength(), IDocument.DEFAULT_CONTENT_TYPE);
 			}
 		}

 		return document.getPartition(offset);
 	}

 	/**
 	 * Computes and returns the partitioning for the given region of the given
 	 * document for the given partitioning name.
 	 *
 	 * @param document the document
 	 * @param partitioning the partitioning name
 	 * @param offset the region offset
 	 * @param length the region length
 	 * @param includeZeroLengthPartitions whether to include zero-length partitions
 	 * @return the partitioning for the given region of the given document for
 	 *         the given partitioning name
 	 * @throws BadLocationException if the given region is invalid for the given
 	 *         document
 	 * @since 3.0
 	 */
 	public static ITypedRegion[] computePartitioning(IDocument document, String partitioning, int offset, int length, boolean includeZeroLengthPartitions) throws BadLocationException {
 		if (document instanceof IDocumentExtension3) {
 			IDocumentExtension3 extension3= (IDocumentExtension3) document;
 			try {
 				return extension3.computePartitioning(partitioning, offset, length, includeZeroLengthPartitions);
 			} catch (BadPartitioningException x) {
 				return new ITypedRegion[0];
 			}
 		}

 		return document.computePartitioning(offset, length);
 	}

 	/**
 	 * Computes and returns the partition managing position categories for the
 	 * given document or <code>null</code> if this was impossible.
 	 *
 	 * @param document the document
 	 * @return the partition managing position categories or <code>null</code>
 	 * @since 3.0
 	 */
 	public static String[] computePartitionManagingCategories(IDocument document) {
 		if (document instanceof IDocumentExtension3) {
 			IDocumentExtension3 extension3= (IDocumentExtension3) document;
 			String[] partitionings= extension3.getPartitionings();
 			if (partitionings != null) {
 				Set<String> categories= new HashSet<>();
 				for (int i= 0; i < partitionings.length; i++) {
 					IDocumentPartitioner p= extension3.getDocumentPartitioner(partitionings[i]);
 					if (p instanceof IDocumentPartitionerExtension2) {
 						IDocumentPartitionerExtension2 extension2= (IDocumentPartitionerExtension2) p;
 						String[] c= extension2.getManagingPositionCategories();
 						if (c != null) {
 							for (int j= 0; j < c.length; j++)
 								categories.add(c[j]);
 						}
 					}
 				}
 				String[] result= new String[categories.size()];
 				categories.toArray(result);
 				return result;
 			}
 		}
 		return null;
 	}

 	/**
 	 * Returns the default line delimiter for the given document. This is
 	 * {@link IDocumentExtension4#getDefaultLineDelimiter()} if available.
 	 * Otherwise, this is either the delimiter of the first line, or the platform line delimiter if it is
 	 * a legal line delimiter, or the first one of the legal line delimiters. The default line delimiter should be used when performing document
 	 * manipulations that span multiple lines.
 	 *
 	 * @param document the document
 	 * @return the document's default line delimiter
 	 * @since 3.0
 	 */
 	public static String getDefaultLineDelimiter(IDocument document) {

 		if (document instanceof IDocumentExtension4)
 			return ((IDocumentExtension4)document).getDefaultLineDelimiter();

 		String lineDelimiter= null;

 		try {
 			lineDelimiter= document.getLineDelimiter(0);
 		} catch (BadLocationException x) {
 		}

 		if (lineDelimiter != null)
 			return lineDelimiter;

 		String sysLineDelimiter= System.getProperty("line.separator"); //$NON-NLS-1$
 		String[] delimiters= document.getLegalLineDelimiters();
 		Assert.isTrue(delimiters.length > 0);
 		for (int i= 0; i < delimiters.length; i++) {
 			if (delimiters[i].equals(sysLineDelimiter)) {
 				lineDelimiter= sysLineDelimiter;
 				break;
 			}
 		}

 		if (lineDelimiter == null)
 			lineDelimiter= delimiters[0];

 		return lineDelimiter;
 	}

 	/**
 	 * Returns <code>true</code> if the two regions overlap. Returns <code>false</code> if one of the
 	 * arguments is <code>null</code>.
 	 *
 	 * @param left the left region
 	 * @param right the right region
 	 * @return <code>true</code> if the two regions overlap, <code>false</code> otherwise
 	 * @since 3.0
 	 */
 	public static boolean overlaps(IRegion left, IRegion right) {

 		if (left == null || right == null)
 			return false;

 		int rightEnd= right.getOffset() + right.getLength();
 		int leftEnd= left.getOffset()+ left.getLength();

 		if (right.getLength() > 0) {
 			if (left.getLength() > 0)
 				return left.getOffset() < rightEnd && right.getOffset() < leftEnd;
 			return  right.getOffset() <= left.getOffset() && left.getOffset() < rightEnd;
 		}

 		if (left.getLength() > 0)
 			return left.getOffset() <= right.getOffset() && right.getOffset() < leftEnd;

 		return left.getOffset() == right.getOffset();
 	}

 	/**
 	 * Returns a copy of the given string array.
 	 *
 	 * @param array the string array to be copied
 	 * @return a copy of the given string array or <code>null</code> when <code>array</code> is <code>null</code>
 	 * @since 3.1
 	 */
 	public static String[] copy(String[] array) {
 		if (array != null) {
 			String[] copy= new String[array.length];
 			System.arraycopy(array, 0, copy, 0, array.length);
 			return copy;
 		}
 		return null;
 	}

 	/**
 	 * Returns a copy of the given integer array.
 	 *
 	 * @param array the integer array to be copied
 	 * @return a copy of the given integer array or <code>null</code> when <code>array</code> is <code>null</code>
 	 * @since 3.1
 	 */
 	public static int[] copy(int[] array) {
 		if (array != null) {
 			int[] copy= new int[array.length];
 			System.arraycopy(array, 0, copy, 0, array.length);
 			return copy;
 		}
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2015 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jface.text;

	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.ListIterator;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.runtime.Assert;


	/**
	* A collection of text functions.
	* <p>
	* This class is neither intended to be instantiated nor subclassed.
	* </p>
	* @noinstantiate This class is not intended to be instantiated by clients.
	* @noextend This class is not intended to be subclassed by clients.
	*/
	public class TextUtilities {

	/**
	* Default line delimiters used by the text functions of this class.
	*/
	public final static String[] DELIMITERS= new String[] { "\n", "\r", "\r\n" }; //$NON-NLS-3$ //$NON-NLS-2$ //$NON-NLS-1$

	/**
	* Default line delimiters used by these text functions.
	*
	* @deprecated use DELIMITERS instead
	*/
	@Deprecated
	public final static String[] fgDelimiters= DELIMITERS;



	/**
	* Determines which one of default line delimiters appears first in the list. If none of them the
	* hint is returned.
	*
	* @param text the text to be checked
	* @param hint the line delimiter hint
	* @return the line delimiter
	*/
	public static String determineLineDelimiter(String text, String hint) {
	try {
	int[] info= indexOf(DELIMITERS, text, 0);
	return DELIMITERS[info[1]];
	} catch (ArrayIndexOutOfBoundsException x) {
	}
	return hint;
	}

	/**
	* Returns the starting position and the index of the first matching search string
	* in the given text that is greater than the given offset. If more than one search
	* string matches with the same starting position then the longest one is returned.
	*
	* @param searchStrings the strings to search for
	* @param text the text to be searched
	* @param offset the offset at which to start the search
	* @return an <code>int[]</code> with two elements where the first is the starting offset, the second the index of the found
	* search string in the given <code>searchStrings</code> array, returns <code>[-1, -1]</code> if no match exists
	*/
	public static int[] indexOf(String[] searchStrings, String text, int offset) {

	int[] result= { -1, -1 };
	int zeroIndex= -1;

	for (int i= 0; i < searchStrings.length; i++) {

	int length= searchStrings[i].length();

	if (length == 0) {
	zeroIndex= i;
	continue;
	}

	int index= text.indexOf(searchStrings[i], offset);
	if (index >= 0) {

	if (result[0] == -1) {
	result[0]= index;
	result[1]= i;
	} else if (index < result[0]) {
	result[0]= index;
	result[1]= i;
	} else if (index == result[0] && length > searchStrings[result[1]].length()) {
	result[0]= index;
	result[1]= i;
	}
	}
	}

	if (zeroIndex > -1 && result[0] == -1) {
	result[0]= 0;
	result[1]= zeroIndex;
	}

	return result;
	}

	/**
	* Returns the index of the longest search string with which the given text ends or
	* <code>-1</code> if none matches.
	*
	* @param searchStrings the strings to search for
	* @param text the text to search
	* @return the index in <code>searchStrings</code> of the longest string with which <code>text</code> ends or <code>-1</code>
	*/
	public static int endsWith(String[] searchStrings, String text) {

	int index= -1;

	for (int i= 0; i < searchStrings.length; i++) {
	if (text.endsWith(searchStrings[i])) {
	if (index == -1 \|\| searchStrings[i].length() > searchStrings[index].length())
	index= i;
	}
	}

	return index;
	}

	/**
	* Returns the index of the longest search string with which the given text starts or <code>-1</code>
	* if none matches.
	*
	* @param searchStrings the strings to search for
	* @param text the text to search
	* @return the index in <code>searchStrings</code> of the longest string with which <code>text</code> starts or <code>-1</code>
	*/
	public static int startsWith(String[] searchStrings, String text) {

	int index= -1;

	for (int i= 0; i < searchStrings.length; i++) {
	if (text.startsWith(searchStrings[i])) {
	if (index == -1 \|\| searchStrings[i].length() > searchStrings[index].length())
	index= i;
	}
	}

	return index;
	}

	/**
	* Returns the index of the first compare string that equals the given text or <code>-1</code>
	* if none is equal.
	*
	* @param compareStrings the strings to compare with
	* @param text the text to check
	* @return the index of the first equal compare string or <code>-1</code>
	*/
	public static int equals(String[] compareStrings, String text) {
	for (int i= 0; i < compareStrings.length; i++) {
	if (text.equals(compareStrings[i]))
	return i;
	}
	return -1;
	}

	/**
	* Returns a document event which is an accumulation of a list of document events,
	* <code>null</code> if the list of documentEvents is empty.
	* The document of the document events are ignored.
	*
	* @param unprocessedDocument the document to which the document events would be applied
	* @param documentEvents the list of document events to merge
	* @return returns the merged document event
	* @throws BadLocationException might be thrown if document is not in the correct state with respect to document events
	*/
	public static DocumentEvent mergeUnprocessedDocumentEvents(IDocument unprocessedDocument, List<? extends DocumentEvent> documentEvents) throws BadLocationException {

	if (documentEvents.size() == 0)
	return null;

	final Iterator<? extends DocumentEvent> iterator= documentEvents.iterator();
	final DocumentEvent firstEvent= iterator.next();

	// current merged event
	final IDocument document= unprocessedDocument;
	int offset= firstEvent.getOffset();
	int length= firstEvent.getLength();
	final StringBuffer text= new StringBuffer(firstEvent.getText() == null ? "" : firstEvent.getText()); //$NON-NLS-1$

	while (iterator.hasNext()) {

	final int delta= text.length() - length;

	final DocumentEvent event= iterator.next();
	final int eventOffset= event.getOffset();
	final int eventLength= event.getLength();
	final String eventText= event.getText() == null ? "" : event.getText(); //$NON-NLS-1$

	// event is right from merged event
	if (eventOffset > offset + length + delta) {
	final String string= document.get(offset + length, (eventOffset - delta) - (offset + length));
	text.append(string);
	text.append(eventText);

	length= (eventOffset - delta) + eventLength - offset;

	// event is left from merged event
	} else if (eventOffset + eventLength < offset) {
	final String string= document.get(eventOffset + eventLength, offset - (eventOffset + eventLength));
	text.insert(0, string);
	text.insert(0, eventText);

	length= offset + length - eventOffset;
	offset= eventOffset;

	// events overlap each other
	} else {
	final int start= Math.max(0, eventOffset - offset);
	final int end= Math.min(text.length(), eventLength + eventOffset - offset);
	text.replace(start, end, eventText);

	offset= Math.min(offset, eventOffset);
	final int totalDelta= delta + eventText.length() - eventLength;
	length= text.length() - totalDelta;
	}
	}

	return new DocumentEvent(document, offset, length, text.toString());
	}

	/**
	* Returns a document event which is an accumulation of a list of document events,
	* <code>null</code> if the list of document events is empty.
	* The document events being merged must all refer to the same document, to which
	* the document changes have been already applied.
	*
	* @param documentEvents the list of document events to merge
	* @return returns the merged document event
	* @throws BadLocationException might be thrown if document is not in the correct state with respect to document events
	*/
	public static DocumentEvent mergeProcessedDocumentEvents(List<? extends DocumentEvent> documentEvents) throws BadLocationException {

	if (documentEvents.size() == 0)
	return null;

	final ListIterator<? extends DocumentEvent> iterator= documentEvents.listIterator(documentEvents.size());
	final DocumentEvent firstEvent= iterator.previous();

	// current merged event
	final IDocument document= firstEvent.getDocument();
	int offset= firstEvent.getOffset();
	int length= firstEvent.getLength();
	int textLength= firstEvent.getText() == null ? 0 : firstEvent.getText().length();

	while (iterator.hasPrevious()) {

	final int delta= length - textLength;

	final DocumentEvent event= iterator.previous();
	final int eventOffset= event.getOffset();
	final int eventLength= event.getLength();
	final int eventTextLength= event.getText() == null ? 0 : event.getText().length();

	// event is right from merged event
	if (eventOffset > offset + textLength + delta) {
	length= (eventOffset - delta) - (offset + textLength) + length + eventLength;
	textLength= (eventOffset - delta) + eventTextLength - offset;

	// event is left from merged event
	} else if (eventOffset + eventTextLength < offset) {
	length= offset - (eventOffset + eventTextLength) + length + eventLength;
	textLength= offset + textLength - eventOffset;
	offset= eventOffset;

	// events overlap each other
	} else {
	final int start= Math.max(0, eventOffset - offset);
	final int end= Math.min(length, eventTextLength + eventOffset - offset);
	length += eventLength - (end - start);

	offset= Math.min(offset, eventOffset);
	final int totalDelta= delta + eventLength - eventTextLength;
	textLength= length - totalDelta;
	}
	}

	final String text= document.get(offset, textLength);
	return new DocumentEvent(document, offset, length, text);
	}

	/**
	* Removes all connected document partitioners from the given document and stores them
	* under their partitioning name in a map. This map is returned. After this method has been called
	* the given document is no longer connected to any document partitioner.
	*
	* @param document the document
	* @return the map containing the removed partitioners
	*/
	public static Map<String, IDocumentPartitioner> removeDocumentPartitioners(IDocument document) {
	Map<String, IDocumentPartitioner> partitioners= new HashMap<>();
	if (document instanceof IDocumentExtension3) {
	IDocumentExtension3 extension3= (IDocumentExtension3) document;
	String[] partitionings= extension3.getPartitionings();
	for (int i= 0; i < partitionings.length; i++) {
	IDocumentPartitioner partitioner= extension3.getDocumentPartitioner(partitionings[i]);
	if (partitioner != null) {
	extension3.setDocumentPartitioner(partitionings[i], null);
	partitioner.disconnect();
	partitioners.put(partitionings[i], partitioner);
	}
	}
	} else {
	IDocumentPartitioner partitioner= document.getDocumentPartitioner();
	if (partitioner != null) {
	document.setDocumentPartitioner(null);
	partitioner.disconnect();
	partitioners.put(IDocumentExtension3.DEFAULT_PARTITIONING, partitioner);
	}
	}
	return partitioners;
	}

	/**
	* Connects the given document with all document partitioners stored in the given map under
	* their partitioning name. This method cleans the given map.
	*
	* @param document the document
	* @param partitioners the map containing the partitioners to be connected
	* @since 3.0
	*/
	public static void addDocumentPartitioners(IDocument document, Map<String, ? extends IDocumentPartitioner> partitioners) {
	if (document instanceof IDocumentExtension3) {
	IDocumentExtension3 extension3= (IDocumentExtension3) document;
	Iterator<String> e= partitioners.keySet().iterator();
	while (e.hasNext()) {
	String partitioning= e.next();
	IDocumentPartitioner partitioner= partitioners.get(partitioning);
	partitioner.connect(document);
	extension3.setDocumentPartitioner(partitioning, partitioner);
	}
	partitioners.clear();
	} else {
	IDocumentPartitioner partitioner= partitioners.get(IDocumentExtension3.DEFAULT_PARTITIONING);
	partitioner.connect(document);
	document.setDocumentPartitioner(partitioner);
	}
	}

	/**
	* Returns the content type at the given offset of the given document.
	*
	* @param document the document
	* @param partitioning the partitioning to be used
	* @param offset the offset
	* @param preferOpenPartitions <code>true</code> if precedence should be
	* given to a open partition ending at <code>offset</code> over a
	* closed partition starting at <code>offset</code>
	* @return the content type at the given offset of the document
	* @throws BadLocationException if offset is invalid in the document
	* @since 3.0
	*/
	public static String getContentType(IDocument document, String partitioning, int offset, boolean preferOpenPartitions) throws BadLocationException {
	if (document instanceof IDocumentExtension3) {
	IDocumentExtension3 extension3= (IDocumentExtension3) document;
	try {
	return extension3.getContentType(partitioning, offset, preferOpenPartitions);
	} catch (BadPartitioningException x) {
	return IDocument.DEFAULT_CONTENT_TYPE;
	}
	}

	return document.getContentType(offset);
	}

	/**
	* Returns the partition of the given offset of the given document.
	*
	* @param document the document
	* @param partitioning the partitioning to be used
	* @param offset the offset
	* @param preferOpenPartitions <code>true</code> if precedence should be
	* given to a open partition ending at <code>offset</code> over a
	* closed partition starting at <code>offset</code>
	* @return the content type at the given offset of this viewer's input
	* document
	* @throws BadLocationException if offset is invalid in the given document
	* @since 3.0
	*/
	public static ITypedRegion getPartition(IDocument document, String partitioning, int offset, boolean preferOpenPartitions) throws BadLocationException {
	if (document instanceof IDocumentExtension3) {
	IDocumentExtension3 extension3= (IDocumentExtension3) document;
	try {
	return extension3.getPartition(partitioning, offset, preferOpenPartitions);
	} catch (BadPartitioningException x) {
	return new TypedRegion(0, document.getLength(), IDocument.DEFAULT_CONTENT_TYPE);
	}
	}

	return document.getPartition(offset);
	}

	/**
	* Computes and returns the partitioning for the given region of the given
	* document for the given partitioning name.
	*
	* @param document the document
	* @param partitioning the partitioning name
	* @param offset the region offset
	* @param length the region length
	* @param includeZeroLengthPartitions whether to include zero-length partitions
	* @return the partitioning for the given region of the given document for
	* the given partitioning name
	* @throws BadLocationException if the given region is invalid for the given
	* document
	* @since 3.0
	*/
	public static ITypedRegion[] computePartitioning(IDocument document, String partitioning, int offset, int length, boolean includeZeroLengthPartitions) throws BadLocationException {
	if (document instanceof IDocumentExtension3) {
	IDocumentExtension3 extension3= (IDocumentExtension3) document;
	try {
	return extension3.computePartitioning(partitioning, offset, length, includeZeroLengthPartitions);
	} catch (BadPartitioningException x) {
	return new ITypedRegion[0];
	}
	}

	return document.computePartitioning(offset, length);
	}

	/**
	* Computes and returns the partition managing position categories for the
	* given document or <code>null</code> if this was impossible.
	*
	* @param document the document
	* @return the partition managing position categories or <code>null</code>
	* @since 3.0
	*/
	public static String[] computePartitionManagingCategories(IDocument document) {
	if (document instanceof IDocumentExtension3) {
	IDocumentExtension3 extension3= (IDocumentExtension3) document;
	String[] partitionings= extension3.getPartitionings();
	if (partitionings != null) {
	Set<String> categories= new HashSet<>();
	for (int i= 0; i < partitionings.length; i++) {
	IDocumentPartitioner p= extension3.getDocumentPartitioner(partitionings[i]);
	if (p instanceof IDocumentPartitionerExtension2) {
	IDocumentPartitionerExtension2 extension2= (IDocumentPartitionerExtension2) p;
	String[] c= extension2.getManagingPositionCategories();
	if (c != null) {
	for (int j= 0; j < c.length; j++)
	categories.add(c[j]);
	}
	}
	}
	String[] result= new String[categories.size()];
	categories.toArray(result);
	return result;
	}
	}
	return null;
	}

	/**
	* Returns the default line delimiter for the given document. This is
	* {@link IDocumentExtension4#getDefaultLineDelimiter()} if available.
	* Otherwise, this is either the delimiter of the first line, or the platform line delimiter if it is
	* a legal line delimiter, or the first one of the legal line delimiters. The default line delimiter should be used when performing document
	* manipulations that span multiple lines.
	*
	* @param document the document
	* @return the document's default line delimiter
	* @since 3.0
	*/
	public static String getDefaultLineDelimiter(IDocument document) {

	if (document instanceof IDocumentExtension4)
	return ((IDocumentExtension4)document).getDefaultLineDelimiter();

	String lineDelimiter= null;

	try {
	lineDelimiter= document.getLineDelimiter(0);
	} catch (BadLocationException x) {
	}

	if (lineDelimiter != null)
	return lineDelimiter;

	String sysLineDelimiter= System.getProperty("line.separator"); //$NON-NLS-1$
	String[] delimiters= document.getLegalLineDelimiters();
	Assert.isTrue(delimiters.length > 0);
	for (int i= 0; i < delimiters.length; i++) {
	if (delimiters[i].equals(sysLineDelimiter)) {
	lineDelimiter= sysLineDelimiter;
	break;
	}
	}

	if (lineDelimiter == null)
	lineDelimiter= delimiters[0];

	return lineDelimiter;
	}

	/**
	* Returns <code>true</code> if the two regions overlap. Returns <code>false</code> if one of the
	* arguments is <code>null</code>.
	*
	* @param left the left region
	* @param right the right region
	* @return <code>true</code> if the two regions overlap, <code>false</code> otherwise
	* @since 3.0
	*/
	public static boolean overlaps(IRegion left, IRegion right) {

	if (left == null \|\| right == null)
	return false;

	int rightEnd= right.getOffset() + right.getLength();
	int leftEnd= left.getOffset()+ left.getLength();

	if (right.getLength() > 0) {
	if (left.getLength() > 0)
	return left.getOffset() < rightEnd && right.getOffset() < leftEnd;
	return right.getOffset() <= left.getOffset() && left.getOffset() < rightEnd;
	}

	if (left.getLength() > 0)
	return left.getOffset() <= right.getOffset() && right.getOffset() < leftEnd;

	return left.getOffset() == right.getOffset();
	}

	/**
	* Returns a copy of the given string array.
	*
	* @param array the string array to be copied
	* @return a copy of the given string array or <code>null</code> when <code>array</code> is <code>null</code>
	* @since 3.1
	*/
	public static String[] copy(String[] array) {
	if (array != null) {
	String[] copy= new String[array.length];
	System.arraycopy(array, 0, copy, 0, array.length);
	return copy;
	}
	return null;
	}

	/**
	* Returns a copy of the given integer array.
	*
	* @param array the integer array to be copied
	* @return a copy of the given integer array or <code>null</code> when <code>array</code> is <code>null</code>
	* @since 3.1
	*/
	public static int[] copy(int[] array) {
	if (array != null) {
	int[] copy= new int[array.length];
	System.arraycopy(array, 0, copy, 0, array.length);
	return copy;
	}
	return null;
	}
	}