Java Tree.getText方法代码示例

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
@Override
public boolean equalsByTree(Tree tree) {
	if (tree == null)
		return false;
	String op = tree.getText();
	if (op == null)
		return false;
	if (!op.equalsIgnoreCase(fnName))
		return false;
	if (tree.getChildCount() != inputs.size())
		return false;
	for (int i = 0; i < inputs.size(); ++i) {
		Column c = inputs.get(i);
		if (!c.getInfo().equalsByTree(tree.getChild(i)))
			return false;
	}
	return true;
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
static private String getText(Tree node)
{
    String text = node.getText();
    int index;
    switch (node.getType())
    {
    case CMIS_FTSParser.FTSWORD:
        index = text.indexOf('\\');
        if (index == -1)
        {
            return text;
        }
        else
        {
            return unescape(text);
        }
    case CMIS_FTSParser.FTSPHRASE:
        String phrase = text.substring(1, text.length() - 1);
        index = phrase.indexOf('\\');
        if (index == -1)
        {
            return phrase;
        }
        else
        {
            return unescape(phrase);
        }
    default:
        return text;
    }
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
@Override
public void registerPersisterSpace(Tree entityName, Tree alias) {
	String put = entityNameByAlias.put( alias.getText(), entityName.getText() );
	if ( put != null && !put.equalsIgnoreCase( entityName.getText() ) ) {
		throw new UnsupportedOperationException(
				"Alias reuse currently not supported: alias " + alias.getText()
				+ " already assigned to type " + put );
	}
	propertyHelper.registerEntityAlias( entityName.getText(), alias.getText() );
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
@Override
public PathedPropertyReferenceSource normalizeQualifiedRoot(Tree root) {
	String entityNameForAlias = entityNameByAlias.get( root.getText() );

	if ( entityNameForAlias == null ) {
		throw log.getUnknownAliasException( root.getText() );
	}

	return new PathedPropertyReference( root.getText(), null, true );
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
private String getDefaultFieldText(Tree tree) throws QueryParseException {
    String val = tree.getChild(0).toString();
    if (val.startsWith("\"") && val.endsWith("\"") && val.length() >= 2) {
        val = val.substring(1, val.length() - 1);
    }
    if (!isValidExpression(val)) {
        throw new QueryParseException("Invalid query at " +
                tree.getCharPositionInLine() + ": " + tree.getText());
    }
    return Query.sanitizeValue(val);
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
private static Relation parseAgg(Relation input, Tree select_subtree,
		Tree having_subtree) throws DataLawyerException {
	if (!select_subtree.getText().equalsIgnoreCase("select"))
		throw DataLawyerException.incorrectParseTree("select");
	if (having_subtree != null)
		if (!having_subtree.getText().equalsIgnoreCase("having"))
			throw DataLawyerException.incorrectParseTree("having");

	ArrayList<Tree> aggregations = getAggregations(select_subtree);
	if (having_subtree != null)
		aggregations.addAll(getAggregations(having_subtree));

	Relation output = input;

	// Unlike parseWhere, there might not be any aggregated column.
	if (aggregations.size() > 0) {
		output = new OpAgg(input);
		for (Tree aggregate : aggregations) {
			// We might end up adding duplicate columns (for example through
			// the having clause and through the select clause).
			if (output.getColumn(aggregate) == null) {
				String operation_string = aggregate.getText();
				Column input_col_id = getNewColumnIfRequired(input,
						aggregate.getChild(0));
				ColumnOptMetadata optinfo = input
						.getColumnOptInfo(input_col_id);
				UnaryOperation operation = Operation.getUnary(
						operation_string, input_col_id);
				((OpAgg) output).addOperation(operation, optinfo);
			}
		}
	}

	return output;
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
public Expression<?> translateLiteral(Tree n) {
  Type<?> type = null;
  switch(n.getType()) {
  case BYTE_LITERAL:
    type = BuiltinTypes.SINT8;
    break;
  case SHORT_LITERAL:
    type = BuiltinTypes.SINT16;
    break;
  case INT_LITERAL:
    type = BuiltinTypes.SINT32;
    break;
  case LONG_LITERAL:
    type = BuiltinTypes.SINT64;
    break;
  case FLOAT_LITERAL:
    type = BuiltinTypes.FLOAT;
    break;
  case DOUBLE_LITERAL:
    type = BuiltinTypes.DOUBLE;
    break;
  case BIGINT_LITERAL:
    type = BuiltinTypes.INTEGER;
    break;
  case BIGDECIMAL_LITERAL:
    type = BuiltinTypes.DECIMAL;
    break;
  default:
    throw new UnexpectedTokenException(n, BYTE_LITERAL, SHORT_LITERAL, INT_LITERAL, LONG_LITERAL, FLOAT_LITERAL, DOUBLE_LITERAL, BIGINT_LITERAL, BIGDECIMAL_LITERAL);  
  }
  
  String txt = n.getText();
  int lastIdx = txt.length() - 1;
  char last = txt.charAt(lastIdx);
  if(!Character.isDigit(last))
    txt = txt.substring(0, lastIdx);
  
  return Constant.createParsed(type, txt);
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
public String translateIdentifier(Tree n) {
  switch(n.getType()) {
  case ExpressionParser.ID:
    return n.getText();
  case ExpressionParser.QID:
    String txt = n.getText();
    // TODO : unescape quotes
    return txt.substring(1, txt.length() - 1);
  }
  throw new UnexpectedTokenException(n, ExpressionParser.ID, ExpressionParser.QID);
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
public Type<?> translateType(Tree n) {
  requireType(n, ExpressionParser.ID);
  String name = n.getText();
  Type<?> type = types.byName(name);
  if(type == null)
    throw new UnknownTypeException(n);
  return type;
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
static private String getText(Tree node, boolean returnTextFromUnknownNodes)
{
    String text = node.getText();
    int index;
    switch (node.getType())
    {
    case FTSParser.FTSWORD:
    case FTSParser.FTSPRE:
    case FTSParser.FTSWILD:
        index = text.indexOf('\\');
        if (index == -1)
        {
            return text;
        }
        else
        {
            return unescape(text);
        }
    case FTSParser.FTSPHRASE:
        String phrase = text.substring(1, text.length() - 1);
        index = phrase.indexOf('\\');
        if (index == -1)
        {
            return phrase;
        }
        else
        {
            return unescape(phrase);
        }
    case FTSParser.ID:
        index = text.indexOf('\\');
        if (index == -1)
        {
            return ISO9075.decode(text);
        }
        else
        {
            return ISO9075.decode(unescape(text));
        }
    case FTSParser.URI:
    case FTSParser.OR:
    case FTSParser.AND:
    case FTSParser.NOT:
    case FTSParser.TILDA:
    case FTSParser.PLUS:
    case FTSParser.MINUS:
    case FTSParser.COLON:
    case FTSParser.STAR:
    case FTSParser.DOTDOT:
    case FTSParser.DOT:
    case FTSParser.AMP:
    case FTSParser.EXCLAMATION:
    case FTSParser.BAR:
    case FTSParser.EQUALS:
    case FTSParser.QUESTION_MARK:
    case FTSParser.TO:
    case FTSParser.COMMA:
    case FTSParser.CARAT:
    case FTSParser.DOLLAR:
    case FTSParser.AT:
    case FTSParser.PERCENT:
    case FTSParser.DECIMAL_INTEGER_LITERAL:
    case FTSParser.FLOATING_POINT_LITERAL:
    case FTSParser.DATETIME:
        return text;
    default:
        if(returnTextFromUnknownNodes)
        {
            return text;
        }
        else
        {
            return "";
        }
    }
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
@Override
public PathedPropertyReferenceSource normalizeUnqualifiedPropertyReference(Tree property) {
	return new PathedPropertyReference( property.getText(), null, isAlias( property ) );
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
@Override
public PathedPropertyReferenceSource normalizeUnqualifiedRoot(Tree root) {
	return new PathedPropertyReference( root.getText(), null, isAlias( root ) );
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
@Override
public PathedPropertyReferenceSource normalizePropertyPathIntermediary(PropertyPath path, Tree propertyName) {
	return new PathedPropertyReference( propertyName.getText(), null, false );
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
@Override
public PathedPropertyReferenceSource normalizePropertyPathTerminus(PropertyPath path, Tree propertyNameNode) {
	return new PathedPropertyReference( propertyNameNode.getText(), null, false );
}
 

import org.antlr.runtime.tree.Tree; //导入方法依赖的package包/类
@Override
public void pushFromStrategy(JoinType joinType, Tree assosiationFetchTree, Tree propertyFetchTree, Tree alias) {
	this.currentAlias = alias.getText();
}