public Query toQuery(Expression<?> expr, QueryMetadata metadata) {
if (expr instanceof Operation<?>) {
return toQuery((Operation<?>) expr, metadata);
} else {
return toQuery(ExpressionUtils.extract(expr), metadata);
}
}
/**
* Performs a comparison on the two number models set previously. One is subtracted from the
* other, then compared against zero. If either of the values is not a number, an exception is
* thrown.
*
* @param modelRoot the template model that will be evaluated by the expression
* @return A {@link freemarker.template.FastBoolean} of the expression
* @throws TemplateException the expression could not be evaluated for some reason
*/
public TemplateModel getAsTemplateModel(TemplateWriteableHashModel modelRoot)
throws TemplateException {
TemplateModel leftModel = left.getAsTemplateModel(modelRoot);
TemplateModel rightModel = right.getAsTemplateModel(modelRoot);
return FastBoolean.getInstance(ExpressionUtils.compareNumbers(leftModel, rightModel) <= 0);
}
private static boolean isIndexedListLoopStatement(PsiForStatement forStatement, boolean ignoreUntypedCollections) {
final PsiStatement initialization = forStatement.getInitialization();
if (!(initialization instanceof PsiDeclarationStatement)) {
return false;
}
final PsiDeclarationStatement declaration = (PsiDeclarationStatement)initialization;
final PsiElement[] declaredElements = declaration.getDeclaredElements();
final PsiElement secondDeclaredElement;
if (declaredElements.length == 1) {
secondDeclaredElement = null;
}
else if (declaredElements.length == 2) {
secondDeclaredElement = declaredElements[1];
}
else {
return false;
}
final PsiElement declaredElement = declaredElements[0];
if (!(declaredElement instanceof PsiVariable)) {
return false;
}
final PsiVariable indexVariable = (PsiVariable)declaredElement;
final PsiExpression initialValue = indexVariable.getInitializer();
if (initialValue == null) {
return false;
}
final Object constant = ExpressionUtils.computeConstantExpression(initialValue);
if (!(constant instanceof Number)) {
return false;
}
final Number number = (Number)constant;
if (number.intValue() != 0) {
return false;
}
final PsiExpression condition = forStatement.getCondition();
final Holder collectionHolder = getCollectionFromSizeComparison(condition, indexVariable, secondDeclaredElement);
if (collectionHolder == null) {
return false;
}
final PsiStatement update = forStatement.getUpdate();
if (!VariableAccessUtils.variableIsIncremented(indexVariable, update)) {
return false;
}
final PsiStatement body = forStatement.getBody();
if (!isIndexVariableOnlyUsedAsListIndex(collectionHolder, indexVariable, body)) {
return false;
}
if (collectionHolder != Holder.DUMMY) {
final PsiVariable collection = collectionHolder.getVariable();
final PsiClassType collectionType = (PsiClassType)collection.getType();
final PsiType[] parameters = collectionType.getParameters();
if (ignoreUntypedCollections && parameters.length == 0) {
return false;
}
return !VariableAccessUtils.variableIsAssigned(collection, body);
}
return true;
}
static boolean isArrayLoopStatement(PsiForStatement forStatement) {
final PsiStatement initialization = forStatement.getInitialization();
if (!(initialization instanceof PsiDeclarationStatement)) {
return false;
}
final PsiDeclarationStatement declaration = (PsiDeclarationStatement)initialization;
final PsiElement[] declaredElements = declaration.getDeclaredElements();
final PsiElement secondDeclaredElement;
if (declaredElements.length == 1) {
secondDeclaredElement = null;
}
else if (declaredElements.length == 2) {
secondDeclaredElement = declaredElements[1];
}
else {
return false;
}
final PsiElement declaredElement = declaredElements[0];
if (!(declaredElement instanceof PsiVariable)) {
return false;
}
final PsiVariable indexVariable = (PsiVariable)declaredElement;
final PsiExpression initialValue = indexVariable.getInitializer();
if (initialValue == null) {
return false;
}
final Object constant =
ExpressionUtils.computeConstantExpression(initialValue);
if (!(constant instanceof Integer)) {
return false;
}
final Integer integer = (Integer)constant;
if (integer.intValue() != 0) {
return false;
}
final PsiStatement update = forStatement.getUpdate();
if (!VariableAccessUtils.variableIsIncremented(indexVariable, update)) {
return false;
}
final PsiExpression condition = forStatement.getCondition();
final PsiReferenceExpression arrayReference = getVariableReferenceFromCondition(condition, indexVariable, secondDeclaredElement);
if (arrayReference == null) {
return false;
}
final PsiElement element = arrayReference.resolve();
if (!(element instanceof PsiVariable)) {
return false;
}
final PsiVariable arrayVariable = (PsiVariable)element;
final PsiStatement body = forStatement.getBody();
return body == null ||
isIndexVariableOnlyUsedAsIndex(arrayVariable, indexVariable, body) &&
!VariableAccessUtils.variableIsAssigned(arrayVariable, body) &&
!VariableAccessUtils.arrayContentsAreAssigned(arrayVariable, body);
}
@Test
public void roundtrip() throws Exception {
Path<?> path = ExpressionUtils.path(Object.class, "entity");
SimplePath<?> path2 = Expressions.path(Object.class, "entity");
assertEquals(path, serialize(path));
assertEquals(path2, serialize(path2));
assertEquals(path2.isNull(), serialize(path2.isNull()));
assertEquals(path.hashCode(), serialize(path).hashCode());
assertEquals(path2.hashCode(), serialize(path2).hashCode());
assertEquals(path2.isNull().hashCode(), serialize(path2.isNull()).hashCode());
}
@Test
public void Ne() {
assertEquals("str != str2", ExpressionUtils.ne(str, str2).toString());
}
@Test
public void NeConst() {
assertEquals("str != X", ExpressionUtils.neConst(str, "X").toString());
}
@Test
public void IsNotNull() {
assertEquals("str is not null", ExpressionUtils.isNotNull(str).toString());
}
@Test
public void In() {
assertEquals(
"str in [a, b, c]", ExpressionUtils.in(str, Arrays.asList("a", "b", "c")).toString());
}
@Test
public void Eq() {
assertEquals("str = str2", ExpressionUtils.eq(str, str2).toString());
}
@Test
public void EqConst() {
assertEquals("str = X", ExpressionUtils.eqConst(str, "X").toString());
}
@Test
public void Count() {
assertEquals("count(str)", ExpressionUtils.count(str).toString());
}
private String like(Expression<String> expr) {
return ExpressionUtils.regexToLike(expr).toString();
}
private String regex(Expression<String> expr) {
return ExpressionUtils.likeToRegex(expr).toString();
}
