Java Code Examples for java.util.Stack#size()

/**
 * Check pairs.
 * @param test
 *            the test
 * @return true, if successful
 */
private boolean checkPairs(String test) {
	String[] parts = test.trim().split("<"); //$NON-NLS-1$
	Stack<String> stack = new Stack<String>();
	for (int i = 0; i < parts.length; i++) {
		if (parts[i].length() > 0) {
			String[] subparts = parts[i].split("[\\s]|[>]"); //$NON-NLS-1$
			if (subparts[0].startsWith("/")) { //$NON-NLS-1$
				if (stack.size() == 0) {
					return false;
				} else {
					String last = stack.pop();
					if (!last.equals(subparts[0].substring(1))) {
						return false;
					}
				}
			} else {
				stack.push(subparts[0]);
			}
		}
	}
	if (stack.size() == 0) {
		return true;
	}
	return false;
}
 

/**
 * Given an expression and an optional comparator, build a tree of
 * InputFormats using the comparator to sort keys.
 */
static Node parse(String expr, JobConf job) throws IOException {
  if (null == expr) {
    throw new IOException("Expression is null");
  }
  Class<? extends WritableComparator> cmpcl =
    job.getClass("mapred.join.keycomparator", null, WritableComparator.class);
  Lexer lex = new Lexer(expr);
  Stack<Token> st = new Stack<Token>();
  Token tok;
  while ((tok = lex.next()) != null) {
    if (TType.RPAREN.equals(tok.getType())) {
      st.push(reduce(st, job));
    } else {
      st.push(tok);
    }
  }
  if (st.size() == 1 && TType.CIF.equals(st.peek().getType())) {
    Node ret = st.pop().getNode();
    if (cmpcl != null) {
      ret.setKeyComparator(cmpcl);
    }
    return ret;
  }
  throw new IOException("Missing ')'");
}
 

/**
 * Calculates the length of the the sub-path in a transition path, that is used only by a given string.
 
 * @param str       a String corresponding to a transition path from sourceNode
 * @return          an int denoting the size of the sub-path in the transition path
 *                  corresponding to {@code str} that is only used by {@code str}
 */
private int calculateSoleTransitionPathLength(String str)
{
    Stack<MDAGNode> transitionPathNodeStack = sourceNode.getTransitionPathNodes(str);
    transitionPathNodeStack.pop();  //The MDAGNode at the top of the stack is not needed
                                    //(we are processing the outgoing transitions of nodes inside str's transition path,
                                    //the outgoing transitions of the MDAGNode at the top of the stack are outside this path)
    
    transitionPathNodeStack.trimToSize();

    //Process each node in transitionPathNodeStack, using each to determine whether the
    //transition path corresponding to str is only used by str.  This is true if and only if
    //each node in the transition path has a single outgoing transition and is not an accept state.
    while(!transitionPathNodeStack.isEmpty())
    {
        MDAGNode currentNode = transitionPathNodeStack.peek();
        if(currentNode.getOutgoingTransitions().size() <= 1 && !currentNode.isAcceptNode())
            transitionPathNodeStack.pop();
        else
            break;
    }
    /////
    
    return (transitionPathNodeStack.capacity() - transitionPathNodeStack.size());
}
 

@Override
public void setLabelBeforeAction(Label endLabel) {
	Stack<Pair<Label, Block>> onEntry = this.getLinesToVisitOnEntry();
	
	//they are stored in reverse order
	for(int n=onEntry.size()-1; n >= 0; n--){
		Pair<Label, Block> level = onEntry.get(n);
		if(level.getA()!=null){
			onEntry.set(n, new Pair<Label, Block>(endLabel, level.getB()));//overrite the label
			return;
		}
		
	}
	//nothing extra to insert so...
	setLabelToVisitJustBeforeReturnOpCode(endLabel);
}
 

private boolean checkUnDeployLogOrder(LogViewerClient logViewerClient)
        throws RemoteException {
    LogEvent[] systemLogs;
    systemLogs = logViewerClient.getAllRemoteSystemLogs();
    //Create a stack to store the intended logs in order
    Stack<String> logStack = new Stack<>();
    logStack.push("Inbound Endpoint named 'inbound-endpoint' has been undeployed");
    logStack.push("Sequence named 'test-sequence' has been undeployed");

    //Check whether the logs are in the stack's order
    if (systemLogs != null) {
        for (LogEvent logEvent : systemLogs) {
            if (logEvent == null) {
                continue;
            }
            if (logStack.size() != 0 && logEvent.getMessage().contains(logStack.peek())){
                logStack.pop();
            }
        }
    }
    return logStack.isEmpty();
}
 

public static BinaryTree<Integer> LCA(BinaryTree<Integer> tree, BinaryTree<Integer> node0, BinaryTree<Integer> node1) {
    Stack<BinaryTree<Integer>> zero = dfs(tree, node0, new Stack<>());
    Stack<BinaryTree<Integer>> one = dfs(tree, node1, new Stack<>());

    //ITERATE BOTH STACKS
    while (!zero.isEmpty() && !one.isEmpty()) {
        if (zero.size() > one.size()) {
            //IF STACK ZERO IS BIGGER GET TO SAME LEVEL AS ONE
            zero.pop();
        } else if (zero.size() < one.size()) {
            //IF STACK ONE IS BIGGER GET TO SAME LEVEL AS ZERO
            one.pop();
        } else {
            //IF STACKS ARE EQUAL SEE IF THEY HAVE THE SAME NODE
            if (zero.peek().equals(one.peek()))
                return zero.pop();
            zero.pop();
            one.pop();
        }
    }

    return new BinaryTree<>(0);
}
 

/**
 * There're 3 special RelNode in parents stack, OLAPProjectRel, OLAPToEnumerableConverter
 * and OLAPUnionRel. OLAPProjectRel will helps collect required columns but the other two
 * don't. Go through the parent RelNodes from bottom to top, and the first-met special
 * RelNode determines the behavior.
 *      * OLAPProjectRel -> skip column collection
 *      * OLAPToEnumerableConverter and OLAPUnionRel -> require column collection
 */
private boolean needCollectionColumns(OLAPImplementor implementor) {
    Stack<RelNode> allParents = implementor.getParentNodeStack();
    int index = allParents.size() - 1;

    while (index >= 0) {
        RelNode parent = allParents.get(index);
        if (parent instanceof OLAPProjectRel) {
            return false;
        }

        if (parent instanceof OLAPToEnumerableConverter || parent instanceof OLAPUnionRel) {
            return true;
        }

        OLAPRel olapParent = (OLAPRel) allParents.get(index);
        if (olapParent.getContext() != null && olapParent.getContext() != this.context) {
            // if the whole context has not projection, let table scan take care of itself
            break;
        }
        index--;
    }

    return true;
}
 

public String[] bases (String x){
    try {
        // default to using the current ORB version in case the
        // vhandler is not set
        if (vhandler == null) {
            vhandler = ValueHandlerImpl.getInstance(false);
        }

        Stack repIds = new Stack();
        Class parent = ObjectStreamClass.lookup(vhandler.getClassFromType(x)).forClass().getSuperclass();

        while (!parent.equals(java.lang.Object.class)) {
            repIds.push(vhandler.createForAnyType(parent));
            parent = parent.getSuperclass();
        }

        String result[] = new String[repIds.size()];
        for (int i = result.length - 1; i >= 0; i++)
            result[i] = (String)repIds.pop();

        return result;
    } catch (Throwable t) {
        throw wrapper.missingLocalValueImpl( CompletionStatus.COMPLETED_MAYBE, t );
    }
}
 

private void ensureUniqueCanonicalStack(int jumpsrc, int jumpdest, Stack<Variable> stack) {
	// check if the current stack is going to be used as a canonical stack
	if (!canonicalStackForBranchJoinJumpdest.containsKey(jumpdest)) {
		// if so, check for duplicate variables in the stack, which may cause merge conflicts
		if (stack.size() != stack.stream().distinct().count()) {
			log.println("undup canonical stack @" + toHex(jumpdest));
			// map duplicate variables to new ones
			if (jumpsrc != -1 && variableReassignments.containsKey(jumpsrc) || jumpsrc == -1 && variableReassignmentsInline.containsKey(jumpsrc)) {
				throw new IllegalStateException("reassignment does already exist");
			}
			Map<Variable, Variable> reassignments = new HashMap<>();
			Set<Variable> processedVars = new HashSet<>();
			for (int i = 0; i < stack.size(); ++i) {
				Variable var = stack.get(i);
				if (processedVars.contains(var)) {
					// duplicate variable, create new one with reassigment
					Variable undupVar = new Variable();
					stack.set(i, undupVar);
					reassignments.put(undupVar, var);
					log.println(" " + undupVar + " <- " + var);
				}
				else {
					processedVars.add(var);
				}
			}
			if (jumpsrc == -1) {
				variableReassignmentsInline.put(jumpdest, reassignments);
			}
			else {
				variableReassignments.put(jumpsrc, reassignments);
			}
		}
	}
}
 

public static void main (String [] args) throws Exception {
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	String s;
	while ((s=br.readLine())!=null) {
		StringTokenizer st=new StringTokenizer(s);
		Stack<Doll> stk=new Stack<>();
		int dollCount=0;
		while (st.hasMoreTokens()) {
			int n=Integer.parseInt(st.nextToken());
			dollCount++;
			if (n<0) {
				Doll d=new Doll(-n);
				if (stk.empty()) stk.add(d);
				else if (stk.peek().emptySpace>d.size) {
					stk.peek().emptySpace-=d.size;
					stk.add(d);
				} else break;
			} else {
				if (!stk.isEmpty() && stk.peek().size==n) stk.pop();
				else break;
			}
		}

		if (stk.size()==0 && dollCount%2==0) System.out.println(":-) Matrioshka!");
		else System.out.println(":-( Try again.");
	}
}
 

public int[] asteroidCollision(int[] asteroids) {
    Stack<Integer> stack = new Stack<>();
    for (int asteroid : asteroids) {
        collision:
        {
            while (!stack.isEmpty() && asteroid < 0 && stack.peek() > 0) {

                if (stack.peek() + asteroid < 0) {
                    stack.pop();
                    continue;
                } else if (stack.peek() + asteroid == 0) {
                    stack.pop();
                }
                break collision;
            }
            stack.push(asteroid);
        }
    }

    int size = stack.size();
    int[] res = new int[size];
    int index = size - 1;
    while (!stack.isEmpty()) {
        res[index] = stack.pop();
        index--;
    }
    return res;
}
 

@Nullable
@Override
public ProblemDescriptor[] checkFile(@NotNull PsiFile file, @NotNull final InspectionManager manager, final boolean isOnTheFly) {
  if (!(file instanceof HaxeFile)) return null;
  final List<ProblemDescriptor> result = new ArrayList<ProblemDescriptor>();
  final ProblemReporter reporter = new ProblemReporter() {
    @Override
    public void reportProblem(ASTNode node, String message) {
      result.add( manager.createProblemDescriptor( node.getPsi(),
                                                   message,
                                                   (LocalQuickFix)null,
                                                   ProblemHighlightType.ERROR,
                                                   isOnTheFly));
    }
  };

  FileASTNode node1 = file.getNode();
  LeafElement firstLeaf = TreeUtil.findFirstLeaf(node1);

  Stack<List<ASTNode>> levels = new Stack<List<ASTNode>>();
  List<ASTNode> nodes = new ArrayList<ASTNode>();
  // Push the root node, just in case there is no #if to start it off.
  levels.push(nodes);

  ASTNode leaf = firstLeaf;
  while (leaf != null) {
    IElementType leafElementType = leaf.getElementType();

    if (leafElementType.equals(HaxeTokenTypes.PPIF)) {
      nodes = new ArrayList<ASTNode>();
      levels.push(nodes);
      nodes.add(leaf);
    }
    else if (leafElementType.equals(HaxeTokenTypes.PPEND)) {
      nodes.add(leaf);
      // Leave the base level in place, even if there are extra ends.
      if (levels.size() > 1) {
        validateLevel(nodes, reporter);
        levels.pop();
        nodes = levels.peek();
      }
    }
    else if (leafElementType.equals(HaxeTokenTypes.PPELSEIF)) {
      nodes.add(leaf);
    }
    else if (leafElementType.equals(HaxeTokenTypes.PPELSE)) {
      nodes.add(leaf);
    }
    leaf = TreeUtil.nextLeaf(leaf);
  }

  // Any levels that are still left need to be validated.
  for (List<ASTNode> level : levels) {
    validateLevel(level, reporter);
  }

  return ArrayUtil.toObjectArray(result, ProblemDescriptor.class);
}
 

/**
 * Construct a QName from a string, resolving the prefix
 * using the given namespace stack. The default namespace is
 * not resolved.
 *
 * @param qname Qualified name to resolve
 * @param namespaces Namespace stack to use to resolve namespace
 * @param validate If true the new QName will be validated and an IllegalArgumentException will
 *                 be thrown if it is invalid.
 */
public QName(String qname, Stack namespaces, boolean validate)
{

  String namespace = null;
  String prefix = null;
  int indexOfNSSep = qname.indexOf(':');

  if (indexOfNSSep > 0)
  {
    prefix = qname.substring(0, indexOfNSSep);

    if (prefix.equals("xml"))
    {
      namespace = S_XMLNAMESPACEURI;
    }
    // Do we want this?
    else if (prefix.equals("xmlns"))
    {
      return;
    }
    else
    {
      int depth = namespaces.size();

      for (int i = depth - 1; i >= 0; i--)
      {
        NameSpace ns = (NameSpace) namespaces.elementAt(i);

        while (null != ns)
        {
          if ((null != ns.m_prefix) && prefix.equals(ns.m_prefix))
          {
            namespace = ns.m_uri;
            i = -1;

            break;
          }

          ns = ns.m_next;
        }
      }
    }

    if (null == namespace)
    {
      throw new RuntimeException(
        XMLMessages.createXMLMessage(
          XMLErrorResources.ER_PREFIX_MUST_RESOLVE,
          new Object[]{ prefix }));  //"Prefix must resolve to a namespace: "+prefix);
    }
  }

  _localName = (indexOfNSSep < 0)
               ? qname : qname.substring(indexOfNSSep + 1);

  if (validate)
  {
      if ((_localName == null) || (!XML11Char.isXML11ValidNCName(_localName)))
      {
         throw new IllegalArgumentException(XMLMessages.createXMLMessage(
          XMLErrorResources.ER_ARG_LOCALNAME_INVALID,null )); //"Argument 'localName' not a valid NCName");
      }
  }
  _namespaceURI = namespace;
  _prefix = prefix;
  m_hashCode = toString().hashCode();
}
 

/**
 * Messages getTreeNodeForPage(path, onlyIfVisible, shouldCreate,
 * path.length) as long as path is non-null and the length is {@literal >} 0.
 * Otherwise returns null.
 */
private FHTreeStateNode getNodeForPath(TreePath path,
                                         boolean onlyIfVisible,
                                         boolean shouldCreate) {
    if(path != null) {
        FHTreeStateNode      node;

        node = getMapping(path);
        if(node != null) {
            if(onlyIfVisible && !node.isVisible())
                return null;
            return node;
        }
        if(onlyIfVisible)
            return null;

        // Check all the parent paths, until a match is found.
        Stack<TreePath> paths;

        if(tempStacks.size() == 0) {
            paths = new Stack<TreePath>();
        }
        else {
            paths = tempStacks.pop();
        }

        try {
            paths.push(path);
            path = path.getParentPath();
            node = null;
            while(path != null) {
                node = getMapping(path);
                if(node != null) {
                    // Found a match, create entries for all paths in
                    // paths.
                    while(node != null && paths.size() > 0) {
                        path = paths.pop();
                        node = node.createChildFor(path.
                                                   getLastPathComponent());
                    }
                    return node;
                }
                paths.push(path);
                path = path.getParentPath();
            }
        }
        finally {
            paths.removeAllElements();
            tempStacks.push(paths);
        }
        // If we get here it means they share a different root!
        return null;
    }
    return null;
}
 

/**
  * Returns the TreeStateNode identified by path.  This mirrors
  * the behavior of getNodeForPath, but tries to take advantage of
  * path if it is an instance of AbstractTreePath.
  */
private TreeStateNode getNodeForPath(TreePath path,
                                       boolean onlyIfVisible,
                                       boolean shouldCreate) {
    if(path != null) {
        TreeStateNode      node;

        node = getMapping(path);
        if(node != null) {
            if(onlyIfVisible && !node.isVisible())
                return null;
            return node;
        }

        // Check all the parent paths, until a match is found.
        Stack<TreePath> paths;

        if(tempStacks.size() == 0) {
            paths = new Stack<TreePath>();
        }
        else {
            paths = tempStacks.pop();
        }

        try {
            paths.push(path);
            path = path.getParentPath();
            node = null;
            while(path != null) {
                node = getMapping(path);
                if(node != null) {
                    // Found a match, create entries for all paths in
                    // paths.
                    while(node != null && paths.size() > 0) {
                        path = paths.pop();
                        node.getLoadedChildren(shouldCreate);

                        int            childIndex = treeModel.
                                  getIndexOfChild(node.getUserObject(),
                                              path.getLastPathComponent());

                        if(childIndex == -1 ||
                           childIndex >= node.getChildCount() ||
                           (onlyIfVisible && !node.isVisible())) {
                            node = null;
                        }
                        else
                            node = (TreeStateNode)node.getChildAt
                                           (childIndex);
                    }
                    return node;
                }
                paths.push(path);
                path = path.getParentPath();
            }
        }
        finally {
            paths.removeAllElements();
            tempStacks.push(paths);
        }
        // If we get here it means they share a different root!
        // We could throw an exception...
    }
    return null;
}
 

/** Handle an operand */
private static Operand handleOperand( String sourceField, BSONObject exp ) {

    Operand current = null;
    Object value = null;

    for ( String field : exp.keySet() ) {
        if ( field.startsWith( "$" ) ) {
            if ( "$gt".equals( field ) ) {
                value = exp.get( field );

                GreaterThan gt = new GreaterThan();
                gt.setProperty( sourceField );
                gt.setLiteral( value );

                current = gt;
            }
            else if ( "$gte".equals( field ) ) {
                value = exp.get( field );

                GreaterThanEqual gte = new GreaterThanEqual();
                gte.setProperty( sourceField );
                gte.setLiteral( exp.get( field ) );

                current = gte;
                // http://www.mongodb.org/display/DOCS/Advanced+Queries#AdvancedQueries-%3C%2C%3C%3D%2C%3E%2C%3E%3D
                // greater than equals
                // { "field" : { $gte: value } }
            }
            else if ( "$lt".equals( field ) ) {
                value = exp.get( field );

                LessThan lt = new LessThan();
                lt.setProperty( sourceField );
                lt.setLiteral( value );

                current = lt;
            }
            else if ( "$lte".equals( field ) ) {
                value = exp.get( field );

                LessThanEqual lte = new LessThanEqual();
                lte.setProperty( sourceField );
                lte.setLiteral( value );

                current = lte;
            }
            else if ( "$in".equals( field ) ) {
                value = exp.get( field );

                BasicBSONList values = ( BasicBSONList ) value;

                int size = values.size();

                Stack<Operand> expressions = new Stack<Operand>();

                for (Object value1 : values) {
                    Equal equal = new Equal();
                    equal.setProperty(sourceField);
                    equal.setLiteral(value1);

                    expressions.push(equal);
                }

                // we need to build a tree of expressions
                while ( expressions.size() > 1 ) {
                    OrOperand or = new OrOperand();
                    or.addChild( expressions.pop() );
                    or.addChild( expressions.pop() );
                    expressions.push( or );
                }

                current = expressions.pop();
            }
        }
    }

    return current;
}
 

@Override
protected Object map(Admin traverser) {
	Object ans = null;

       // Execute the operations
       Stack<Object> runStack = new Stack<Object>();
       
       for (PixyDatum op : operations) {
       	switch (op.getType()) {
       	case NUMBER:
       		runStack.push(op.getNumber());
       		break;
       		
       	case STRING:
       		runStack.push(op.getString());
       		break;

       	case SPECIAL_ATOM:
       		if (op.isAtomAPipeVar()) {
       			String namedStep = op.getAtomVarName();
       			
       			Object curEnd;
       			if (namedStep.equals("")) {
       				curEnd = traverser.get();
       			} else {
       				curEnd = this.getNullableScopeValue(null, namedStep, traverser);
       			}

       			Object item = convertToRuntimeObject(namedStep, curEnd);
       			runStack.push(item);
       		} else if (op.isTrue()) {
       			runStack.push(Boolean.TRUE);
       		} else if (op.isFail()) {
       			runStack.push(Boolean.FALSE);
       		} else {
           		runStack.push(calculate(op.getAtom(), runStack));
       		}
       		break;

       	case RELATION:
       	case LIST:
       	case VARIABLE:
       	default: 
       		throw new PixyException(PixyErrorCodes.INTERNAL_ERROR, "Unhandled operation: " + op + ". Run stack: " + runStack);
       	}
	}
	
       if (runStack.size() == 1) {
       	ans = runStack.pop();
       } else {
           throw new PixyException(PixyErrorCodes.INTERNAL_ERROR, "Internal error. Operations " + operations + " left run stack with " + runStack);        	
       }

       return ans;
   }
 

/**
  * Returns the TreeStateNode identified by path.  This mirrors
  * the behavior of getNodeForPath, but tries to take advantage of
  * path if it is an instance of AbstractTreePath.
  */
private TreeStateNode getNodeForPath(TreePath path,
                                       boolean onlyIfVisible,
                                       boolean shouldCreate) {
    if(path != null) {
        TreeStateNode      node;

        node = getMapping(path);
        if(node != null) {
            if(onlyIfVisible && !node.isVisible())
                return null;
            return node;
        }

        // Check all the parent paths, until a match is found.
        Stack<TreePath> paths;

        if(tempStacks.size() == 0) {
            paths = new Stack<TreePath>();
        }
        else {
            paths = tempStacks.pop();
        }

        try {
            paths.push(path);
            path = path.getParentPath();
            node = null;
            while(path != null) {
                node = getMapping(path);
                if(node != null) {
                    // Found a match, create entries for all paths in
                    // paths.
                    while(node != null && paths.size() > 0) {
                        path = paths.pop();
                        node.getLoadedChildren(shouldCreate);

                        int            childIndex = treeModel.
                                  getIndexOfChild(node.getUserObject(),
                                              path.getLastPathComponent());

                        if(childIndex == -1 ||
                           childIndex >= node.getChildCount() ||
                           (onlyIfVisible && !node.isVisible())) {
                            node = null;
                        }
                        else
                            node = (TreeStateNode)node.getChildAt
                                           (childIndex);
                    }
                    return node;
                }
                paths.push(path);
                path = path.getParentPath();
            }
        }
        finally {
            paths.removeAllElements();
            tempStacks.push(paths);
        }
        // If we get here it means they share a different root!
        // We could throw an exception...
    }
    return null;
}
 

/**
  * Returns the TreeStateNode identified by path.  This mirrors
  * the behavior of getNodeForPath, but tries to take advantage of
  * path if it is an instance of AbstractTreePath.
  */
private TreeStateNode getNodeForPath(TreePath path,
                                       boolean onlyIfVisible,
                                       boolean shouldCreate) {
    if(path != null) {
        TreeStateNode      node;

        node = getMapping(path);
        if(node != null) {
            if(onlyIfVisible && !node.isVisible())
                return null;
            return node;
        }

        // Check all the parent paths, until a match is found.
        Stack<TreePath> paths;

        if(tempStacks.size() == 0) {
            paths = new Stack<TreePath>();
        }
        else {
            paths = tempStacks.pop();
        }

        try {
            paths.push(path);
            path = path.getParentPath();
            node = null;
            while(path != null) {
                node = getMapping(path);
                if(node != null) {
                    // Found a match, create entries for all paths in
                    // paths.
                    while(node != null && paths.size() > 0) {
                        path = paths.pop();
                        node.getLoadedChildren(shouldCreate);

                        int            childIndex = treeModel.
                                  getIndexOfChild(node.getUserObject(),
                                              path.getLastPathComponent());

                        if(childIndex == -1 ||
                           childIndex >= node.getChildCount() ||
                           (onlyIfVisible && !node.isVisible())) {
                            node = null;
                        }
                        else
                            node = (TreeStateNode)node.getChildAt
                                           (childIndex);
                    }
                    return node;
                }
                paths.push(path);
                path = path.getParentPath();
            }
        }
        finally {
            paths.removeAllElements();
            tempStacks.push(paths);
        }
        // If we get here it means they share a different root!
        // We could throw an exception...
    }
    return null;
}
 

/**
 * Construct a QName from a string, resolving the prefix
 * using the given namespace stack. The default namespace is
 * not resolved.
 *
 * @param qname Qualified name to resolve
 * @param namespaces Namespace stack to use to resolve namespace
 * @param validate If true the new QName will be validated and an IllegalArgumentException will
 *                 be thrown if it is invalid.
 */
public QName(String qname, Stack<NameSpace> namespaces, boolean validate)
{

  String namespace = null;
  String prefix = null;
  int indexOfNSSep = qname.indexOf(':');

  if (indexOfNSSep > 0)
  {
    prefix = qname.substring(0, indexOfNSSep);

    if (prefix.equals("xml"))
    {
      namespace = S_XMLNAMESPACEURI;
    }
    // Do we want this?
    else if (prefix.equals("xmlns"))
    {
      return;
    }
    else
    {
      int depth = namespaces.size();

      for (int i = depth - 1; i >= 0; i--)
      {
        NameSpace ns = namespaces.get(i);

        while (null != ns)
        {
          if ((null != ns.m_prefix) && prefix.equals(ns.m_prefix))
          {
            namespace = ns.m_uri;
            i = -1;

            break;
          }

          ns = ns.m_next;
        }
      }
    }

    if (null == namespace)
    {
      throw new RuntimeException(
        XMLMessages.createXMLMessage(
          XMLErrorResources.ER_PREFIX_MUST_RESOLVE,
          new Object[]{ prefix }));  //"Prefix must resolve to a namespace: "+prefix);
    }
  }

  _localName = (indexOfNSSep < 0)
               ? qname : qname.substring(indexOfNSSep + 1);

  if (validate)
  {
      if ((_localName == null) || (!XML11Char.isXML11ValidNCName(_localName)))
      {
         throw new IllegalArgumentException(XMLMessages.createXMLMessage(
          XMLErrorResources.ER_ARG_LOCALNAME_INVALID,null )); //"Argument 'localName' not a valid NCName");
      }
  }
  _namespaceURI = namespace;
  _prefix = prefix;
  m_hashCode = toString().hashCode();
}