generator/schema2template/src/main/java/schema2template/model/MSVExpressionIterator.java - odftoolkit - Git at Google

 /************************************************************************
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
  *
  * Copyright 2009, 2010 Oracle and/or its affiliates. All rights reserved.
  *
  * Use is subject to license terms.
  *
  * Licensed 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. You can also
  * obtain a copy of the License at http://odftoolkit.org/docs/license.txt
  *
  * 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 schema2template.model;

 import static schema2template.example.odf.OdfHelper.DEBUG;
 import com.sun.msv.grammar.DataExp;
 import com.sun.msv.grammar.ElementExp;
 import com.sun.msv.grammar.Expression;
 import com.sun.msv.grammar.NameClassAndExpression;
 import com.sun.msv.grammar.ReferenceExp;
 import com.sun.msv.grammar.ValueExp;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Stack;
 import java.util.logging.Logger;

 /**
  * Iterates through the MSV expression tree.
  *
  * Traversing the MSV Tree structure by
  *	1) First trying to get the child (going as deep as possible)
  *  2) Second if no child is available, trying to get the next sibling
  *  3) If no sibling available, get a sibling of the parent (going back to step 1)
  *
  * <p>Also has the ability to limit iteration to given subclasses and to limit subtree
  * to the next element expressions below. </p>
  */
 public final class MSVExpressionIterator implements Iterator<Expression> {

 	private static final Logger LOG = Logger.getLogger(MSVExpressionIterator.class.getName());
 	private Expression mCurrentExpression; // the expression that will be received by next()
 	public int mCurrentExpressionDepth;   // Level of current expression starting with 0
 	private MSVExpressionVisitorChildren mVisitor;
 	// list of already visited expressions to avoid endless recursion
 	// The stack assists the iteration to go back up (usually done in by recursion)
 	// The stack contains the next expression, parent, grandparent, ...
 	private Stack<UniqueAncestor> mAncestorsAndCurrent;
 	// to prevent enless loops, known Element expression will be remembered and not again reentered
 	// Situation: Element a contains Element b contains Element a, will stop after the second a not continuing with b
 	private HashSet<Expression> mKnownElementExpressions;

 	// The vertical tree position is remembered by the stack, the vertical position will be remembered by a sibling index
 	private class UniqueAncestor {

 		public UniqueAncestor(Expression exp, int siblingIndex) {
 			mExp = exp;
 			mSiblingIndex = siblingIndex;
 		}
 		private Expression mExp;
 		private int mSiblingIndex;
 	}
 	// limit browsing to subclasses of Expression
 	private Class mDesiredExpression;
 	// if false, only return direct children of root. Don't return root as first element or grand children
 	private boolean mOnlyChildren;
 	private int mCurrentDepth = 0;
 	public static final boolean ALL_SUBTREE = true;
 	public static final boolean DIRECT_CHILDREN_ONLY = true;

 	public int getDepth() {
 		return mCurrentDepth;
 	}

 	/**
 	 * Iterate through the expression tree
 	 *
 	 * @param root Expression root
 	 */
 	public MSVExpressionIterator(Expression root) {
 		this(root, Expression.class, false);
 	}

 	/**
 	 *  Iterate through the expression tree, but only return objects of desiredExpression
 	 *
 	 * @param root Expression root
 	 * @param desiredExpression Limit returned expressions to subclasses of desiredExpression
 	 */
 	public MSVExpressionIterator(Expression root, Class desiredExpression) {
 		this(root, desiredExpression, false);
 	}

 	/**
 	 * Iterate..., but only return objects of desiredExpression and (if not onlyChildren)
 	 * don't go to children of ElementExp elements (this does not concern root node!).
 	 *
 	 * <p>Example: Root is table:table. If you choose onlyChildren=false and to limit
 	 * desiredExpression=ElementExp.class, then you will get all direct element children of table:table,
 	 * like table:table-row. But you won't get the children of table:table-row.
 	 * </p>
 	 *
 	 * @param root Expression root
 	 * @param desiredExpression Limit returned expressions to subclasses of desiredExpression
 	 * @param onlyChildren if only children should be returned
 	 */
 	public MSVExpressionIterator(Expression root, Class desiredExpression, boolean onlyChildren) {
 		// initialize members
 		mCurrentExpression = root;
 		mDesiredExpression = desiredExpression;
 		mOnlyChildren = onlyChildren;

 		// create helpers
 		mVisitor = new MSVExpressionVisitorChildren();
 		mKnownElementExpressions = new HashSet<Expression>();

 		// Initialize status
 		mAncestorsAndCurrent = new Stack<UniqueAncestor>();
 		mAncestorsAndCurrent.push(new UniqueAncestor(root, 0));

 		// make sure that there is at least one desired expression - for hasNext()
 		while (!mDesiredExpression.isInstance(mCurrentExpression) && mCurrentExpression != null) {
 			mCurrentExpression = getNextExpression();
 		}

 		// Ignore root, if only children are desired
 		if (mOnlyChildren && root == mCurrentExpression) {
 			mCurrentExpression = getNextExpression();
 		}
 	}

 	public static String dumpMSVExpressionTree(Expression rootExpression) throws Exception {
 		MSVExpressionIterator iterator = new MSVExpressionIterator(rootExpression);
 		StringBuilder builder = new StringBuilder();
 		while (iterator.hasNext()) {
 			Expression expr = iterator.next();
 			builder.append(dumpMSVExpression(expr, iterator.getDepth())).append("\n");
 		}
 		return builder.toString();
 	}

 	private static String dumpMSVExpression(Expression expr, int depth) {
 		String returnValue = null;
 		MSVExpressionVisitorType typeVisitor = new MSVExpressionVisitorType();
 		MSVNameClassVisitorList nameVisitor = new MSVNameClassVisitorList();
 		MSVExpressionType type = (MSVExpressionType) expr.visit(typeVisitor);
 		returnValue = (depth + ": " + type.toString());

 		// AttributeExp, ElementExp
 		if (expr instanceof NameClassAndExpression) {
 			List<String> names = (List<String>) ((NameClassAndExpression) expr).getNameClass().visit(nameVisitor);
 			for (String name : names) {
 				returnValue += (" \"" + name + "\",");
 				if(DEBUG) System.out.println(returnValue);
 			}
 		} else if (expr instanceof ReferenceExp) {
 			returnValue += (" '" + ((ReferenceExp) expr).name + "',");
 			if(DEBUG) System.out.println(returnValue);
 		} else if (type == MSVExpressionType.VALUE) {
 			returnValue += (" '" + ((ValueExp) expr).value.toString() + "',");
 			if(DEBUG) System.out.println(returnValue);
 		} else if (type == MSVExpressionType.DATA) {
 			returnValue += (" '" + ((DataExp) expr).getName().localName + "',");
 			if(DEBUG) System.out.println(returnValue);
 		} else {
 			if(DEBUG) System.out.println(returnValue);
 		}
 		return returnValue;
 	}

 	public boolean hasNext() {
 		return (mCurrentExpression != null) ? true : false;
 	}

 	/** Iterating the Tree like the following
 	If there are (unvisited) children -> go down
 	If there are no (unvisited) children, but unvistsiblings -> go up and right
 	 */
 	private Expression getNextExpression() {
 		Expression nextExpression = null;
 		// the current expression might be null if the desired type of expression was never found in the tree
 		if (mCurrentExpression != null) {
 			// if all tree is desired, or root, or if it is not element expression
 			if (!mOnlyChildren || mAncestorsAndCurrent.size() == 1 || !(mAncestorsAndCurrent.peek().mExp instanceof ElementExp)) {
 				List<Expression> children = (List<Expression>) mCurrentExpression.visit(mVisitor);
 				// see if we can go DOWN the tree
 				if (children.size() > 0) {
 					Expression nextExpCandidate = children.get(0);
 					// DO NOT expand elements which occur more than one time in the ancestors hierarchy (i.e.
 					// since we compute the last element: Do not expand it, if it also occurs before)
 					if (isNoKnownElement(nextExpCandidate)) {
 						// GO DOWN - Proceed with first child
 						nextExpression = nextExpCandidate;
 						mAncestorsAndCurrent.push(new UniqueAncestor(nextExpression, 0));
 					}
 				}
 			}

 			// if you could not get depper, but you can go up
 			// if there was no first child for the next expression and still some parent not being the root
 			while (nextExpression == null && mAncestorsAndCurrent.size() > 1) {
 				// go one up the stack
 				UniqueAncestor uniqueAncestor = mAncestorsAndCurrent.pop();
 				// get the new parent
 				Expression parent = mAncestorsAndCurrent.peek().mExp;
 				// to get the siblings
 				List<Expression> siblings = (List<Expression>) parent.visit(mVisitor);
 				// get the unvisted sibling index
 				final int nextSiblingIndex = uniqueAncestor.mSiblingIndex + 1;
 				if (nextSiblingIndex < siblings.size()) {
 					Expression nextExpCandidate = siblings.get(nextSiblingIndex);
 					// DO NOT expand elements which occur more than one time in the ancestors hierarchy (i.e.
 					// since we compute the last element: Do not expand it, if it also occurs before)
 					if (isNoKnownElement(nextExpCandidate)) {
 						// GO RIGHT - Add next sibling to the stack
 						nextExpression = nextExpCandidate;
 						mAncestorsAndCurrent.push(new UniqueAncestor(nextExpression, nextSiblingIndex));
 					}
 				}
 			}
 		}
 		return nextExpression;
 	}

 	private boolean isNoKnownElement(Expression exp) {
 		boolean isNew = false;
 		if (!(exp instanceof ElementExp) || !mKnownElementExpressions.contains(exp)) {
 			mKnownElementExpressions.add(exp);
 			isNew = true;
 		} else {
 //			LOG.info("Found known element expression:" + dumpMSVExpression(exp, this.getDepth()));
 		}
 		return isNew;
 	}

 	public Expression next() {
 		if (mCurrentExpression == null) {
 			return null;
 		}
 		Expression retVal = mCurrentExpression;
 		mCurrentDepth = mAncestorsAndCurrent.size() - 1;
 		mCurrentExpression = getNextExpression();

 		// as there is always a desired expression, make sure the next one is adequate
 		while (!mDesiredExpression.isInstance(mCurrentExpression) && mCurrentExpression != null) {
 			mCurrentExpression = getNextExpression();
 		}
 		return retVal;
 	}

 	// Unsupported
 	public void remove() {
 		throw new UnsupportedOperationException("Not supported.");

 	}
 }
	/************************************************************************
	*
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
	*
	* Copyright 2009, 2010 Oracle and/or its affiliates. All rights reserved.
	*
	* Use is subject to license terms.
	*
	* Licensed 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. You can also
	* obtain a copy of the License at http://odftoolkit.org/docs/license.txt
	*
	* 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 schema2template.model;

	import static schema2template.example.odf.OdfHelper.DEBUG;
	import com.sun.msv.grammar.DataExp;
	import com.sun.msv.grammar.ElementExp;
	import com.sun.msv.grammar.Expression;
	import com.sun.msv.grammar.NameClassAndExpression;
	import com.sun.msv.grammar.ReferenceExp;
	import com.sun.msv.grammar.ValueExp;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Stack;
	import java.util.logging.Logger;

	/**
	* Iterates through the MSV expression tree.
	*
	* Traversing the MSV Tree structure by
	* 1) First trying to get the child (going as deep as possible)
	* 2) Second if no child is available, trying to get the next sibling
	* 3) If no sibling available, get a sibling of the parent (going back to step 1)
	*
	* <p>Also has the ability to limit iteration to given subclasses and to limit subtree
	* to the next element expressions below. </p>
	*/
	public final class MSVExpressionIterator implements Iterator<Expression> {

	private static final Logger LOG = Logger.getLogger(MSVExpressionIterator.class.getName());
	private Expression mCurrentExpression; // the expression that will be received by next()
	public int mCurrentExpressionDepth; // Level of current expression starting with 0
	private MSVExpressionVisitorChildren mVisitor;
	// list of already visited expressions to avoid endless recursion
	// The stack assists the iteration to go back up (usually done in by recursion)
	// The stack contains the next expression, parent, grandparent, ...
	private Stack<UniqueAncestor> mAncestorsAndCurrent;
	// to prevent enless loops, known Element expression will be remembered and not again reentered
	// Situation: Element a contains Element b contains Element a, will stop after the second a not continuing with b
	private HashSet<Expression> mKnownElementExpressions;

	// The vertical tree position is remembered by the stack, the vertical position will be remembered by a sibling index
	private class UniqueAncestor {

	public UniqueAncestor(Expression exp, int siblingIndex) {
	mExp = exp;
	mSiblingIndex = siblingIndex;
	}
	private Expression mExp;
	private int mSiblingIndex;
	}
	// limit browsing to subclasses of Expression
	private Class mDesiredExpression;
	// if false, only return direct children of root. Don't return root as first element or grand children
	private boolean mOnlyChildren;
	private int mCurrentDepth = 0;
	public static final boolean ALL_SUBTREE = true;
	public static final boolean DIRECT_CHILDREN_ONLY = true;

	public int getDepth() {
	return mCurrentDepth;
	}

	/**
	* Iterate through the expression tree
	*
	* @param root Expression root
	*/
	public MSVExpressionIterator(Expression root) {
	this(root, Expression.class, false);
	}

	/**
	* Iterate through the expression tree, but only return objects of desiredExpression
	*
	* @param root Expression root
	* @param desiredExpression Limit returned expressions to subclasses of desiredExpression
	*/
	public MSVExpressionIterator(Expression root, Class desiredExpression) {
	this(root, desiredExpression, false);
	}

	/**
	* Iterate..., but only return objects of desiredExpression and (if not onlyChildren)
	* don't go to children of ElementExp elements (this does not concern root node!).
	*
	* <p>Example: Root is table:table. If you choose onlyChildren=false and to limit
	* desiredExpression=ElementExp.class, then you will get all direct element children of table:table,
	* like table:table-row. But you won't get the children of table:table-row.
	* </p>
	*
	* @param root Expression root
	* @param desiredExpression Limit returned expressions to subclasses of desiredExpression
	* @param onlyChildren if only children should be returned
	*/
	public MSVExpressionIterator(Expression root, Class desiredExpression, boolean onlyChildren) {
	// initialize members
	mCurrentExpression = root;
	mDesiredExpression = desiredExpression;
	mOnlyChildren = onlyChildren;

	// create helpers
	mVisitor = new MSVExpressionVisitorChildren();
	mKnownElementExpressions = new HashSet<Expression>();

	// Initialize status
	mAncestorsAndCurrent = new Stack<UniqueAncestor>();
	mAncestorsAndCurrent.push(new UniqueAncestor(root, 0));

	// make sure that there is at least one desired expression - for hasNext()
	while (!mDesiredExpression.isInstance(mCurrentExpression) && mCurrentExpression != null) {
	mCurrentExpression = getNextExpression();
	}

	// Ignore root, if only children are desired
	if (mOnlyChildren && root == mCurrentExpression) {
	mCurrentExpression = getNextExpression();
	}
	}

	public static String dumpMSVExpressionTree(Expression rootExpression) throws Exception {
	MSVExpressionIterator iterator = new MSVExpressionIterator(rootExpression);
	StringBuilder builder = new StringBuilder();
	while (iterator.hasNext()) {
	Expression expr = iterator.next();
	builder.append(dumpMSVExpression(expr, iterator.getDepth())).append("\n");
	}
	return builder.toString();
	}

	private static String dumpMSVExpression(Expression expr, int depth) {
	String returnValue = null;
	MSVExpressionVisitorType typeVisitor = new MSVExpressionVisitorType();
	MSVNameClassVisitorList nameVisitor = new MSVNameClassVisitorList();
	MSVExpressionType type = (MSVExpressionType) expr.visit(typeVisitor);
	returnValue = (depth + ": " + type.toString());

	// AttributeExp, ElementExp
	if (expr instanceof NameClassAndExpression) {
	List<String> names = (List<String>) ((NameClassAndExpression) expr).getNameClass().visit(nameVisitor);
	for (String name : names) {
	returnValue += (" \"" + name + "\",");
	if(DEBUG) System.out.println(returnValue);
	}
	} else if (expr instanceof ReferenceExp) {
	returnValue += (" '" + ((ReferenceExp) expr).name + "',");
	if(DEBUG) System.out.println(returnValue);
	} else if (type == MSVExpressionType.VALUE) {
	returnValue += (" '" + ((ValueExp) expr).value.toString() + "',");
	if(DEBUG) System.out.println(returnValue);
	} else if (type == MSVExpressionType.DATA) {
	returnValue += (" '" + ((DataExp) expr).getName().localName + "',");
	if(DEBUG) System.out.println(returnValue);
	} else {
	if(DEBUG) System.out.println(returnValue);
	}
	return returnValue;
	}

	public boolean hasNext() {
	return (mCurrentExpression != null) ? true : false;
	}

	/** Iterating the Tree like the following
	If there are (unvisited) children -> go down
	If there are no (unvisited) children, but unvistsiblings -> go up and right
	*/
	private Expression getNextExpression() {
	Expression nextExpression = null;
	// the current expression might be null if the desired type of expression was never found in the tree
	if (mCurrentExpression != null) {
	// if all tree is desired, or root, or if it is not element expression
	if (!mOnlyChildren \|\| mAncestorsAndCurrent.size() == 1 \|\| !(mAncestorsAndCurrent.peek().mExp instanceof ElementExp)) {
	List<Expression> children = (List<Expression>) mCurrentExpression.visit(mVisitor);
	// see if we can go DOWN the tree
	if (children.size() > 0) {
	Expression nextExpCandidate = children.get(0);
	// DO NOT expand elements which occur more than one time in the ancestors hierarchy (i.e.
	// since we compute the last element: Do not expand it, if it also occurs before)
	if (isNoKnownElement(nextExpCandidate)) {
	// GO DOWN - Proceed with first child
	nextExpression = nextExpCandidate;
	mAncestorsAndCurrent.push(new UniqueAncestor(nextExpression, 0));
	}
	}
	}

	// if you could not get depper, but you can go up
	// if there was no first child for the next expression and still some parent not being the root
	while (nextExpression == null && mAncestorsAndCurrent.size() > 1) {
	// go one up the stack
	UniqueAncestor uniqueAncestor = mAncestorsAndCurrent.pop();
	// get the new parent
	Expression parent = mAncestorsAndCurrent.peek().mExp;
	// to get the siblings
	List<Expression> siblings = (List<Expression>) parent.visit(mVisitor);
	// get the unvisted sibling index
	final int nextSiblingIndex = uniqueAncestor.mSiblingIndex + 1;
	if (nextSiblingIndex < siblings.size()) {
	Expression nextExpCandidate = siblings.get(nextSiblingIndex);
	// DO NOT expand elements which occur more than one time in the ancestors hierarchy (i.e.
	// since we compute the last element: Do not expand it, if it also occurs before)
	if (isNoKnownElement(nextExpCandidate)) {
	// GO RIGHT - Add next sibling to the stack
	nextExpression = nextExpCandidate;
	mAncestorsAndCurrent.push(new UniqueAncestor(nextExpression, nextSiblingIndex));
	}
	}
	}
	}
	return nextExpression;
	}

	private boolean isNoKnownElement(Expression exp) {
	boolean isNew = false;
	if (!(exp instanceof ElementExp) \|\| !mKnownElementExpressions.contains(exp)) {
	mKnownElementExpressions.add(exp);
	isNew = true;
	} else {
	// LOG.info("Found known element expression:" + dumpMSVExpression(exp, this.getDepth()));
	}
	return isNew;
	}

	public Expression next() {
	if (mCurrentExpression == null) {
	return null;
	}
	Expression retVal = mCurrentExpression;
	mCurrentDepth = mAncestorsAndCurrent.size() - 1;
	mCurrentExpression = getNextExpression();

	// as there is always a desired expression, make sure the next one is adequate
	while (!mDesiredExpression.isInstance(mCurrentExpression) && mCurrentExpression != null) {
	mCurrentExpression = getNextExpression();
	}
	return retVal;
	}

	// Unsupported
	public void remove() {
	throw new UnsupportedOperationException("Not supported.");

	}
	}