Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.hadoop.hive.ql.parse; import java.io.Serializable; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Deque; import java.util.List; import org.antlr.runtime.Token; import org.antlr.runtime.tree.CommonTree; import org.antlr.runtime.tree.Tree; import org.apache.commons.lang3.StringUtils; import org.apache.hadoop.hive.ql.lib.Node; /** * */ public class ASTNode extends CommonTree implements Node, Serializable { private static final long serialVersionUID = 1L; private transient StringBuilder astStr; private transient ASTNodeOrigin origin; private transient int startIndx = -1; private transient int endIndx = -1; private transient ASTNode rootNode; private transient boolean isValidASTStr; private transient boolean visited = false; public ASTNode() { } /** * Constructor. * * @param t * Token for the CommonTree Node */ public ASTNode(Token t) { super(t); } public ASTNode(ASTNode node) { super(node); this.origin = node.origin; } @Override public Tree dupNode() { return new ASTNode(this); } /* * (non-Javadoc) * * @see org.apache.hadoop.hive.ql.lib.Node#getChildren() */ @Override public ArrayList<Node> getChildren() { if (super.getChildCount() == 0) { return null; } ArrayList<Node> ret_vec = new ArrayList<Node>(); for (int i = 0; i < super.getChildCount(); ++i) { ret_vec.add((Node) super.getChild(i)); } return ret_vec; } /* * (non-Javadoc) * * @see org.apache.hadoop.hive.ql.lib.Node#getName() */ @Override public String getName() { return String.valueOf(super.getToken().getType()); } /** * For every node in this subtree, make sure it's start/stop token's * are set. Walk depth first, visit bottom up. Only updates nodes * with at least one token index < 0. * * In contrast to the method in the parent class, this method is * iterative. */ @Override public void setUnknownTokenBoundaries() { Deque<ASTNode> stack1 = new ArrayDeque<ASTNode>(); Deque<ASTNode> stack2 = new ArrayDeque<ASTNode>(); stack1.push(this); while (!stack1.isEmpty()) { ASTNode next = stack1.pop(); stack2.push(next); if (next.children != null) { for (int i = next.children.size() - 1; i >= 0; i--) { stack1.push((ASTNode) next.children.get(i)); } } } while (!stack2.isEmpty()) { ASTNode next = stack2.pop(); if (next.children == null) { if (next.startIndex < 0 || next.stopIndex < 0) { next.startIndex = next.stopIndex = next.token.getTokenIndex(); } } else if (next.startIndex >= 0 && next.stopIndex >= 0) { continue; } else if (next.children.size() > 0) { ASTNode firstChild = (ASTNode) next.children.get(0); ASTNode lastChild = (ASTNode) next.children.get(next.children.size() - 1); next.startIndex = firstChild.getTokenStartIndex(); next.stopIndex = lastChild.getTokenStopIndex(); } } } /** * @return information about the object from which this ASTNode originated, or * null if this ASTNode was not expanded from an object reference */ public ASTNodeOrigin getOrigin() { return origin; } /** * Tag this ASTNode with information about the object from which this node * originated. */ public void setOrigin(ASTNodeOrigin origin) { this.origin = origin; } public String dump() { StringBuilder sb = new StringBuilder("\n"); dump(sb); return sb.toString(); } private StringBuilder dump(StringBuilder sb) { Deque<ASTNode> stack = new ArrayDeque<ASTNode>(); stack.push(this); int tabLength = 0; while (!stack.isEmpty()) { ASTNode next = stack.peek(); if (!next.visited) { sb.append(StringUtils.repeat(" ", tabLength * 3)); sb.append(next.toString()); sb.append("\n"); if (next.children != null) { for (int i = next.children.size() - 1; i >= 0; i--) { stack.push((ASTNode) next.children.get(i)); } } tabLength++; next.visited = true; } else { tabLength--; next.visited = false; stack.pop(); } } return sb; } private void getRootNodeWithValidASTStr() { if (rootNode != null && rootNode.parent == null && rootNode.hasValidMemoizedString()) { return; } ASTNode retNode = this; while (retNode.parent != null) { retNode = (ASTNode) retNode.parent; } rootNode = retNode; if (!rootNode.isValidASTStr) { rootNode.astStr = new StringBuilder(); rootNode.toStringTree(rootNode); rootNode.isValidASTStr = true; } return; } private boolean hasValidMemoizedString() { return isValidASTStr && astStr != null; } private void resetRootInformation() { // Reset the previously stored rootNode string if (rootNode != null) { rootNode.astStr = null; rootNode.isValidASTStr = false; } } private int getMemoizedStringLen() { return astStr == null ? 0 : astStr.length(); } private String getMemoizedSubString(int start, int end) { return (astStr == null || start < 0 || end > astStr.length() || start >= end) ? null : astStr.subSequence(start, end).toString(); } private void addtoMemoizedString(String string) { if (astStr == null) { astStr = new StringBuilder(); } astStr.append(string); } @Override public void setParent(Tree t) { super.setParent(t); resetRootInformation(); } @Override public void addChild(Tree t) { super.addChild(t); resetRootInformation(); } @Override public void addChildren(List kids) { super.addChildren(kids); resetRootInformation(); } @Override public void setChild(int i, Tree t) { super.setChild(i, t); resetRootInformation(); } @Override public void insertChild(int i, Object t) { super.insertChild(i, t); resetRootInformation(); } @Override public Object deleteChild(int i) { Object ret = super.deleteChild(i); resetRootInformation(); return ret; } @Override public void replaceChildren(int startChildIndex, int stopChildIndex, Object t) { super.replaceChildren(startChildIndex, stopChildIndex, t); resetRootInformation(); } @Override public String toStringTree() { // The root might have changed because of tree modifications. // Compute the new root for this tree and set the astStr. getRootNodeWithValidASTStr(); // If rootNotModified is false, then startIndx and endIndx will be stale. if (startIndx >= 0 && endIndx <= rootNode.getMemoizedStringLen()) { return rootNode.getMemoizedSubString(startIndx, endIndx); } return toStringTree(rootNode); } private String toStringTree(ASTNode rootNode) { Deque<ASTNode> stack = new ArrayDeque<ASTNode>(); stack.push(this); while (!stack.isEmpty()) { ASTNode next = stack.peek(); if (!next.visited) { if (next.parent != null && next.parent.getChildCount() > 1 && next != next.parent.getChild(0)) { rootNode.addtoMemoizedString(" "); } next.rootNode = rootNode; next.startIndx = rootNode.getMemoizedStringLen(); // Leaf if (next.children == null || next.children.size() == 0) { String str = next.toString(); rootNode.addtoMemoizedString( next.getType() != HiveParser.StringLiteral ? str.toLowerCase() : str); next.endIndx = rootNode.getMemoizedStringLen(); stack.pop(); continue; } if (!next.isNil()) { rootNode.addtoMemoizedString("("); String str = next.toString(); rootNode.addtoMemoizedString( (next.getType() == HiveParser.StringLiteral || null == str) ? str : str.toLowerCase()); rootNode.addtoMemoizedString(" "); } if (next.children != null) { for (int i = next.children.size() - 1; i >= 0; i--) { stack.push((ASTNode) next.children.get(i)); } } next.visited = true; } else { if (!next.isNil()) { rootNode.addtoMemoizedString(")"); } next.endIndx = rootNode.getMemoizedStringLen(); next.visited = false; stack.pop(); } } return rootNode.getMemoizedSubString(startIndx, endIndx); } }