Java TextRegion类代码示例

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
public void update(int offset, int replacedTextLength, String newText) {
	if (!isLoaded()) {
		throw new IllegalStateException("You can't update an unloaded resource.");
	}
	try {
		isUpdating = true;
		IParseResult oldParseResult = parseResult;
		ReplaceRegion replaceRegion = new ReplaceRegion(new TextRegion(offset, replacedTextLength), newText);
		IParseResult newParseResult;
		ParserRule oldEntryPoint = NodeModelUtils.getEntryParserRule(oldParseResult.getRootNode());
		if (entryPoint == null || entryPoint == oldEntryPoint) {
			newParseResult = parser.reparse(oldParseResult, replaceRegion);
		} else {
			StringBuilder builder = new StringBuilder(oldParseResult.getRootNode().getText());
			replaceRegion.applyTo(builder);
			newParseResult = parser.parse(entryPoint, new StringReader(builder.toString()));
		}
		updateInternalState(oldParseResult, newParseResult);
	} finally {
		isUpdating = false;
	}
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
@Test 
	public void testTokenRegionContainsRegion() throws Exception {
		String modelAsString = "a1 / /* comment */ b2";
		List<CommonToken> tokens = getTokens(modelAsString);
		for(int length=0; length < modelAsString.length(); ++length) {
			for(int offset = 0; offset + length < modelAsString.length(); ++offset) {
				ITextRegion tokenRegion = tokenRegionProvider.getTokenRegion(modelAsString, new TextRegion(offset, length));
//				System.out.println(offset + ":" + length + " -> " + tokenRegion);
				CommonToken firstToken = findTokenStartingAt(tokenRegion.getOffset(), tokens);
				assertTrue(firstToken.getStartIndex() <= offset);
				if(tokenRegion.getLength() != 0) {
					CommonToken lastToken = findTokenStopingAt(tokenRegion.getOffset() + tokenRegion.getLength()-1, tokens);
					assertTrue(lastToken.getStopIndex() >= offset + length -1);
				}
			}
		}
	}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
@Test public void testGetCrossReferenceNode() throws Exception {
	String firstPart = "foo Foo1=X.Y foo Foo2=X.Y zonk bar Bar1 Foo1=X.Y";
	String modelAsString = firstPart+",Foo2=X.Y";
	XtextResource resource = getResourceFromString(modelAsString);
	
	INode node = eObjectAtOffsetHelper.getCrossReferenceNode(resource, new TextRegion(firstPart.length(), 0));
	assertEquals(firstPart.length()-8, node.getOffset());
	assertEquals(8, node.getLength());
	
	assertNull(eObjectAtOffsetHelper.getCrossReferenceNode(resource, new TextRegion(firstPart.length(), 1)));
	
	node = eObjectAtOffsetHelper.getCrossReferenceNode(resource, new TextRegion(firstPart.length()+1, 0));
	assertEquals(firstPart.length()+1, node.getOffset());
	assertEquals(8, node.getLength());
	
	node = eObjectAtOffsetHelper.getCrossReferenceNode(resource, new TextRegion(firstPart.length()+1, 5));
	assertEquals(firstPart.length()+1, node.getOffset());
	assertEquals(8, node.getLength());
	
	node = eObjectAtOffsetHelper.getCrossReferenceNode(resource, new TextRegion(firstPart.length()+1, 8));
	assertEquals(firstPart.length()+1, node.getOffset());
	assertEquals(8, node.getLength());
	
	assertNull(eObjectAtOffsetHelper.getCrossReferenceNode(resource, new TextRegion(firstPart.length()+1, 9)));
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
@Override
protected String getStringRepresentation(final Object object) {
  if ((object instanceof AbstractIdeTemplateProposalProvider.Variable)) {
    final String varName = ((AbstractIdeTemplateProposalProvider.Variable)object).name;
    int _offset = this.context.getReplaceRegion().getOffset();
    int _currentOffset = this.getCurrentOffset();
    final int offset = (_offset + _currentOffset);
    int _length = varName.length();
    TextRegion _textRegion = new TextRegion(offset, _length);
    this.entry.getEditPositions().add(_textRegion);
    return varName;
  } else {
    if ((object instanceof AbstractIdeTemplateProposalProvider.Cursor)) {
      int _offset_1 = this.context.getReplaceRegion().getOffset();
      int _currentOffset_1 = this.getCurrentOffset();
      final int offset_1 = (_offset_1 + _currentOffset_1);
      this.entry.setEscapePosition(Integer.valueOf(offset_1));
      return null;
    } else {
      return object.toString();
    }
  }
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
@Override
public void createHyperlinksByOffset(final XtextResource resource, final int offset, final IHyperlinkAcceptor acceptor) {
  IEditorPart activeEditor = workbench.getActiveWorkbenchWindow().getActivePage().getActiveEditor();
  if (activeEditor.getEditorInput() instanceof XtextReadonlyEditorInput) {
    INode crossRefNode = eObjectAtOffsetHelper.getCrossReferenceNode(resource, new TextRegion(offset, 0));
    if (crossRefNode == null) {
      return;
    }
    EObject crossLinkedEObject = eObjectAtOffsetHelper.getCrossReferencedElement(crossRefNode);
    if (crossLinkedEObject != null && crossLinkedEObject.eClass().getEPackage() != CheckPackage.eINSTANCE) {
      return;
    }
    // if EPackage of referenced object is CheckPackage, try to provide hyperlinks: works for included catalogs
  }
  super.createHyperlinksByOffset(resource, offset, acceptor);
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
protected ITextRegion getTextRegion(EObject eObject) {
	if (eObject == null)
		return null;
	IParseResult parseResult = ((XtextResource)eObject.eResource()).getParseResult();
	if (parseResult == null)
		return null;
	ICompositeNode rootNode = parseResult.getRootNode();
	Map<ILeafNode, EObject> comments = commentAssociater.associateCommentsWithSemanticEObjects(eObject, singleton(rootNode));
	final ITextRegion result = locationProvider.getFullTextRegion(eObject);
	int start = result.getOffset();
	int end = result.getOffset() + result.getLength();
	for (Entry<ILeafNode, EObject> entry : comments.entrySet()) {
		if (entry.getValue() == eObject) {
			ILeafNode node = entry.getKey();
			if (node.getTotalOffset() < start) {
				start = node.getTotalOffset();
			}
			if (node.getTotalEndOffset() > end) {
				end = node.getTotalEndOffset();
			}
		}
	}
	return new TextRegion(start, end-start);
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
@Override
protected void computeCommentFolding(final IXtextDocument xtextDocument,
		final IFoldingRegionAcceptor<ITextRegion> foldingRegionAcceptor, final ITypedRegion typedRegion,
		final boolean initiallyFolded) throws BadLocationException {
	final int offset = typedRegion.getOffset();
	final int length = typedRegion.getLength();
	final Matcher matcher = getTextPatternInComment().matcher(xtextDocument.get(offset, length));
	((GamaFoldingRegionAcceptor) foldingRegionAcceptor).type = typedRegion.getType();
	if (matcher.find()) {
		final TextRegion significant = new TextRegion(offset + matcher.start(), 0);
		((IFoldingRegionAcceptorExtension<ITextRegion>) foldingRegionAcceptor).accept(offset, length,
				initiallyFolded, significant);
	} else {
		((IFoldingRegionAcceptorExtension<ITextRegion>) foldingRegionAcceptor).accept(offset, length,
				initiallyFolded);
	}
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
protected void addSectionToAppend(IAcceptor<ReplaceRegion> acceptor) {
	StringBuilder importDeclarationsToAppend = getImportDeclarationsToAppend();
	if (importDeclarationsToAppend.length() == 0)
		return;
	importRegion = regionUtil.addLeadingWhitespace(importRegion, resource);
	importRegion = regionUtil.addTrailingSingleWhitespace(importRegion, lineSeparator, resource);
	int insertOffset = importRegion.getOffset() + importRegion.getLength();
	if (insertOffset != 0 && originalImportDeclarations.isEmpty())
		importDeclarationsToAppend.insert(0, lineSeparator);
	importDeclarationsToAppend.append(lineSeparator);
	int insertLength = -importRegion.getLength();
	insertLength += regionUtil.addTrailingWhitespace(importRegion, resource).getLength();
	ReplaceRegion appendDeclarations = new ReplaceRegion(new TextRegion(insertOffset, insertLength), importDeclarationsToAppend.toString());
	acceptor.accept(appendDeclarations);
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
public ITextRegion computeRegion(XtextResource resource) {
	XImportSection xImportSection = config.getImportSection(resource);
	// try to obtain the region from the text if it is not a synthetic region.
	if (xImportSection != null && xImportSection.eResource() != null) {
		INode node = NodeModelUtils.findActualNodeFor(xImportSection);
		if(node == null) 
			LOG.error("Cannot detect node for original import section");
		else 
			return node.getTextRegion();
	} 
	return new TextRegion(config.getImportSectionOffset(resource), 0);
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
public ITextRegion addLeadingWhitespace(ITextRegion textRegion, XtextResource resource) {
	String text = resource.getParseResult().getRootNode().getText();
	int offset = textRegion.getOffset();
	int length = textRegion.getLength();
	while(offset > 0 && Character.isWhitespace(text.charAt(offset-1)) ){
		--offset;
		++length;
	}
	return new TextRegion(offset, length);
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
public ITextRegion addTrailingWhitespace(ITextRegion textRegion, XtextResource resource) {
	String text = resource.getParseResult().getRootNode().getText();
	int offset = textRegion.getOffset();
	int length = textRegion.getLength();
	while(offset + length < text.length() && Character.isWhitespace(text.charAt(offset+length))) {
		++length;
	}
	return new TextRegion(offset, length);
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的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.TextRegion; //导入依赖的package包/类
private void addJavaDocReferences(final INode documentationNode, final ITextRegion selectedRegion, final ImportsAcceptor acceptor) {
  List<ReplaceRegion> _computeTypeRefRegions = this.javaDocTypeReferenceProvider.computeTypeRefRegions(documentationNode);
  for (final ReplaceRegion docTypeReference : _computeTypeRefRegions) {
    {
      int _offset = docTypeReference.getOffset();
      int _length = docTypeReference.getLength();
      final TextRegion referenceRange = new TextRegion(_offset, _length);
      boolean _contains = selectedRegion.contains(referenceRange);
      if (_contains) {
        String docTypeText = docTypeReference.getText();
        final EObject element = NodeModelUtils.findActualSemanticObjectFor(documentationNode);
        IScope scope = this.scopeProvider.getScope(element, 
          TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE);
        IEObjectDescription singleElement = scope.getSingleElement(QualifiedName.create(docTypeText));
        JvmType referencedType = null;
        if ((singleElement != null)) {
          EObject _eObjectOrProxy = singleElement.getEObjectOrProxy();
          referencedType = ((JvmType) _eObjectOrProxy);
        }
        if (((referencedType instanceof JvmDeclaredType) && (!referencedType.eIsProxy()))) {
          JvmDeclaredType casted = ((JvmDeclaredType) referencedType);
          boolean _equals = casted.getQualifiedName().equals(docTypeText);
          boolean _not = (!_equals);
          if (_not) {
            acceptor.acceptTypeImport(casted);
          }
        }
      }
    }
  }
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
protected void assertTrace(final String javaCodeWithMarker, String xbaseCodeWithMarker) throws Exception {
	xbaseCodeWithMarker = " " + xbaseCodeWithMarker + " ";
	Matcher xbaseMatcher = p.matcher(xbaseCodeWithMarker);
	assertTrue(xbaseMatcher.matches());
	String xbaseGroup1 = xbaseMatcher.group(1);
	String xbaseGroup2 = xbaseMatcher.group(2);
	String xbaseGroup3 = xbaseMatcher.group(3);
	String actualCode = xbaseGroup1 + xbaseGroup2 + xbaseGroup3; 
	XExpression model = expression(actualCode,true);
	TreeAppendable appendable = new TreeAppendable(new ImportManager(true), converter, locationProvider, jvmModelAssociations, model, "  ", "\n");
	XbaseCompiler compiler = get(XbaseCompiler.class);
	LightweightTypeReference returnType = typeResolver.resolveTypes(model).getReturnType(model);
	if (returnType == null) {
		throw new IllegalStateException();
	}
	compiler.compile(model, appendable, returnType);
	String compiledJavaCode = appendable.getContent();
	Matcher javaMatcher = p.matcher(javaCodeWithMarker);
	assertTrue(javaMatcher.matches());
	String javaGroup1 = javaMatcher.group(1);
	String javaGroup2 = javaMatcher.group(2);
	String javaGroup3 = javaMatcher.group(3);
	String actualExpectation = javaGroup1 + javaGroup2 + javaGroup3;
	assertEquals(actualExpectation, compiledJavaCode);
	ITrace trace = new SimpleTrace(appendable.getTraceRegion());
	ILocationInResource location = trace.getBestAssociatedLocation(new TextRegion(javaGroup1.length(), javaGroup2.length()));
	if (location == null) {
		throw new IllegalStateException("location may not be null");
	}
	assertEquals(new TextRegion(xbaseGroup1.length(), xbaseGroup2.length()), location.getTextRegion());
}
 

import org.eclipse.xtext.util.TextRegion; //导入依赖的package包/类
/**
 * @since 2.5
 */
@Override
public ITextRegion getTextRegion() {
	int offset = getOffset();
	int length = getEndOffset() - offset;
	return new TextRegion(offset, length);
}