PriorityQueueWithIterators

Instance Constructors

new PriorityQueueWithIterators()(implicit ord: Ordering[A])

Type Members

class GroupedIterator[B >: A] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]]

Definition Classes
Iterator

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def ++[B >: A](that: ⇒ GenTraversableOnce[B]): Iterator[B]

Definition Classes
Iterator
def ++=(it: Iterator[A]): Unit

Adds all elements provided by an iterator into the priority queue.
def ++=(it: Iterable[A]): Unit

Adds all elements provided by an iterable into the priority queue.
def +=(it: Iterator[A]): Unit

Inserts a sequence as a single element into the priority queue.
Inserts a sequence as a single element into the priority queue. The given iterator has to produce elements in descending order!
def +=(elem: A): Unit

Inserts a single element into the priority queue.
def /:[B](z: B)(op: (B, A) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: (A, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def asInstanceOf[T0]: T0

Definition Classes
Any
def buffered: BufferedIterator[A]

Definition Classes
Iterator
def clear(): Unit

Removes all elements from the queue.
Removes all elements from the queue. After this operation is completed, the queue will be empty.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B](pf: PartialFunction[A, B]): Iterator[B]

Definition Classes
Iterator
Annotations
@migration
Migration
(Changed in version 2.8.0) collect has changed. The previous behavior can be reproduced with toSeq.
def collectFirst[B](pf: PartialFunction[A, B]): Option[B]

Definition Classes
TraversableOnce
def contains(elem: Any): Boolean

Definition Classes
Iterator
def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def copyToArray[B >: A](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: A](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: A](dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def corresponds[B](that: GenTraversableOnce[B])(p: (A, B) ⇒ Boolean): Boolean

Definition Classes
Iterator
def count(p: (A) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
def dequeue: A

Returns the element with the highest priority in the queue, and removes this element from the queue.
Returns the element with the highest priority in the queue, and removes this element from the queue.
returns
the element with the highest priority.

Exceptions thrown
def drop(n: Int): Iterator[A]

Definition Classes
Iterator
def dropAll: Unit

Definition Classes
PeekIterator
def dropWhile(p: (A) ⇒ Boolean): Iterator[A]

Definition Classes
Iterator
def duplicate: (Iterator[A], Iterator[A])

Definition Classes
Iterator
def enqueue(it: Iterator[A]): Unit

Adds all elements to the queue.
Adds all elements to the queue. The given iterators have to produce elements in descending order!
def enqueue(elems: A*): Unit

Adds all elements to the queue.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def exists(p: (A) ⇒ Boolean): Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def filter(p: (A) ⇒ Boolean): Iterator[A]

Definition Classes
Iterator
def filterNot(p: (A) ⇒ Boolean): Iterator[A]

Definition Classes
Iterator
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (A) ⇒ Boolean): Option[A]

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Iterator[B]

Definition Classes
Iterator
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: (A, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def forall(p: (A) ⇒ Boolean): Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def foreach[U](f: (A) ⇒ U): Unit

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def grouped[B >: A](size: Int): GroupedIterator[B]

Definition Classes
Iterator
def hasDefiniteSize: Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def hasNext: Boolean

Definition Classes
PriorityQueueWithIterators → Iterator
def hashCode(): Int

Definition Classes
AnyRef → Any
def indexOf[B >: A](elem: B): Int

Definition Classes
Iterator
def indexWhere(p: (A) ⇒ Boolean): Int

Definition Classes
Iterator
def isEmpty: Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTraversableAgain: Boolean

Definition Classes
Iterator → GenTraversableOnce
def length: Int

Definition Classes
Iterator
def map[B](f: (A) ⇒ B): Iterator[B]

Definition Classes
Iterator
def max: A

Returns the element with the highest priority in the queue, or throws an error if there is no element contained in the queue.
Returns the element with the highest priority in the queue, or throws an error if there is no element contained in the queue.
returns
the element with the highest priority.
def max[B >: A](implicit cmp: Ordering[B]): A

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

Definition Classes
TraversableOnce → GenTraversableOnce
def min[B >: A](implicit cmp: Ordering[B]): A

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def next(): A

Definition Classes
PriorityQueueWithIterators → Iterator
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def padTo[A1 >: A](len: Int, elem: A1): Iterator[A1]

Definition Classes
Iterator
def partition(p: (A) ⇒ Boolean): (Iterator[A], Iterator[A])

Definition Classes
Iterator
def patch[B >: A](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]

Definition Classes
Iterator
def peekNext: A

Definition Classes
PriorityQueueWithIterators → PeekIterator
def product[B >: A](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: A](op: (B, A) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: A](op: (A, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reversed: List[A]

Attributes
protected[this]
Definition Classes
TraversableOnce
def sameElements(that: Iterator[_]): Boolean

Definition Classes
Iterator
def scanLeft[B](z: B)(op: (B, A) ⇒ B): Iterator[B]

Definition Classes
Iterator
def scanRight[B](z: B)(op: (A, B) ⇒ B): Iterator[B]

Definition Classes
Iterator
def seq: Iterator[A]

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def size: Int

Definition Classes
TraversableOnce → GenTraversableOnce
def slice(from: Int, until: Int): Iterator[A]

Definition Classes
Iterator
def sliding[B >: A](size: Int, step: Int): GroupedIterator[B]

Definition Classes
Iterator
def span(p: (A) ⇒ Boolean): (Iterator[A], Iterator[A])

Definition Classes
Iterator
def sum[B >: A](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(n: Int): Iterator[A]

Definition Classes
Iterator
def takeWhile(p: (A) ⇒ Boolean): Iterator[A]

Definition Classes
Iterator
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[B >: A]: Buffer[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIndexedSeq: IndexedSeq[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterator: Iterator[A]

Definition Classes
Iterator → GenTraversableOnce
def toList: List[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSeq: Seq[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSet[B >: A]: Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream: Stream[A]

Definition Classes
Iterator → GenTraversableOnce
def toString(): String

Definition Classes
Iterator → AnyRef → Any
def toTraversable: Traversable[A]

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def toVector: Vector[A]

Definition Classes
TraversableOnce → GenTraversableOnce
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( ... )
def withFilter(p: (A) ⇒ Boolean): Iterator[A]

Definition Classes
Iterator
def zip[B](that: Iterator[B]): Iterator[(A, B)]

Definition Classes
Iterator
def zipAll[B, A1 >: A, B1 >: B](that: Iterator[B], thisElem: A1, thatElem: B1): Iterator[(A1, B1)]

Definition Classes
Iterator
def zipWithIndex: Iterator[(A, Int)]

Definition Classes
Iterator

Related Doc: package util

class PriorityQueueWithIterators[A] extends PeekIterator[A]

Instance Constructors

new PriorityQueueWithIterators()(implicit ord: Ordering[A])

Type Members

class GroupedIterator[B >: A] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: A](that: ⇒ GenTraversableOnce[B]): Iterator[B]

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

def ++=(it: Iterable[A]): Unit

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

def +=(elem: A): Unit

def /:[B](z: B)(op: (B, A) ⇒ B): B

def :\[B](z: B)(op: (A, B) ⇒ B): B

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def buffered: BufferedIterator[A]

def clear(): Unit

def clone(): AnyRef

def collect[B](pf: PartialFunction[A, B]): Iterator[B]

def collectFirst[B](pf: PartialFunction[A, B]): Option[B]

def contains(elem: Any): Boolean

def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: A](xs: Array[B]): Unit

def copyToArray[B >: A](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

def corresponds[B](that: GenTraversableOnce[B])(p: (A, B) ⇒ Boolean): Boolean

def count(p: (A) ⇒ Boolean): Int

def dequeue: A

def drop(n: Int): Iterator[A]

def dropAll: Unit

def dropWhile(p: (A) ⇒ Boolean): Iterator[A]

def duplicate: (Iterator[A], Iterator[A])

def enqueue(it: Iterator[A]): Unit

def enqueue(elems: A*): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (A) ⇒ Boolean): Boolean

def filter(p: (A) ⇒ Boolean): Iterator[A]

def filterNot(p: (A) ⇒ Boolean): Iterator[A]

def finalize(): Unit

def find(p: (A) ⇒ Boolean): Option[A]

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Iterator[B]

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

def foldRight[B](z: B)(op: (A, B) ⇒ B): B

def forall(p: (A) ⇒ Boolean): Boolean

def foreach[U](f: (A) ⇒ U): Unit

final def getClass(): Class[_]

def grouped[B >: A](size: Int): GroupedIterator[B]

def hasDefiniteSize: Boolean

def hasNext: Boolean

def hashCode(): Int

def indexOf[B >: A](elem: B): Int

def indexWhere(p: (A) ⇒ Boolean): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isTraversableAgain: Boolean

def length: Int

def map[B](f: (A) ⇒ B): Iterator[B]

def max: A

def max[B >: A](implicit cmp: Ordering[B]): A

def maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

def min[B >: A](implicit cmp: Ordering[B]): A

def minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

final def ne(arg0: AnyRef): Boolean

def next(): A

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit