Java ITextRegion.getOffset方法代码示例

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
private static ILocationData createLocationData(ITraceURIConverter converter, ILocationInFileProvider locationProvider, EObject object, ILocationInFileProviderExtension.RegionDescription query, boolean skipEmpty) {
	ITextRegion textRegion = locationProvider instanceof ILocationInFileProviderExtension ? 
			((ILocationInFileProviderExtension) locationProvider).getTextRegion(object, query) : locationProvider.getFullTextRegion(object);
	if (!(textRegion instanceof ITextRegionWithLineInformation)) {
		if (log.isDebugEnabled())
			log.debug("location provider returned text region without line information.", new Exception());
		if (textRegion != null)
			textRegion = new TextRegionWithLineInformation(textRegion.getOffset(), textRegion.getLength(), 0, 0);
		else
			return null;
	} 
	// usually we want to skip empty regions but if the root region is empty, we want to use it to store the path information along
	// with the empty offset / length pair
	if (skipEmpty && textRegion == ITextRegion.EMPTY_REGION) {
		return null;
	}
	ILocationData newData = createLocationData(converter, object, (ITextRegionWithLineInformation) textRegion);
	return newData;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
@Override
public IFormattedRegion format(final ICompositeNode root, final int offset, final int length) {
  final TokenStringBuffer buf = new TokenStringBuffer();
  final ITokenStream out = offset == 0 ? buf : new FilterStream(buf);
  final ITokenStream formatStream = formatter.createFormatterStream(null, out, false);
  if (!(formatStream instanceof IDelegatingTokenStream)) {
    return super.format(root, offset, length);
  }
  try {
    ITextRegion range;
    if (offset > 0) {
      int noffset = root.getText().lastIndexOf('\n', offset) + 1; // Keep the new line
      int nlength = length + (offset - noffset); // Always start in the beginning of the line
      range = nodeModelStreamer.feedTokenStream(formatStream, root, noffset, nlength);
    } else {
      range = nodeModelStreamer.feedTokenStream(formatStream, root, offset, length);
    }
    return new FormattedRegion(range.getOffset(), range.getLength(), buf.toString());
  } catch (IOException e) {
    // this should never happen since TokenStringBuffer doesn't throw IOEs.
    throw new RuntimeException(e); // NOPMD
  }
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
/**
 * @since 2.1
 */
public INode getCrossReferenceNode(XtextResource resource, ITextRegion region) {
	IParseResult parseResult = resource.getParseResult();
	if (parseResult != null) {
		ILeafNode leaf = NodeModelUtils.findLeafNodeAtOffset(parseResult.getRootNode(), region.getOffset());
		INode crossRefNode = findCrossReferenceNode(leaf);
		// if not a cross reference position and the cursor is at the beginning of a node try the previous one.
		if (crossRefNode == null && leaf != null && region.getLength()==0 && leaf.getOffset() == region.getOffset()) {
			leaf = NodeModelUtils.findLeafNodeAtOffset(parseResult.getRootNode(), region.getOffset() - 1);
			return findCrossReferenceNode(leaf);
		} else if (crossRefNode != null && crossRefNode.getEndOffset() >= region.getOffset() + region.getLength()) {
			return crossRefNode;
		}
	}
	return null;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
@Override
public boolean isModified(ITextRegion region) {
	int offset = region.getOffset();
	int endOffset = offset + region.getLength();
	for (RewriteAction action : rewrites) {
		int rwOffset = action.originalFirst.getOffset();
		int rwEndOffset = action.originalLast.getEndOffset();
		if (rwOffset <= offset && offset < rwEndOffset) {
			return true;
		}
		if (rwOffset < endOffset && endOffset <= rwEndOffset) {
			return true;
		}
	}
	return false;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
protected boolean isInRequestedRange(EObject obj) {
	Collection<ITextRegion> regions = request.getRegions();
	if (regions.isEmpty())
		return true;
	ITextRegionAccess access = request.getTextRegionAccess();
	IEObjectRegion objRegion = access.regionForEObject(obj);
	if (objRegion == null)
		return false;
	IHiddenRegion previousHidden = objRegion.getPreviousHiddenRegion();
	IHiddenRegion nextHidden = objRegion.getNextHiddenRegion();
	int objOffset = previousHidden != null ? previousHidden.getOffset() : 0;
	int objEnd = nextHidden != null ? nextHidden.getEndOffset() : access.regionForRootEObject().getEndOffset();
	for (ITextRegion region : regions) {
		int regionOffset = region.getOffset();
		int regionEnd = regionOffset + region.getLength();
		if (regionOffset <= objEnd && regionEnd >= objOffset)
			return true;
	}
	return false;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
@Override
public IFormattedRegion format(ICompositeNode root, int offset, int length) {
	String indent = getIndentation(root, offset);
	TokenStringBuffer buf = new TokenStringBuffer();
	ITokenStream out = offset == 0 ? buf : new FilterFirstWhitespaceStream(buf);
	ITokenStream fmt;
	if (formatter instanceof IFormatterExtension) {
		EObject semanticElement = NodeModelUtils.findActualSemanticObjectFor(root);
		if (semanticElement != null)
			fmt = ((IFormatterExtension) formatter).createFormatterStream(semanticElement, indent, out, false);
		else {
			// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=380406
			ITextRegion rootRegion = root.getTextRegion();
			return new FormattedRegion(rootRegion.getOffset(), rootRegion.getLength(), root.getText());
		}
	} else
		fmt = formatter.createFormatterStream(indent, out, false);
	try {
		ITextRegion range = nodeModelStreamer.feedTokenStream(fmt, root, offset, length);
		return new FormattedRegion(range.getOffset(), range.getLength(), buf.toString());
	} catch (IOException e) {
		// this should never happen since TokenStringBuffer doesn't throw IOEs.
		throw new RuntimeException(e);
	}
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
/**
 * Returns with {@code true} if the AST element selected from the resource
 * can provide document highlights, otherwise returns with {@code false}.
 * 
 * <p>
 * Clients may override this method to change the default behavior.
 * 
 * @param selectedElemnt
 *            the selected element resolved via the offset from the
 *            resource. Can be {@code null}.
 * @param resource
 *            the resource for the document.
 * @param offset
 *            the offset of the selection.
 * 
 * @return {@code true} if the document highlight is available for the
 *         selected element, otherwise {@code false}.
 *
 */
protected boolean isDocumentHighlightAvailableFor(final EObject selectedElemnt, final XtextResource resource,
		final int offset) {

	if (selectedElemnt == null || !getSelectedElementFilter().apply(selectedElemnt)) {
		return false;
	}

	final EObject containedElement = offsetHelper.resolveContainedElementAt(resource, offset);
	// Special handling to avoid such cases when the selection is not
	// exactly on the desired element.
	if (selectedElemnt == containedElement) {
		final ITextRegion region = locationInFileProvider.getSignificantTextRegion(containedElement);
		return !isNullOrEmpty(region)
				// Region is comparable to a selection in an editor,
				// therefore the end position is exclusive.
				&& (region.contains(offset) || (region.getOffset() + region.getLength()) == offset);
	}

	return true;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
@Override
public ITreeAppendable trace(EObject object, EStructuralFeature feature, int indexInList) {
	ITextRegion textRegion = locationProvider.getFullTextRegion(object, feature, indexInList);
	if (!(textRegion instanceof ITextRegionWithLineInformation)) {
		if (log.isDebugEnabled())
			log.debug("location provider returned text region without line information. Synthesized dummy data.", new Exception());
		textRegion = new TextRegionWithLineInformation(textRegion.getOffset(), textRegion.getLength(), 0, 0);
	} 
	if (textRegion == ITextRegion.EMPTY_REGION) {
		return this;
	}
	ILocationData newData = createLocationData(traceURIConverter, object, (ITextRegionWithLineInformation) textRegion);
	return trace(Collections.singleton(newData), false);
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
public boolean doComputePrefix(ICompositeNode node, StringBuilder result) {
	List<ILeafNode> hiddens = Lists.newArrayListWithCapacity(2);
	for (INode child : node.getChildren()) {
		if (child instanceof ICompositeNode) {
			if (!doComputePrefix((ICompositeNode) child, result))
				return false;
		}
		else {
			ILeafNode leaf = (ILeafNode) child;
			ITextRegion leafRegion = leaf.getTextRegion();
			if (leafRegion.getOffset() > completionOffset)
				return false;
			if (leaf.isHidden()) {
				if (result.length() != 0)
					hiddens.add((ILeafNode) child);
			}
			else {
				Iterator<ILeafNode> iter = hiddens.iterator();
				while (iter.hasNext()) {
					result.append(iter.next().getText());
				}
				hiddens.clear();
				result.append(getNodeTextUpToCompletionOffset(leaf));
				if (leafRegion.getOffset() + leafRegion.getLength() > completionOffset)
					return false;
			}
		}
	}
	return true;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
@Override
public boolean existsConflict(String proposal, ContentAssistContext context) {
	// hidden node between lastCompleteNode and currentNode?
	INode lastCompleteNode = context.getLastCompleteNode();
	ITextRegion replaceRegion = context.getReplaceRegion();
	int nodeEnd = lastCompleteNode.getEndOffset();
	if (nodeEnd < replaceRegion.getOffset())
		return false;
	
	return existsConflict(lastCompleteNode, replaceRegion.getOffset(), proposal, context);
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
protected INode getLastCompleteNodeByOffset(INode node, int offset) {
	BidiTreeIterator<INode> iterator = node.getRootNode().getAsTreeIterable().iterator();
	INode result = node;
	ITextRegion candidateTextRegion = node.getTextRegion();
	while (iterator.hasNext()) {
		INode candidate = iterator.next();
		ITextRegion textRegion = candidate.getTextRegion();
		if (textRegion.getOffset() >= offset && !(textRegion.getOffset() == offset && textRegion.getLength() == 0)) {
			if (!candidateTextRegion.equals(textRegion) && candidate instanceof ILeafNode && textRegion.getLength() + textRegion.getOffset() >= offset) {
				break;
			}
		} 
		if ((candidate instanceof ILeafNode) &&
				   (candidate.getGrammarElement() == null ||
						   candidate.getGrammarElement() instanceof AbstractElement ||
						   candidate.getGrammarElement() instanceof ParserRule)) {
			if (textRegion.getLength() == 0) {
				if (candidateTextRegion.getOffset() + candidateTextRegion.getLength() < offset || candidateTextRegion.getLength() == 0 && candidateTextRegion.getOffset() <= offset) {
					result = candidate;
					candidateTextRegion = candidate.getTextRegion();
				}
			} else {
				result = candidate;
				candidateTextRegion = candidate.getTextRegion();
			}
		}
	}
	return result;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
public ITextRegion addTrailingSingleWhitespace(ITextRegion textRegion, String lineSeparator, XtextResource resource) {
	String text = resource.getParseResult().getRootNode().getText();
	String theFollowing = text.substring(textRegion.getOffset() + textRegion.getLength());
	if(!isEmpty(theFollowing)) { 
		if(theFollowing.startsWith(lineSeparator)) 
			return new TextRegion(textRegion.getOffset(), textRegion.getLength() + lineSeparator.length());
		else if(Character.isWhitespace(theFollowing.charAt(0)))
			return new TextRegion(textRegion.getOffset(), textRegion.getLength() + 1);
	}
	return textRegion;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
public EObject findActualSemanticObjectFor(final ICompositeNode rootNode, final ITextRegion textRegion) {
  ILeafNode leafNodeAtOffset = NodeModelUtils.findLeafNodeAtOffset(rootNode, textRegion.getOffset());
  EObject semanticElementOffset = leafNodeAtOffset.getSemanticElement();
  ICompositeNode actualOffsetNode = NodeModelUtils.findActualNodeFor(semanticElementOffset);
  int _offset = textRegion.getOffset();
  int _length = textRegion.getLength();
  final int endOffset = (_offset + _length);
  while (((actualOffsetNode.getParent() != null) && (actualOffsetNode.getTotalEndOffset() < endOffset))) {
    actualOffsetNode = actualOffsetNode.getParent();
  }
  final EObject actualSemanticObj = actualOffsetNode.getSemanticElement();
  return actualSemanticObj;
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
@Override
public ILocationInResource getBestAssociatedLocation(ITextRegion region) {
	AbstractTraceRegion right = findTraceRegionAtRightOffset(region.getOffset() + region.getLength());
	if (right != null && encloses(right, region.getOffset(), true)) {
		if (right.getMyOffset() + right.getMyLength() == region.getOffset() + region.getLength())
			return getMergedLocationInResource(right);
	}
	
	AbstractTraceRegion left = findTraceRegionAtLeftOffset(region.getOffset());
	return mergeRegions(left, right);
}
 

import org.eclipse.xtext.util.ITextRegion; //导入方法依赖的package包/类
public ReplaceRegion getTokenReplaceRegion(String changedText, ReplaceRegion replaceRegion) {
	int lengthDelta = replaceRegion.getText().length() - replaceRegion.getLength();
	ITextRegion tokenRegion = getTokenRegion(changedText, new TextRegion(replaceRegion.getOffset(), replaceRegion
			.getText().length()));
	if (tokenRegion.getOffset() == replaceRegion.getOffset()
			&& tokenRegion.getLength() == replaceRegion.getText().length())
		return replaceRegion;
	else 
		return new ReplaceRegion(tokenRegion.getOffset(), tokenRegion.getLength() - lengthDelta,
				changedText.substring(tokenRegion.getOffset(), tokenRegion.getOffset() + tokenRegion.getLength()));
}