Stack

Abstract Value Members

abstract val head: Head

The head field of the Stack composes all associated metadata of the topmost element of the stack.
The head field of the Stack composes all associated metadata of the topmost element of the stack.

Note
head does not give access to the value T, use make instead.
See also
Stack.Head

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(right: Stack[T]): Stack[T]

Produce a new stack representing the concatenation of this with right.
Produce a new stack representing the concatenation of this with right. Note that this replaces the terminating element of this.
def +:(stk: Stackable[T]): Stack[T]

A copy of this Stack with stk prepended.
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def concat(right: Stack[T]): Stack[T]

Produce a new stack representing the concatenation of this with right.
Produce a new stack representing the concatenation of this with right. Note that this replaces the terminating element of this.
Alias for Stack.++.
def contains(role: Role): Boolean

Returns whether the stack contains a given role or not.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def exists(pred: (Stack[T]) ⇒ Boolean): Boolean

Traverse the stack, until you find that pred has been evaluated to true.
Traverse the stack, until you find that pred has been evaluated to true. If pred finds an element, return true, otherwise, false.

Annotations
@tailrec()
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def foreach(fn: (Stack[T]) ⇒ Unit): Unit

Traverse the stack, invoking fn on each element.
Traverse the stack, invoking fn on each element.

Annotations
@tailrec()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def insertAfter[U](target: Role, insertion: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

Insert the given Stackable after the stack elements matching the argument role.
Insert the given Stackable after the stack elements matching the argument role. If no elements match the role, then an unmodified stack is returned. insertion must conform to typeclass CanStackFrom.
def insertAfter(target: Role, insertion: Stackable[T]): Stack[T]

Insert the given Stackable after the stack elements matching the argument role.
Insert the given Stackable after the stack elements matching the argument role. If no elements match the role, then an unmodified stack is returned.
def insertBefore[U](target: Role, insertion: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

Insert the given Stackable before the stack elements matching the argument role.
Insert the given Stackable before the stack elements matching the argument role. If no elements match the role, then an unmodified stack is returned. insertion must conform to typeclass CanStackFrom.
def insertBefore(target: Role, insertion: Stackable[T]): Stack[T]

Insert the given Stackable before the stack elements matching the argument role.
Insert the given Stackable before the stack elements matching the argument role. If no elements match the role, then an unmodified stack is returned.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def make(params: Params): T

Materialize the current stack with the given parameters, producing a T-typed value representing the current configuration.
def map(fn: (Head, T) ⇒ T): Stack[T]

Transform one stack to another by applying fn on each element.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def prepend[U](role: Role, element: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

A copy of this Stack with element prepended using the given Stack.Role.
def prepend(stk: Stackable[T]): Stack[T]

A copy of this Stack with stk prepended.
A copy of this Stack with stk prepended.
An alias for Stack.+:.
def remove(target: Role): Stack[T]

Remove all nodes in the stack that match the target role.
Remove all nodes in the stack that match the target role. Leaf nodes are not removable.
def replace[U](target: Role, replacement: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

Replace any stack elements matching the argument role with a given Stackable.
Replace any stack elements matching the argument role with a given Stackable. If no elements match the role, then an unmodified stack is returned. replacement must conform to typeclass CanStackFrom.
def replace(target: Role, replacement: Stackable[T]): Stack[T]

Replace any stack elements matching the argument role with a given Stackable.
Replace any stack elements matching the argument role with a given Stackable. If no elements match the role, then an unmodified stack is returned.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tails: Iterator[Stack[T]]

Enumerate each well-formed stack contained within this stack.
def toString(): String

Definition Classes
Stack → AnyRef → Any
def transform(fn: (Stack[T]) ⇒ Stack[T]): Stack[T]

Transform one stack to another by applying fn on each element; the map traverses on the element produced by fn, not the original stack.
Transform one stack to another by applying fn on each element; the map traverses on the element produced by fn, not the original stack. Prefer using map over transform.

Attributes
protected
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object Stack | package finagle

sealed trait Stack[T] extends AnyRef

Abstract Value Members

abstract val head: Head

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(right: Stack[T]): Stack[T]

def +:(stk: Stackable[T]): Stack[T]

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def concat(right: Stack[T]): Stack[T]

def contains(role: Role): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def exists(pred: (Stack[T]) ⇒ Boolean): Boolean

def finalize(): Unit

final def foreach(fn: (Stack[T]) ⇒ Unit): Unit

final def getClass(): Class[_]

def hashCode(): Int

def insertAfter[U](target: Role, insertion: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

def insertAfter(target: Role, insertion: Stackable[T]): Stack[T]

def insertBefore[U](target: Role, insertion: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

def insertBefore(target: Role, insertion: Stackable[T]): Stack[T]

final def isInstanceOf[T0]: Boolean

def make(params: Params): T

def map(fn: (Head, T) ⇒ T): Stack[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prepend[U](role: Role, element: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

def prepend(stk: Stackable[T]): Stack[T]

def remove(target: Role): Stack[T]

def replace[U](target: Role, replacement: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

def replace(target: Role, replacement: Stackable[T]): Stack[T]

final def synchronized[T0](arg0: ⇒ T0): T0

def tails: Iterator[Stack[T]]

def toString(): String

def transform(fn: (Stack[T]) ⇒ Stack[T]): Stack[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped