001: /*
002: * Copyright 1999-2004 The Apache Software Foundation.
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: /*
017: * $Id$
018: */
019: package org.apache.xml.utils;
020:
021: import java.util.EmptyStackException;
022:
023: /**
024: * Implement a stack of simple integers.
025: *
026: * %OPT%
027: * This is currently based on ObjectVector, which permits fast acess but pays a
028: * heavy recopying penalty if/when its size is increased. If we expect deep
029: * stacks, we should consider a version based on ChunkedObjectVector.
030: * @xsl.usage internal
031: */
032: public class ObjectStack extends ObjectVector {
033:
034: /**
035: * Default constructor. Note that the default
036: * block size is very small, for small lists.
037: */
038: public ObjectStack() {
039: super ();
040: }
041:
042: /**
043: * Construct a ObjectVector, using the given block size.
044: *
045: * @param blocksize Size of block to allocate
046: */
047: public ObjectStack(int blocksize) {
048: super (blocksize);
049: }
050:
051: /**
052: * Copy constructor for ObjectStack
053: *
054: * @param v ObjectStack to copy
055: */
056: public ObjectStack(ObjectStack v) {
057: super (v);
058: }
059:
060: /**
061: * Pushes an item onto the top of this stack.
062: *
063: * @param i the int to be pushed onto this stack.
064: * @return the <code>item</code> argument.
065: */
066: public Object push(Object i) {
067:
068: if ((m_firstFree + 1) >= m_mapSize) {
069: m_mapSize += m_blocksize;
070:
071: Object newMap[] = new Object[m_mapSize];
072:
073: System.arraycopy(m_map, 0, newMap, 0, m_firstFree + 1);
074:
075: m_map = newMap;
076: }
077:
078: m_map[m_firstFree] = i;
079:
080: m_firstFree++;
081:
082: return i;
083: }
084:
085: /**
086: * Removes the object at the top of this stack and returns that
087: * object as the value of this function.
088: *
089: * @return The object at the top of this stack.
090: */
091: public Object pop() {
092: Object val = m_map[--m_firstFree];
093: m_map[m_firstFree] = null;
094:
095: return val;
096: }
097:
098: /**
099: * Quickly pops a number of items from the stack.
100: */
101:
102: public void quickPop(int n) {
103: m_firstFree -= n;
104: }
105:
106: /**
107: * Looks at the object at the top of this stack without removing it
108: * from the stack.
109: *
110: * @return the object at the top of this stack.
111: * @throws EmptyStackException if this stack is empty.
112: */
113: public Object peek() {
114: try {
115: return m_map[m_firstFree - 1];
116: } catch (ArrayIndexOutOfBoundsException e) {
117: throw new EmptyStackException();
118: }
119: }
120:
121: /**
122: * Looks at the object at the position the stack counting down n items.
123: *
124: * @param n The number of items down, indexed from zero.
125: * @return the object at n items down.
126: * @throws EmptyStackException if this stack is empty.
127: */
128: public Object peek(int n) {
129: try {
130: return m_map[m_firstFree - (1 + n)];
131: } catch (ArrayIndexOutOfBoundsException e) {
132: throw new EmptyStackException();
133: }
134: }
135:
136: /**
137: * Sets an object at a the top of the statck
138: *
139: *
140: * @param val object to set at the top
141: * @throws EmptyStackException if this stack is empty.
142: */
143: public void setTop(Object val) {
144: try {
145: m_map[m_firstFree - 1] = val;
146: } catch (ArrayIndexOutOfBoundsException e) {
147: throw new EmptyStackException();
148: }
149: }
150:
151: /**
152: * Tests if this stack is empty.
153: *
154: * @return <code>true</code> if this stack is empty;
155: * <code>false</code> otherwise.
156: * @since JDK1.0
157: */
158: public boolean empty() {
159: return m_firstFree == 0;
160: }
161:
162: /**
163: * Returns where an object is on this stack.
164: *
165: * @param o the desired object.
166: * @return the distance from the top of the stack where the object is]
167: * located; the return value <code>-1</code> indicates that the
168: * object is not on the stack.
169: * @since JDK1.0
170: */
171: public int search(Object o) {
172:
173: int i = lastIndexOf(o);
174:
175: if (i >= 0) {
176: return size() - i;
177: }
178:
179: return -1;
180: }
181:
182: /**
183: * Returns clone of current ObjectStack
184: *
185: * @return clone of current ObjectStack
186: */
187: public Object clone() throws CloneNotSupportedException {
188: return (ObjectStack) super.clone();
189: }
190:
191: }
|