Java StringLiteral类代码示例

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
@SuppressWarnings("unchecked")
	@Override
	public void createUnobservedInitStmt(CaptureLog log, int logRecNo) 
	{
		PostProcessor.notifyRecentlyProcessedLogRecNo(logRecNo);
		
		// NOTE: PLAIN INIT: has always one non-null param
		// TODO: use primitives
		final int    oid     = log.objectIds.get(logRecNo);
//		final String type    = log.oidClassNames.get(log.oidRecMapping.get(oid));
		final Object value   = log.params.get(logRecNo)[0];
		this.isXStreamNeeded = true;
		
		final VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
		// handling because there must always be a new instantiation statement for pseudo inits
		this.oidToVarMapping.remove(oid);
		vd.setName(ast.newSimpleName(this.createNewVarName(oid, log.oidClassNames.get(log.oidRecMapping.get(oid)), true)));
		
		final MethodInvocation methodInvocation = ast.newMethodInvocation();
		final Name name = ast.newSimpleName("XSTREAM");
		methodInvocation.setExpression(name);
		methodInvocation.setName(ast.newSimpleName("fromXML")); 
		
		final StringLiteral xmlParam = ast.newStringLiteral();
		xmlParam.setLiteralValue((String) value);
		methodInvocation.arguments().add(xmlParam);
		
//		final CastExpression castExpr = ast.newCastExpression();
//		castExpr.setType(this.createAstType(type, ast));
//		castExpr.setExpression(methodInvocation);
		
//		vd.setInitializer(castExpr);
		vd.setInitializer(methodInvocation);
		
		final VariableDeclarationStatement vs = ast.newVariableDeclarationStatement(vd);
		vs.setType(this.createAstType("Object", ast));
				
		methodBlock.statements().add(vs);
	}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void createUnobservedInitStmt(final int logRecNo, final Block methodBlock, final AST ast)
{
	// NOTE: PLAIN INIT: has always one non-null param
	// TODO: use primitives
	final int    oid     = this.log.objectIds.get(logRecNo);
	final String type    = this.log.oidClassNames.get(this.log.oidRecMapping.get(oid));
	final Object value   = this.log.params.get(logRecNo)[0];
	this.isXStreamNeeded = true;
	
	final VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
	// handling because there must always be a new instantiation statement for pseudo inits
	this.oidToVarMapping.remove(oid);
	vd.setName(ast.newSimpleName(this.createNewVarName(oid, type)));
	
	final MethodInvocation methodInvocation = ast.newMethodInvocation();
	final Name name = ast.newSimpleName("XSTREAM");
	methodInvocation.setExpression(name);
	methodInvocation.setName(ast.newSimpleName("fromXML")); 
	
	final StringLiteral xmlParam = ast.newStringLiteral();
	xmlParam.setLiteralValue((String) value);
	methodInvocation.arguments().add(xmlParam);
	
	final CastExpression castExpr = ast.newCastExpression();
	castExpr.setType(this.createAstType(type, ast));
	castExpr.setExpression(methodInvocation);
	
	vd.setInitializer(castExpr);
	
	final VariableDeclarationStatement vs = ast.newVariableDeclarationStatement(vd);
	vs.setType(this.createAstType(type, ast));
			
	methodBlock.statements().add(vs);
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
public static boolean isStringNodeInPatternElement(StringLiteral node) {
	ASTNode parent = node.getParent();
	StructuralPropertyDescriptor locationInParent = node.getLocationInParent();
	if (locationInParent.isChildProperty() && !locationInParent.isChildListProperty()) {
		return false;
	}
	if (parent instanceof MethodInvocation) {
		MethodInvocation parentMethodInvocation = (MethodInvocation) parent;
		if (isPatternPart(parentMethodInvocation)) {
			return true;
		} else if (isStringPattern(parentMethodInvocation)) {
			return true;
		} else {

		}
	} else {
		LOG.fine("not ClassInstanceCreation " + parent.getClass().getName() + " " + parent);
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
/**
 * @param cu
 * @return
 */
public static String findPathGeneratorInGraphWalkerAnnotation(ICompilationUnit cu) {
	CompilationUnit ast = parse(cu);
	Map<String, String> ret = new HashMap<String, String>();
	ast.accept(new ASTVisitor() {
		public boolean visit(MemberValuePair node) {
			String name = node.getName().getFullyQualifiedName();
			if ("value".equals(name) && node.getParent() != null && node.getParent() instanceof NormalAnnotation) {
				IAnnotationBinding annoBinding = ((NormalAnnotation) node.getParent()).resolveAnnotationBinding();
				String qname = annoBinding.getAnnotationType().getQualifiedName();
				if (GraphWalker.class.getName().equals(qname)) {
					StringLiteral sl = (StringLiteral) node.getValue();
					ret.put("ret", sl.getLiteralValue());
				}
			}
			return true;
		}
	});
	return ret.get("ret");
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
public RefinementString(Expression e) {
    if (knownConstants(e))
        return;

    if ( !(e instanceof StringLiteral)) {
        this.exists = false;
        this.length = 0;
        this.containsPunct = false;
        return;
    }

    String s = ((StringLiteral) e).getLiteralValue();
    this.exists = true;
    this.length = s.length();
    this.containsPunct = hasPunct(s);
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
private void setFieldAnnotation(ASTRewrite rewrite, FieldDeclaration fieldDeclaration, String annotation) {
	SingleMemberAnnotation newFieldAnnotation = fieldDeclaration.getAST().newSingleMemberAnnotation();
	newFieldAnnotation.setTypeName(rewrite.getAST().newSimpleName("Domain"));
	StringLiteral newStringLiteral = rewrite.getAST().newStringLiteral();
	newStringLiteral.setLiteralValue(annotation);
	newFieldAnnotation.setValue(newStringLiteral);
	ASTNode modifier = getModifier(fieldDeclaration.modifiers());
	if (modifier != null) {
		ListRewrite paramRewrite = rewrite.getListRewrite(fieldDeclaration, FieldDeclaration.MODIFIERS2_PROPERTY);
		paramRewrite.insertAfter(newFieldAnnotation, modifier, null);
	}
	else {
		ListRewrite fieldRewrite = rewrite.getListRewrite(fieldDeclaration, FieldDeclaration.MODIFIERS2_PROPERTY);
		fieldRewrite.insertFirst(newFieldAnnotation, null);
	}

}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
private void declareOtherDomains(ASTRewrite rewrite, ListRewrite listRewrite, TypeDeclaration typeDeclaration) {
	String qualifiedName = typeDeclaration.resolveBinding().getQualifiedName();
	
	OGraphFacade facade = RefinementAnalysis.getFacade();
	RefinementModel refinementModel = facade.getRefinementModel();
	List<IOtherRefinement> otherRefinements = refinementModel.getOtherRefinements();
	for(IOtherRefinement otherRefinement : otherRefinements ) {
		if (otherRefinement instanceof CreateDomain ) {
			CreateDomain createDomain = (CreateDomain)otherRefinement;
			String fullyQualifiedName = createDomain.getSrcIObject().getC().getFullyQualifiedName();
			if (fullyQualifiedName.equals(qualifiedName)) {
				 StringLiteral newStringLiteralPARAM = rewrite.getAST().newStringLiteral();
				 newStringLiteralPARAM.setLiteralValue(createDomain.getDstDomain());
				 listRewrite.insertLast(newStringLiteralPARAM, null);
			}
		}
	}
			
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
private SingleMemberAnnotation getTypeAnnotationDomainAssumes(ASTRewrite rewrite, TypeDeclaration typeDeclaration, String annotation, String domainName) {
   ArrayInitializer initializer = rewrite.getAST().newArrayInitializer();

if (domainName != null) {
	ListRewrite listRewrite = rewrite.getListRewrite(initializer, ArrayInitializer.EXPRESSIONS_PROPERTY);
	
	StringLiteral newStringLiteral = rewrite.getAST().newStringLiteral();
	newStringLiteral.setLiteralValue(domainName);
	listRewrite.insertFirst(newStringLiteral, null);
	
	declareOtherDomains(rewrite, listRewrite, typeDeclaration);
}

SingleMemberAnnotation newParamAnnotation = typeDeclaration.getAST().newSingleMemberAnnotation();
newParamAnnotation.setTypeName(rewrite.getAST().newSimpleName(annotation));
newParamAnnotation.setValue(initializer);
   return newParamAnnotation;
  }
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
private SingleMemberAnnotation getTypeAnnotationParams(ASTRewrite rewrite, TypeDeclaration typeDeclaration,
          String annotation) {
   ArrayInitializer initializer = rewrite.getAST().newArrayInitializer();

if (!typeDeclaration.resolveBinding().getQualifiedName().equals(Config.MAINCLASS)) {
	StringLiteral newStringLiteral = rewrite.getAST().newStringLiteral();
	newStringLiteral.setLiteralValue("p");

	ListRewrite listRewrite = rewrite.getListRewrite(initializer, ArrayInitializer.EXPRESSIONS_PROPERTY);
	listRewrite.insertFirst(newStringLiteral, null);
}
SingleMemberAnnotation newParamAnnotation = typeDeclaration.getAST().newSingleMemberAnnotation();
newParamAnnotation.setTypeName(rewrite.getAST().newSimpleName(annotation));
newParamAnnotation.setValue(initializer);
   return newParamAnnotation;
  }
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
private FieldDeclaration createLiceseInLineField(AST ast) {
	VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
	vdf.setName(ast.newSimpleName("COPYRIGHT"));
	StringLiteral sl = ast.newStringLiteral();
	sl.setLiteralValue(license_inline);
	vdf.setInitializer(sl);
	FieldDeclaration fd = ast.newFieldDeclaration(vdf);
	fd.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL));
	fd.setType(ast.newSimpleType(ast.newSimpleName("String")));
	
	return fd;
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
private static boolean addSuppressArgument(
    ASTRewrite rewrite, Expression value, StringLiteral newStringLiteral) {
  if (value instanceof ArrayInitializer) {
    ListRewrite listRewrite =
        rewrite.getListRewrite(value, ArrayInitializer.EXPRESSIONS_PROPERTY);
    listRewrite.insertLast(newStringLiteral, null);
  } else if (value instanceof StringLiteral) {
    ArrayInitializer newArr = rewrite.getAST().newArrayInitializer();
    newArr.expressions().add(rewrite.createMoveTarget(value));
    newArr.expressions().add(newStringLiteral);
    rewrite.replace(value, newArr, null);
  } else {
    return false;
  }
  return true;
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static boolean containsAnnotationValue(Expression annotationValue,
    String value) {
  if (annotationValue.getNodeType() == ASTNode.STRING_LITERAL) {
    String valueString = ((StringLiteral) annotationValue).getLiteralValue();
    return value.equals(valueString);
  } else if (annotationValue.getNodeType() == ASTNode.ARRAY_INITIALIZER) {
    // If the annotation value is actually an array, check each element
    List<Expression> warningTypes = ((ArrayInitializer) annotationValue).expressions();
    for (Expression warningType : warningTypes) {
      if (containsAnnotationValue(warningType, value)) {
        return true;
      }
    }
  }

  return false;
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void validateUiHandlerFieldExistenceInUiXml(
    MethodDeclaration uiHandlerDecl) {
  Annotation annotation = JavaASTUtils.findAnnotation(uiHandlerDecl,
      UiBinderConstants.UI_HANDLER_TYPE_NAME);

  if (annotation instanceof SingleMemberAnnotation) {
    SingleMemberAnnotation uiHandlerAnnotation = (SingleMemberAnnotation) annotation;
    Expression exp = uiHandlerAnnotation.getValue();
    if (exp instanceof StringLiteral) {
      validateFieldExistenceInUiXml(
          (TypeDeclaration) uiHandlerDecl.getParent(), exp,
          ((StringLiteral) exp).getLiteralValue());
    } else if (exp instanceof ArrayInitializer) {
      for (Expression element : (List<Expression>) ((ArrayInitializer) exp).expressions()) {
        if (element instanceof StringLiteral) {
          validateFieldExistenceInUiXml(
              (TypeDeclaration) uiHandlerDecl.getParent(), element,
              ((StringLiteral) element).getLiteralValue());
        }
      }
    }
  }
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
private void validateSourceAnnotationValue(StringLiteral literalNode) throws JavaModelException {
  String value = literalNode.getLiteralValue();

  // Interpret the literal path as an absolute path, and then as a path
  // relative to the containing package (indexing both).
  IPath literalPath = new Path(value);
  result.addPossibleResourcePath(literalPath);
  IPath fullResourcePathIfPackageRelative = getPackagePath(literalNode).append(literalPath);
  result.addPossibleResourcePath(fullResourcePathIfPackageRelative);

  // If the @Source path was absolute and we found it, great
  if (ClasspathResourceUtilities.isResourceOnClasspath(javaProject, literalPath)) {
    return;
  }

  if (!ClasspathResourceUtilities.isResourceOnClasspath(javaProject, fullResourcePathIfPackageRelative)) {
    // Didn't work as a relative path either, so now it's an error
    IPath expectedResourcePath = computeMissingResourceExpectedPath(literalPath, fullResourcePathIfPackageRelative);
    ClientBundleProblem problem = ClientBundleProblem.createMissingResourceFile(literalNode,
        literalPath.lastSegment(), expectedResourcePath.removeLastSegments(1));
    result.addProblem(problem);
  }
}
 

import org.eclipse.jdt.core.dom.StringLiteral; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void validateSourceAnnotationValues(Annotation annotation) throws JavaModelException {
  Expression exp = JavaASTUtils.getAnnotationValue(annotation);
  if (exp == null) {
    return;
  }

  // There will usually just be one string value
  if (exp instanceof StringLiteral) {
    validateSourceAnnotationValue((StringLiteral) exp);
  }

  // But there could be multiple values; if so, check each one.
  if (exp instanceof ArrayInitializer) {
    ArrayInitializer array = (ArrayInitializer) exp;

    for (Expression item : (List<Expression>) array.expressions()) {
      if (item instanceof StringLiteral) {
        validateSourceAnnotationValue((StringLiteral) item);
      }
    }
  }
}