2 // System.Collections.Stack
\r
5 // Garrett Rooney (rooneg@electricjellyfish.net)
\r
7 // (C) 2001 Garrett Rooney
\r
10 namespace System.Collections {
\r
12 public class Stack : ICollection, IEnumerable, ICloneable {
\r
15 private object[] contents;
\r
16 private int current = -1;
\r
17 private int count = 0;
\r
18 private int capacity = 16;
\r
19 private int modCount = 0;
\r
21 private void Resize(int ncapacity) {
\r
22 object[] ncontents = new object[ncapacity];
\r
24 Array.Copy(contents, ncontents, count);
\r
26 capacity = ncapacity;
\r
27 contents = ncontents;
\r
31 contents = new object[capacity];
\r
34 public Stack(ICollection collection) {
\r
35 capacity = collection.Count;
\r
36 contents = new object[capacity];
\r
37 current = capacity - 1;
\r
40 collection.CopyTo(contents, 0);
\r
43 public Stack(int c) {
\r
45 contents = new object[capacity];
\r
48 private class SyncStack : Stack {
\r
52 public SyncStack(Stack s) {
\r
56 public override int Count {
\r
59 return stack.Count;
\r
64 public override bool IsReadOnly {
\r
67 return stack.IsReadOnly;
\r
72 public override bool IsSynchronized {
\r
73 get { return true; }
\r
76 public override object SyncRoot {
\r
77 get { return stack.SyncRoot; }
\r
80 public override void Clear() {
\r
81 lock(stack) { stack.Clear(); }
\r
84 public override object Clone() {
\r
86 return Stack.Synchronized((Stack)stack.Clone());
\r
90 public override bool Contains(object obj) {
\r
91 lock (stack) { return stack.Contains(obj); }
\r
94 public override void CopyTo(Array array, int index) {
\r
95 lock (stack) { stack.CopyTo(array, index); }
\r
98 public override IEnumerator GetEnumerator() {
\r
100 return new Enumerator(stack);
\r
104 public override object Peek() {
\r
105 lock (stack) { return stack.Peek(); }
\r
108 public override object Pop() {
\r
109 lock (stack) { return stack.Pop(); }
\r
112 public override void Push(object obj) {
\r
113 lock (stack) { stack.Push(obj); }
\r
116 public override object[] ToArray() {
\r
117 lock (stack) { return stack.ToArray(); }
\r
121 public static Stack Synchronized(Stack s) {
\r
123 throw new ArgumentNullException();
\r
126 return new SyncStack(s);
\r
129 public virtual int Count {
\r
130 get { return count; }
\r
133 public virtual bool IsReadOnly {
\r
134 get { return false; }
\r
137 public virtual bool IsSynchronized {
\r
138 get { return false; }
\r
141 public virtual object SyncRoot {
\r
142 get { return this; }
\r
145 public virtual void Clear() {
\r
148 for (int i = 0; i < count; i++) {
\r
149 contents[i] = null;
\r
156 public virtual object Clone() {
\r
159 stack = new Stack();
\r
161 stack.current = current;
\r
162 stack.contents = contents;
\r
163 stack.count = count;
\r
164 stack.capacity = capacity;
\r
169 public virtual bool Contains(object obj) {
\r
173 for (int i = 0; i < count; i++) {
\r
174 if (contents[i].Equals(obj))
\r
181 public virtual void CopyTo (Array array, int index) {
\r
182 if (array == null) {
\r
183 throw new ArgumentNullException();
\r
187 throw new ArgumentOutOfRangeException();
\r
190 if (array.Rank > 1 ||
\r
191 index >= array.Length ||
\r
192 count > array.Length - index) {
\r
193 throw new ArgumentException();
\r
196 for (int i = current; i != -1; i--) {
\r
197 array.SetValue(contents[i],
\r
198 count - (i + 1) + index);
\r
202 private class Enumerator : IEnumerator {
\r
205 private int modCount;
\r
206 private int current;
\r
208 internal Enumerator(Stack s) {
\r
209 // this is odd. it seems that you need to
\r
210 // start one further ahead than current, since
\r
211 // MoveNext() gets called first when using an
\r
214 modCount = s.modCount;
\r
215 current = s.current + 1;
\r
218 public virtual object Current {
\r
220 if (modCount != stack.modCount
\r
222 || current > stack.count)
\r
223 throw new InvalidOperationException();
\r
224 return stack.contents[current];
\r
228 public virtual bool MoveNext() {
\r
229 if (modCount != stack.modCount
\r
230 || current == -1) {
\r
231 throw new InvalidOperationException();
\r
236 if (current == -1) {
\r
243 public virtual void Reset() {
\r
244 if (modCount != stack.modCount) {
\r
245 throw new InvalidOperationException();
\r
248 // start one ahead of stack.current, so the
\r
249 // first MoveNext() will put us at the top
\r
250 current = stack.current + 1;
\r
254 public virtual IEnumerator GetEnumerator() {
\r
255 return new Enumerator(this);
\r
258 public virtual object Peek() {
\r
259 if (current == -1) {
\r
260 throw new InvalidOperationException();
\r
262 return contents[current];
\r
266 public virtual object Pop() {
\r
267 if (current == -1) {
\r
268 throw new InvalidOperationException();
\r
272 object ret = contents[current];
\r
277 // if we're down to capacity/4, go back to a
\r
278 // lower array size. this should keep us from
\r
279 // sucking down huge amounts of memory when
\r
280 // putting large numbers of items in the Stack.
\r
281 // if we're lower than 16, don't bother, since
\r
282 // it will be more trouble than it's worth.
\r
283 if (count <= (capacity/4) && count > 16) {
\r
284 Resize(capacity/2);
\r
291 public virtual void Push(Object o) {
\r
294 if (capacity == count) {
\r
295 Resize(capacity * 2);
\r
301 contents[current] = o;
\r
304 public virtual object[] ToArray() {
\r
305 object[] ret = new object[count];
\r
307 Array.Copy(contents, ret, count);
\r
309 // ret needs to be in LIFO order
\r
310 Array.Reverse(ret);
\r