class
ExceptionGuardedIterator[T] extends Iterator[T]
Instance Constructors
-
new
ExceptionGuardedIterator(it: Iterator[T], exceptionHandler: (Throwable) ⇒ Unit)
Type Members
-
Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
-
def
/:[B](z: B)(op: (B, T) ⇒ B): B
-
def
:\[B](z: B)(op: (T, 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, T) ⇒ B, combop: (B, B) ⇒ B): B
-
final
def
asInstanceOf[T0]: T0
-
def
buffered: BufferedIterator[T]
-
def
clone(): AnyRef
-
-
-
def
contains(elem: Any): Boolean
-
def
copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Unit
-
def
copyToArray[B >: T](xs: Array[B]): Unit
-
def
copyToArray[B >: T](xs: Array[B], start: Int): Unit
-
def
copyToBuffer[B >: T](dest: Buffer[B]): Unit
-
-
def
count(p: (T) ⇒ Boolean): Int
-
-
-
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
-
-
-
def
finalize(): Unit
-
-
-
def
fold[A1 >: T](z: A1)(op: (A1, A1) ⇒ A1): A1
-
def
foldLeft[B](z: B)(op: (B, T) ⇒ B): B
-
def
foldRight[B](z: B)(op: (T, B) ⇒ B): B
-
-
def
foreach[U](f: (T) ⇒ U): Unit
-
final
def
getClass(): Class[_]
-
-
def
hasDefiniteSize: Boolean
-
-
def
hashCode(): Int
-
def
indexOf[B >: T](elem: B): Int
-
def
indexWhere(p: (T) ⇒ Boolean): Int
-
-
final
def
isInstanceOf[T0]: Boolean
-
def
isTraversableAgain: Boolean
-
def
length: Int
-
def
map[B](f: (T) ⇒ B): Iterator[B]
-
def
max[B >: T](implicit cmp: Ordering[B]): T
-
def
maxBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T
-
def
min[B >: T](implicit cmp: Ordering[B]): T
-
def
minBy[B](f: (T) ⇒ B)(implicit cmp: Ordering[B]): T
-
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(): T
-
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
padTo[A1 >: T](len: Int, elem: A1): Iterator[A1]
-
-
def
patch[B >: T](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]
-
def
product[B >: T](implicit num: Numeric[B]): B
-
def
reduce[A1 >: T](op: (A1, A1) ⇒ A1): A1
-
def
reduceLeft[B >: T](op: (B, T) ⇒ B): B
-
def
reduceLeftOption[B >: T](op: (B, T) ⇒ B): Option[B]
-
def
reduceOption[A1 >: T](op: (A1, A1) ⇒ A1): Option[A1]
-
def
reduceRight[B >: T](op: (T, B) ⇒ B): B
-
def
reduceRightOption[B >: T](op: (T, B) ⇒ B): Option[B]
-
def
reversed: List[T]
-
-
def
scanLeft[B](z: B)(op: (B, T) ⇒ B): Iterator[B]
-
def
scanRight[B](z: B)(op: (T, B) ⇒ B): Iterator[B]
-
-
def
size: Int
-
def
slice(from: Int, until: Int): Iterator[T]
-
-
-
def
sum[B >: T](implicit num: Numeric[B]): B
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
-
-
def
to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T]]): Col[T]
-
def
toArray[B >: T](implicit arg0: ClassTag[B]): Array[B]
-
def
toBuffer[B >: T]: Buffer[B]
-
def
toIndexedSeq: IndexedSeq[T]
-
def
toIterable: Iterable[T]
-
def
toIterator: Iterator[T]
-
def
toList: List[T]
-
def
toMap[T, U](implicit ev: <:<[T, (T, U)]): Map[T, U]
-
def
toSeq: Seq[T]
-
def
toSet[B >: T]: Set[B]
-
def
toStream: Stream[T]
-
def
toString(): String
-
-
def
toVector: Vector[T]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
-
-
def
zipAll[B, A1 >: T, B1 >: B](that: Iterator[B], thisElem: A1, thatElem: B1): Iterator[(A1, B1)]
-
def
zipWithIndex: Iterator[(T, Int)]
Inherited from AnyRef
Inherited from Any
An Iterator that wraps another Iterator with protection for exceptions during iteration. If an exception occurs while calling hasNext or next, the provided exception handler will be called, and the ExceptionGuardedIterator will act as if it is now empty.
Construction using the companion object will also handle exceptions produced when getting the initial wrapped Iterator.