org.eclipse.jface.text.TextUtilities Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjtools Show documentation
Show all versions of aspectjtools Show documentation
AspectJ tools most notably contains the AspectJ compiler (AJC). AJC applies aspects to Java classes during
compilation, fully replacing Javac for plain Java classes and also compiling native AspectJ or annotation-based
@AspectJ syntax. Furthermore, AJC can weave aspects into existing class files in a post-compile binary weaving step.
This library is a superset of AspectJ weaver and hence also of AspectJ runtime.
/*******************************************************************************
* Copyright (c) 2000, 2019 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jface.text;
import java.util.Collections;
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.Map.Entry;
import java.util.Objects;
import java.util.Set;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.AbstractLineTracker.DelimiterInfo;
/**
* A collection of text functions.
*
* This class is neither intended to be instantiated nor subclassed.
*
* @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.
*/
// Note: nextDelimiter implementation is sensitive to element order
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) {
String delimiter = nextDelimiter(text, 0).delimiter;
return delimiter != null ? delimiter : 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 int[] with two elements where the first is the starting offset, the
* second the index of the found search string in the given searchStrings
* array, returns [-1, -1] if no match exists
* @deprecated use {@link MultiStringMatcher#indexOf(CharSequence, int, String...)} instead.
* Notable differences:
*
* - new matcher indexOf does not allow negative offsets (old matcher treated them
* as
0)
* - new matcher indexOf will tolerate
null and empty search strings
* (old accepted empty but throw on null)
* - new matcher indexOf will not match empty string (old matched empty if
* nothing else matched)
*
* For the common case of searching the next default {@link #DELIMITERS delimiter}
* use the optimized {@link #nextDelimiter(CharSequence, int)} method instead.
*/
@Deprecated
public static int[] indexOf(String[] searchStrings, String text, int offset) {
// For compatibility this will throw a NullPointerException like the old implementation
// (instead of an IllegalArgumentException what would be the result from MultiStringMatcher.indexOf)
// and mimic the strange result for empty search string match from the old method.
Objects.requireNonNull(searchStrings);
for (String searchString : searchStrings) {
Objects.requireNonNull(searchString);
}
if (offset < 0) {
offset = 0; // for compatibility with old implementation
}
final MultiStringMatcher.Match match= MultiStringMatcher.indexOf(text, offset, searchStrings);
if (match != null) {
for (int i= 0; i < searchStrings.length; i++) {
if (match.getText().equals(searchStrings[i])) {
return new int[] { match.getOffset(), i };
}
}
} else {
// no match must check for empty search strings and mimic old return value
// search reversed because we want the last empty search string
for (int i= searchStrings.length - 1; i >= 0; i--) {
if (searchStrings[i].length() == 0) {
return new int[] { 0, i };
}
}
}
return new int[] { -1, -1 };
}
/**
* Returns the index of the longest search string with which the given text ends or
* -1 if none matches.
*
* @param searchStrings the strings to search for
* @param text the text to search
* @return the index in searchStrings of the longest string with which text ends or -1
*/
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 -1
* if none matches.
*
* @param searchStrings the strings to search for
* @param text the text to search
* @return the index in searchStrings of the longest string with which text starts or -1
*/
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 -1
* 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 -1
*/
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,
* null 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 documentEvents) throws BadLocationException {
if (documentEvents.isEmpty())
return null;
final Iterator iterator= documentEvents.iterator();
final DocumentEvent firstEvent= iterator.next();
// current merged event
final IDocument document= unprocessedDocument;
int offset= firstEvent.getOffset();
int length= firstEvent.getLength();
final StringBuilder text= new StringBuilder(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,
* null 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 documentEvents) throws BadLocationException {
if (documentEvents.isEmpty())
return null;
final ListIterator 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 removeDocumentPartitioners(IDocument document) {
Map partitioners= new HashMap<>();
if (document instanceof IDocumentExtension3) {
IDocumentExtension3 extension3= (IDocumentExtension3) document;
String[] partitionings= extension3.getPartitionings();
for (String partitioning : partitionings) {
IDocumentPartitioner partitioner= extension3.getDocumentPartitioner(partitioning);
if (partitioner != null) {
extension3.setDocumentPartitioner(partitioning, null);
partitioner.disconnect();
partitioners.put(partitioning, 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 partitioners) {
if (document instanceof IDocumentExtension3) {
IDocumentExtension3 extension3= (IDocumentExtension3) document;
for (Entry entry : partitioners.entrySet()) {
String partitioning= entry.getKey();
IDocumentPartitioner partitioner= entry.getValue();
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 true if precedence should be
* given to a open partition ending at offset over a
* closed partition starting at offset
* @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 true if precedence should be
* given to a open partition ending at offset over a
* closed partition starting at offset
* @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 null if this was impossible.
*
* @param document the document
* @return the partition managing position categories or null
* @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 categories= new HashSet<>();
for (String partitioning : partitionings) {
IDocumentPartitioner p= extension3.getDocumentPartitioner(partitioning);
if (p instanceof IDocumentPartitionerExtension2) {
IDocumentPartitionerExtension2 extension2= (IDocumentPartitionerExtension2) p;
String[] c= extension2.getManagingPositionCategories();
if (c != null) {
Collections.addAll(categories, c);
}
}
}
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) {
String lineDelimiter= null;
if (document instanceof IDocumentExtension4) {
lineDelimiter= ((IDocumentExtension4) document).getDefaultLineDelimiter();
if (lineDelimiter != null)
return lineDelimiter;
}
try {
lineDelimiter= document.getLineDelimiter(0);
} catch (BadLocationException x) {
// usually impossible for the first line
}
if (lineDelimiter != null)
return lineDelimiter;
String sysLineDelimiter= System.lineSeparator();
String[] delimiters= document.getLegalLineDelimiters();
Assert.isTrue(delimiters.length > 0);
for (String delimiter : delimiters) {
if (delimiter.equals(sysLineDelimiter)) {
lineDelimiter= sysLineDelimiter;
break;
}
}
if (lineDelimiter == null)
lineDelimiter= delimiters[0];
return lineDelimiter;
}
/**
* Returns true if the two regions overlap. Returns false if one of the
* arguments is null.
*
* @param left the left region
* @param right the right region
* @return true if the two regions overlap, false 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 null when array is null
* @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 null when array is null
* @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;
}
/**
* Search for the first standard line delimiter in text starting at given offset. Standard line
* delimiters are those defined in {@link #DELIMITERS}. This is a faster variant of the equal
*
*
* MultiStringMatcher.indexOf(TextUtilities.DELIMITERS, text, offset)
*
*
* @param text the text to be searched. Not null.
* @param offset the offset in text at which to start the search
* @return a {@link DelimiterInfo}. If no delimiter was found
* {@link DelimiterInfo#delimiterIndex} is -1 and
* {@link DelimiterInfo#delimiter} is null.
* @since 3.10
*/
public static DelimiterInfo nextDelimiter(CharSequence text, int offset) {
final DelimiterInfo info= new DelimiterInfo();
char ch;
final int length= text.length();
for (int i= offset; i < length; i++) {
ch= text.charAt(i);
if (ch == '\r') {
info.delimiterIndex= i;
if (i + 1 < length && text.charAt(i + 1) == '\n') {
info.delimiter= DELIMITERS[2];
break;
}
info.delimiter= DELIMITERS[1];
break;
} else if (ch == '\n') {
info.delimiterIndex= i;
info.delimiter= DELIMITERS[0];
break;
}
}
if (info.delimiter == null) {
info.delimiterIndex= -1;
} else {
info.delimiterLength= info.delimiter.length();
}
return info;
}
}