Java BooleanLiteralExpr类代码示例

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
private void renderManyToOneAnnotations(MethodDeclaration getter) {
	/*
	 * We need JoinColumn and ManyToOne
	 */
	NormalAnnotationExpr m2o = createOrFindAnnotation(getter, "javax.persistence.ManyToOne");
	MemberValuePair fetch = findAnnotationPair(m2o, "fetch");
	if(null == fetch) {
		importIf("javax.persistence.FetchType");
		m2o.addPair("fetch", "FetchType.LAZY");
	}

	MemberValuePair p = findAnnotationPair(m2o, "optional");
	if(null == p) {
		m2o.addPair("optional", Boolean.toString(m_column.isNullable()));
	} else {
		p.setValue(new BooleanLiteralExpr(m_column.isNullable()));
	}

	NormalAnnotationExpr na = createOrFindAnnotation(getter, "javax.persistence.JoinColumn");
	p = findAnnotationPair(na, "name");
	if(null == p) {
		na.addPair("name", "\"" + m_column.getName() + "\"");
	} else {
		p.setValue(new StringLiteralExpr(m_column.getName()));
	}
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
protected IsType extractType(Expression val) {
  if (val instanceof LiteralExpr) {
    if (val instanceof IntegerLiteralExpr) {
      return new ImmutableType("", "int");
    } else if (val instanceof LongLiteralExpr) {
      return new ImmutableType("", "long");
    } else if (val instanceof DoubleLiteralExpr) {
      return new ImmutableType("", "double");
    } else if (val instanceof CharLiteralExpr) {
      return new ImmutableType("", "char");
    } else if (val instanceof BooleanLiteralExpr) {
      return new ImmutableType("", "boolean");
    } else if (val instanceof StringLiteralExpr) {
      return new ImmutableType("java.lang", "String");
    }
    // TODO: arrays, ui containers, annotated elements, constructors, etc...
  }
  return new ImmutableType("java.lang", "Object");
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override
public JCTree visit(final BooleanLiteralExpr n, final Object arg) {
    //ARG0: Object value
    // The type if literals are tested with instance of
    // inside Literal
    Boolean arg0 = new Boolean(n.getValue());

    return new AJCLiteral(make.Literal(arg0), ((n.getComment() != null) ? n.getComment().getContent() : null));
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override public Boolean visit(final BooleanLiteralExpr n1, final Node arg) {
	final BooleanLiteralExpr n2 = (BooleanLiteralExpr) arg;

	if (n1.getValue() != n2.getValue()) {
		return false;
	}

	return true;
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override
public Node visit(BooleanLiteralExpr _n, Object _arg) {
	Comment comment = cloneNodes(_n.getComment(), _arg);

	BooleanLiteralExpr r = new BooleanLiteralExpr(
			_n.getRange(),
			_n.getValue()
	);
	r.setComment(comment);
	return r;
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override
public void visit(BooleanLiteralExpr n, Script arg) {
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override
public void visit(final BooleanLiteralExpr n, final Object arg) {
    printer.printLn("BooleanLiteralExpr");
    printJavaComment(n.getComment(), arg);
    printer.print(String.valueOf(n.getValue()));
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override public Node visit(final BooleanLiteralExpr n, final A arg) {
	return n;
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
public PrimitiveDefaultValue(PrimitiveType type) {
  super("", type.getType().name());
  this.type = type;
  switch (type.getType()) {
    case Boolean:
      this.viewValue = "CHECKBOX";
      this.domainValue = createDomainValueExpression(
          new BooleanLiteralExpr(true),
          new BooleanLiteralExpr(false)
      );
      break;
    case Int:
      this.viewValue = "TEXT";
      this.domainValue = createDomainValueExpression(
          new IntegerLiteralExpr("Integer.MIN_VALUE"),
          new IntegerLiteralExpr("Integer.MAX_VALUE")
      );
      break;
    case Float:
      this.viewValue = "TEXT";
      this.domainValue = createDomainValueExpression(
          new DoubleLiteralExpr("-Float.MAX_VALUE"),
          new DoubleLiteralExpr("Float.MAX_VALUE")
      );
      break;
    case Double:
      this.viewValue = "TEXT";
      this.domainValue = createDomainValueExpression(
          new DoubleLiteralExpr("-Double.MAX_VALUE"),
          new DoubleLiteralExpr("Double.MAX_VALUE")
      );
      break;
    case Char:
      this.viewValue = "TEXT";
      this.domainValue = createDomainValueExpression(
          new CharLiteralExpr(Character.toString(Character.MIN_VALUE)),
          new CharLiteralExpr(Character.toString(Character.MAX_VALUE))
      );
      break;
    default:
      throw new UnsupportedOperationException("Type " + type.getType() + " is not supported.");
  }
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override public void visit(final BooleanLiteralExpr n, final A arg) {
	visitComment(n.getComment(), arg);
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override public Node visit(final BooleanLiteralExpr n, final A arg) {
	visitComment(n, arg);
	return n;
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void visit(@Nullable MethodDeclaration methodDec,
		@Nullable XmlTestCase testCase) {
	if (null == methodDec || null == testCase)
		throw GlobalUtils
				.createNotInitializedException("classorinterfacedeclaration");
	else {
		if (methodDec.getName().equals("runTest")) {
			List<Expression> groups = new ArrayList<Expression>();
			groups.add(new StringLiteralExpr(testCase
					.getTestCaseFilePathName()));

			List<MemberValuePair> testAnnoParams = new ArrayList<MemberValuePair>();
			testAnnoParams.add(new MemberValuePair("groups",
					new ArrayInitializerExpr(groups)));
			testAnnoParams.add(new MemberValuePair("dataProvider",
					new StringLiteralExpr("dp")));

			List<CaseDependency> caseDeps = testCase
					.getDependOnTestCases();

			if (null != caseDeps) {
				List<Expression> dependsOnGroups = new ArrayList<Expression>();
				boolean alwaysRun = true;// NOPMD
				for (CaseDependency cDep : caseDeps) {
					dependsOnGroups.add(new StringLiteralExpr(cDep
							.getDependOnTestCaseID()));
					if (cDep.getDependencyType() == EnumCaseDependencyType.TESTCASESTEPDEPENDENCY) {
						alwaysRun = false;// NOPMD
					}
				}
				testAnnoParams.add(new MemberValuePair(
						"dependsOnGroups", new ArrayInitializerExpr(
								dependsOnGroups)));
				testAnnoParams.add(new MemberValuePair("alwaysRun",
						new BooleanLiteralExpr(alwaysRun)));
			}
			NormalAnnotationExpr testAnno = new NormalAnnotationExpr(
					ASTHelper.createNameExpr("Test"), testAnnoParams);

			methodDec.getAnnotations().add(testAnno);
		}
	}
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override
public Object visit(final BooleanLiteralExpr n, final Context arg) {
  return n.getValue();
}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override
public void visit(final BooleanLiteralExpr n, final Context ctx) {
  visitNode(n, ctx);
  super.visit(n, ctx);

}
 

import com.github.javaparser.ast.expr.BooleanLiteralExpr; //导入依赖的package包/类
@Override
public Type visit(final BooleanLiteralExpr n, final Context arg) {
  return boolean.class;
}