private static ASTStringLiteral getLiteral(String fieldValue) { ASTStringLiteral literal = new ASTStringLiteral(ParserTreeConstants.JJTSTRINGLITERAL); literal.image = fieldValue; return literal; }
/** {@inheritDoc} */ public Object visit(ASTStringLiteral node, Object data) { if (data != null) { return getAttribute(data, node.getLiteral(), node); } return node.image; }
@Override public Object visit(ASTStringLiteral node, Object data) { node.childrenAccept(this, data); return data; }
copy = new ASTOrNode(ParserTreeConstants.JJTORNODE); } else if (ASTStringLiteral.class.isAssignableFrom(clz)) { copy = new ASTStringLiteral(ParserTreeConstants.JJTSTRINGLITERAL); JexlNodes.setLiteral((ASTStringLiteral) copy, ((ASTStringLiteral) original).getLiteral()); } else if (ASTTrueNode.class.isAssignableFrom(clz)) { copy = new ASTTrueNode(ParserTreeConstants.JJTTRUENODE);
/** * Create an assignment node * * @param name * @param value * @return the assignment node */ public static ASTAssignment createAssignment(String name, String value) { ASTAssignment assignNode = new ASTAssignment(ParserTreeConstants.JJTASSIGNMENT); ASTReference refNode2 = new ASTReference(ParserTreeConstants.JJTREFERENCE); refNode2.jjtSetParent(assignNode); assignNode.jjtAddChild(refNode2, 0); ASTIdentifier idNode = new ASTIdentifier(ParserTreeConstants.JJTIDENTIFIER); idNode.image = name; idNode.jjtSetParent(refNode2); refNode2.jjtAddChild(idNode, 0); ASTStringLiteral literalNode = new ASTStringLiteral(ParserTreeConstants.JJTSTRINGLITERAL); literalNode.jjtSetParent(assignNode); literalNode.image = value; assignNode.jjtAddChild(literalNode, 1); return assignNode; } }
@Override public Object visit(ASTStringLiteral node, Object data) { // strings are always wrapped in a reference node, so the op is the gparent JexlNode op = node.jjtGetParent().jjtGetParent(); if (op instanceof ASTEQNode) { JexlNode field = JexlNodes.otherChild(op, node.jjtGetParent()).jjtGetChild(0); if (log.isTraceEnabled()) { log.trace("Found field " + JexlASTHelper.deconstructIdentifier(field.image) + "==" + node.getLiteral()); } values.addLiteral(node.getLiteral().toString(), JexlASTHelper.deconstructIdentifier(field.image)); } else if (op instanceof ASTERNode) { JexlNode field = JexlNodes.otherChild(op, node.jjtGetParent()).jjtGetChild(0); values.addPattern(node.getLiteral(), JexlASTHelper.deconstructIdentifier(field.image)); } return null; }
@Override public Object visit(ASTStringLiteral node, Object data) { STATE state = STATE.IGNORABLE; if (output != null) { output.writeLine(data + node.toString() + " -> " + state); } return state; }
public static JexlNode buildNewLiteralNode(JexlNode original, String fieldName, String fieldValue) { ASTReference literalReference = new ASTReference(ParserTreeConstants.JJTREFERENCE); ASTStringLiteral literal = getLiteral(fieldValue); literalReference.jjtAddChild(literal, 0); literal.jjtSetParent(literalReference); // we don't know whether the left or right side is the literal to replace. find it. if (original.jjtGetChild(0) instanceof ASTReference && original.jjtGetChild(0).jjtGetChild(0) instanceof ASTIdentifier) { original.jjtAddChild(literalReference, 1); // replace the original reference/literal (on left) with new reference/literal } if (original.jjtGetChild(1) instanceof ASTReference && original.jjtGetChild(1).jjtGetChild(0) instanceof ASTIdentifier) { original.jjtAddChild(literalReference, 0); // replace the original reference/literal (on right) with new reference/literal } literalReference.jjtSetParent(original); return original; }
public Object visit(ASTStringLiteral node, Object data) { output.writeLine(data + node.toString() + ":" + node.image); childrenAccept(node, this, data + PREFIX); return null; }
public static ASTReference literal(String s) { ASTStringLiteral l = new ASTStringLiteral(ParserTreeConstants.JJTSTRINGLITERAL); l.image = s; return makeRef(l); }
node.childrenAccept(this, sb); return sb;
/** * Assign the field name and value to the given newNode * * @param newNode * @param fieldName * @param fieldValue * @return */ protected static JexlNode buildUntypedNewNode(JexlNode newNode, ASTIdentifier fieldName, String fieldValue) { ASTStringLiteral literal = new ASTStringLiteral(ParserTreeConstants.JJTSTRINGLITERAL); literal.image = fieldValue; return buildUntypedNewNode(newNode, fieldName, literal); }
public static ASTReference normalizeLiteral(JexlNode literal, Type<?> normalizer) throws NormalizationException { String normalizedImg = normalizer.normalize(literal.image); ASTStringLiteral normalizedLiteral = new ASTStringLiteral(ParserTreeConstants.JJTSTRINGLITERAL); normalizedLiteral.image = normalizedImg; return JexlNodes.makeRef(normalizedLiteral); }
@Override public Object visit(ASTStringLiteral node, Object data) { // Fail fast if (this.normalizationFailed) { return node; } Type<?> normalizer = null; // get the argument index int index = (Integer) data; try { normalizer = normalizers.get(index); String normalizedValue = (descriptor.regexArguments() ? normalizer.normalizeRegex(node.image) : normalizer.normalize(node.image)); ASTStringLiteral normalizedLiteral = new ASTStringLiteral(ParserTreeConstants.JJTSTRINGLITERAL); normalizedLiteral.image = normalizedValue; return normalizedLiteral; } catch (Exception e) { // If we can't normalize a term, note that, and quit if (log.isTraceEnabled()) { log.trace("Failed to normalized " + node.image + " with " + normalizer != null ? normalizer.getClass().getName() : null + " normalizer"); } this.normalizationFailed = true; return node; } } }
final public void StringLiteral() throws ParseException { /*@bgen(jjtree) StringLiteral */ ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL); boolean jjtc000 = true; jjtree.openNodeScope(jjtn000); jjtreeOpenNodeScope(jjtn000);Token t; try { t = jj_consume_token(STRING_LITERAL); jjtree.closeNodeScope(jjtn000, true); jjtc000 = false; jjtreeCloseNodeScope(jjtn000); jjtn000.image = Parser.buildString(t.image, true); } finally { if (jjtc000) { jjtree.closeNodeScope(jjtn000, true); jjtreeCloseNodeScope(jjtn000); } } }
/** * Create a new ASTGENode from the given field name and value * * @param namespace * @param function * @param field * @param args * @return */ public static JexlNode buildFunctionNode(String namespace, String function, String field, Object... args) { ASTFunctionNode newNode = new ASTFunctionNode(ParserTreeConstants.JJTFUNCTIONNODE); JexlNodes.ensureCapacity(newNode, args.length + 3); int childIndex = 0; ASTIdentifier nsNode = new ASTIdentifier(ParserTreeConstants.JJTIDENTIFIER); nsNode.image = namespace; newNode.jjtAddChild(nsNode, childIndex++); ASTIdentifier functionNode = new ASTIdentifier(ParserTreeConstants.JJTIDENTIFIER); functionNode.image = function; newNode.jjtAddChild(functionNode, childIndex++); ASTIdentifier fieldNode = new ASTIdentifier(ParserTreeConstants.JJTIDENTIFIER); fieldNode.image = field; newNode.jjtAddChild(fieldNode, childIndex++); for (int i = 0; i < args.length; i++) { ASTStringLiteral literal = new ASTStringLiteral(ParserTreeConstants.JJTSTRINGLITERAL); literal.image = args[i].toString(); newNode.jjtAddChild(JexlNodeFactory.wrap(literal), childIndex++); } return JexlNodeFactory.wrap(newNode); }
JexlNode value = new ASTStringLiteral(5); value.image = "fieldValue1"; reference2.jjtAddChild(value, 0); value = new ASTStringLiteral(10); value.image = "fieldValue2"; reference2.jjtAddChild(value, 0);