/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2009, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala.collection.mutable
import scala.collection.generic._
private object Utils {
def growArray(x: Array[AnyRef]) = {
val y = new Array[AnyRef](x.length * 2)
Array.copy(x, 0, y, 0, x.length)
y
}
def clone(x: Array[AnyRef]) = {
val y = new Array[AnyRef](x.length)
Array.copy(x, 0, y, 0, x.length)
y
}
}
/**
* Simple stack class backed by an array. Should be significantly faster
* than the standard mutable stack.
*
* @author David MacIver
*/
@cloneable
class ArrayStack[T] private(private var table : Array[AnyRef],
private var index : Int) extends collection.Sequence[T] with Cloneable[ArrayStack[T]] {
def this() = this(new Array[AnyRef](1), 0)
/** Retrieve n'th element from stack, where top of stack has index 0 */
def apply(n: Int): T =
table(index - 1 - n).asInstanceOf[T]
/** The number of elements in the stack */
def length = index
/**
* Push an element onto the stack.
*
* @param x The element to push
*/
def push(x: T) {
if (index == table.length) table = Utils.growArray(table)
table(index) = x.asInstanceOf[AnyRef]
index += 1
}
/**
* Pop the top element off the stack.
*/
def pop: T = {
if (index == 0) error("Stack empty")
index -= 1
val x = table(index).asInstanceOf[T]
table(index) = null
x
}
/** View the top element of the stack. */
@deprecated("use top instead")
def peek = top
/**
* View the top element of the stack.
*/
def top: T = table(index - 1).asInstanceOf[T]
/**
* Duplicate the top element of the stack.
*/
def dup = push(top)
/**
* Empties the stack.
*/
def clear {
index = 0
table = new Array(1)
}
/**
* Empties the stack, passing all elements on it in FIFO order to the
* provided function.
*
* @param f The function to drain to.
*/
def drain(f: T => Unit) = while (!isEmpty) f(pop)
/**
* Pushes all the provided elements onto the stack.
*
* @param x The source of elements to push
*/
def ++=(x: collection.Iterable[T]): this.type = { x.foreach(this +=(_)); this }
/**
* Pushes all the provided elements onto the stack.
*
* @param x The source of elements to push
*/
def ++=(x: Iterator[T]): this.type = { x.foreach(this +=(_)); this }
/**
* Alias for push.
*
* @param x The element to push
*/
def +=(x: T): this.type = { push(x); this }
/**
* Pop the top two elements off the stack, apply f to them and push the result
* back on to the stack.
*
* @param f The combining function
*/
def combine(f: (T, T) => T) = push(f(pop, pop));
/**
* Repeatedly combine the top elements of the stack until the stack contains only
* one element.
*/
def reduceWith(f: (T, T) => T) = while(size > 1) combine(f)
override def size = index
/**
* Evaluates the expression, preserving the contents of the stack so that
* any changes the evaluation makes to the stack contents will be undone after
* it completes.
*
* @param action The action to run.
*/
def preserving[T](action: => T) = {
val oldIndex = index
val oldTable = Utils.clone(table)
try {
action
} finally {
index = oldIndex
table = oldTable
}
}
override def isEmpty: Boolean = index == 0
/**
* Iterates over the stack in LIFO order.
*/
def iterator: Iterator[T] = new Iterator[T] {
var currentIndex = index
def hasNext = currentIndex > 0
def next = {
currentIndex -= 1
table(currentIndex).asInstanceOf[T]
}
}
override def foreach[U](f: T => U) {
var currentIndex = index
while (currentIndex > 0) {
currentIndex -= 1
f(table(currentIndex).asInstanceOf[T])
}
}
override def clone = new ArrayStack[T](Utils.clone(table), index)
}