scala.collection.mutable
trait StackProxy

[source: `scala/collection/mutable/StackProxy.scala`]

`` `trait` StackProxy[A]
  `extends` Stack[A]`with` SeqProxy[A]

  A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.

Author
  Matthias Zenger
Version
  1.0, 10/05/2004

Values and Variables inherited from MutableList
first0, last0, len

Method Summary
`override def` | ++= (iter : Iterable[A]) : Unit Pushes all elements provided by an `Iterable` object on top of the stack. The elements are pushed in the order they are given out by the iterator.
`override def` | ++= (it : Iterator[A]) : Unit Pushes all elements provided by an iterator on top of the stack. The elements are pushed in the order they are given out by the iterator.
`override def` | += (elem : A) : Unit Pushes a single element on top of the stack.
`override def` | apply (n : Int) : A Access element number `n`.
`override def` | clear : Unit Removes all elements from the stack. After this operation completed, the stack will be empty.
`override def` | clone : Stack[A] This method clones the stack.
`override def` | elements : Iterator[A] Returns an iterator over all elements on the stack. This iterator is stable with respect to state changes in the stack object; i.e. such changes will not be reflected in the iterator. The iterator issues elements in the order they were inserted into the stack (FIFO order).
`override def` | isEmpty : Boolean Checks if the stack is empty.
`override def` | length : Int Returns the length of this stack.
`override def` | pop : A Removes the top element from the stack.
`override def` | push (elems : A*) : Unit Pushes a sequence of elements on top of the stack. The first element is pushed first, etc.
`abstract def` | self : Stack[A]
`override def` | toList : List[A] Creates a list of all stack elements in FIFO order.
`override def` | top : A Returns the top element of the stack. This method will not remove the element from the stack. An error is signaled if there is no element on the stack.

Methods inherited from SeqProxy
concat, isDefinedAt, lastIndexOf, map, flatMap, filter, take, drop, takeWhile, dropWhile, reverse, contains, slice, toArray, copyToArray

Methods inherited from IterableProxy
foreach, forall, exists, find, findIndexOf, indexOf, foldLeft, foldRight, /:, :\, reduceLeft, reduceRight, sameElements, copyToBuffer, mkString, addString

Methods inherited from Proxy
hashCode, equals, toString

Methods inherited from Stack
stringPrefix

Methods inherited from MutableList
get, prependElem, appendElem, reset, last

Methods inherited from Seq
lengthCompare, size, lastOption, headOption, ++, subseq, projection, equalsWith, startsWith, endsWith, indexOf, containsSlice

Methods inherited from Iterable
toStream, mkString, mkString, addString, hasDefiniteSize

Methods inherited from PartialFunction
orElse, andThen

Methods inherited from Function1
compose

Methods inherited from AnyRef
getClass, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf

Method Details

`abstract` `def` self : Stack[A]

Overrides
  SeqProxy.self

`override` `def` apply(n : Int) : A

  Access element number `n`.

Returns
  the element at index `n`.

Overrides
  SeqProxy.apply

`override` `def` length : Int

  Returns the length of this stack.

Overrides
  SeqProxy.length

`override` `def` isEmpty : Boolean

  Checks if the stack is empty.

Returns
  true, iff there is no element on the stack

Overrides
  Stack.isEmpty, SeqProxy.isEmpty

`override` `def` +=(elem : A) : Unit

  Pushes a single element on top of the stack.

Parameters
  `elem -` the element to push onto the stack

Overrides
  Stack.+=

`override` `def` ++=(iter : Iterable[A]) : Unit

  Pushes all elements provided by an `Iterable` object on top of the stack. The elements are pushed in the order they are given out by the iterator.

Parameters
  `iter -` an iterable object

Overrides
  Stack.++=

`override` `def` ++=(it : Iterator[A]) : Unit

  Pushes all elements provided by an iterator on top of the stack. The elements are pushed in the order they are given out by the iterator.

Parameters
  `iter -` an iterator

Overrides
  Stack.++=

`override` `def` push(elems : A*) : Unit

  Pushes a sequence of elements on top of the stack. The first element is pushed first, etc.

Parameters
  `elems -` a sequence of elements

Overrides
  Stack.push

`override` `def` top : A

  Returns the top element of the stack. This method will not remove the element from the stack. An error is signaled if there is no element on the stack.

Returns
  the top element

Overrides
  Stack.top

`override` `def` pop : A

  Removes the top element from the stack.

Overrides
  Stack.pop

`override` `def` clear : Unit

  Removes all elements from the stack. After this operation completed, the stack will be empty.

Overrides
  Stack.clear

`override` `def` elements : Iterator[A]

  Returns an iterator over all elements on the stack. This iterator is stable with respect to state changes in the stack object; i.e. such changes will not be reflected in the iterator. The iterator issues elements in the order they were inserted into the stack (FIFO order).

Returns
  an iterator over all stack elements.

Overrides
  Stack.elements

`override` `def` toList : List[A]

  Creates a list of all stack elements in FIFO order.

Returns
  the created list.

Overrides
  Stack.toList

`override` `def` clone : Stack[A]

  This method clones the stack.

Returns
  a stack with the same elements.

Overrides
  Stack.clone