com.twitter.finagle

Stack

Related Docs: object Stack | package finagle

sealed trait Stack[T] extends AnyRef

Stacks represent stackable elements of type T. It is assumed that T-typed elements can be stacked in some meaningful way; examples are functions (function composition) Filters (chaining), and ServiceFactories (through transformers). T-typed values are also meant to compose: the stack itself materializes into a T-typed value.

Stacks are persistent, allowing for nondestructive transformations; they are designed to represent 'template' stacks which can be configured in various ways before materializing the stack itself.

Note: Stacks are advanced and sometimes subtle. For expert use only!

Linear Supertypes
AnyRef, Any
Known Subclasses
Leaf, Node
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Stack
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Abstract Value Members

  1. 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

  2. abstract def make(params: Params): T

    Materialize the current stack with the given parameters, producing a T-typed value representing the current configuration.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Definition Classes
    AnyRef → Any

  3. 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.

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

    A copy of this Stack with stk prepended.

  5. final def ==(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  6. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  7. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  8. 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.++.

  9. def contains(role: Role): Boolean

    Returns whether the stack contains a given role or not.

  10. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  11. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  12. 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()

  13. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  14. 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()

  15. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  16. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  17. 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.

  18. 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.

  19. 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.

  20. 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.

  21. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  22. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  23. final def notify(): Unit

    Definition Classes
    AnyRef

  24. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  25. 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.+:.

  26. 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.

  27. 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.

  28. 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.

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

    Definition Classes
    AnyRef

  30. def tails: Iterator[Stack[T]]

    Enumerate each well-formed stack contained within this stack.

  31. def toString(): String

    Definition Classes
    Stack → AnyRef → Any

  32. 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.

  33. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  35. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped