Result

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

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

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

def /:\ [A1 >: RowLike] (z: A1)(op: (A1, A1) ⇒ A1): A1

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

def == (arg0: AnyRef): Boolean

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, RowLike) ⇒ B, combop: (B, B) ⇒ B): B

def apply (columnLabel: String): Any

def apply (columnIndex: Int): Any

def apply [T] (name: String, conv: (Any) ⇒ T): T

def asInstanceOf [T0] : T0

def bigdecimal (columnLabel: String): BigDecimal

def bigdecimal (columnIndex: Int): BigDecimal

def buffered : BufferedIterator[RowLike]

def clone (): AnyRef

def close : Unit

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

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

def column (idx: Int): Column

def columnCount : Int

def contains (elem: Any): Boolean

def content : Vector[Any]

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

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

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

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

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

def date (columnLabel: String): Date

def date (columnIndex: Int): Date

def double (columnLabel: String): Double

def double (columnIndex: Int): Double

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

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

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

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

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

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

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

def finalize (): Unit

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

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

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

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

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

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

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

def getClass (): java.lang.Class[_]

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

def hasDefiniteSize : Boolean

def hasNext : Boolean

calls jdbc result set next method.

def hashCode (): Int

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

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

def int (columnLabel: String): Int

def int (columnIndex: Int): Int

def isEmpty : Boolean

def isInstanceOf [T0] : Boolean

def isTraversableAgain : Boolean

def jdbcResult : ResultSet

def length : Int

def long (columnLabel: String): Long

def long (columnIndex: Int): Long

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

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

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

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

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

def mkString : String

def mkString (sep: String): String

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

def ne (arg0: AnyRef): Boolean

def next (): Result

def nonEmpty : Boolean

def notify (): Unit

def notifyAll (): Unit

def padTo [A1 >: RowLike] (len: Int, elem: A1): Iterator[A1]

def partition (p: (RowLike) ⇒ Boolean): (Iterator[RowLike], Iterator[RowLike])

def patch [B >: RowLike] (from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]

def product [B >: RowLike] (implicit num: Numeric[B]): B

def reduce [A1 >: RowLike] (op: (A1, A1) ⇒ A1): A1

def reduceLeft [B >: RowLike] (op: (B, RowLike) ⇒ B): B

def reduceLeftOption [B >: RowLike] (op: (B, RowLike) ⇒ B): Option[B]

def reduceOption [A1 >: RowLike] (op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight [B >: RowLike] (op: (RowLike, B) ⇒ B): B

def reduceRightOption [B >: RowLike] (op: (RowLike, B) ⇒ B): Option[B]

def reversed : List[RowLike]

def sameElements (that: Iterator[_]): Boolean

def scanLeft [B] (z: B)(op: (B, RowLike) ⇒ B): Iterator[B]

def scanRight [B] (z: B)(op: (RowLike, B) ⇒ B): Iterator[B]

def seq : Iterator[RowLike]

def size : Int

def slice (from: Int, until: Int): Iterator[RowLike]

def sliding [B >: RowLike] (size: Int, step: Int): GroupedIterator[B]

def span (p: (RowLike) ⇒ Boolean): (Iterator[RowLike], Iterator[RowLike])

def string (columnLabel: String): String

def string (columnIndex: Int): String

def sum [B >: RowLike] (implicit num: Numeric[B]): B

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

def take (n: Int): Iterator[RowLike]

def takeWhile (p: (RowLike) ⇒ Boolean): Iterator[RowLike]

def timestamp (columnLabel: String): Timestamp

def timestamp (columnIndex: Int): Timestamp

def toArray [B >: RowLike] (implicit arg0: ClassManifest[B]): Array[B]

def toBuffer [B >: RowLike] : Buffer[B]

def toIndexedSeq [B >: RowLike] : IndexedSeq[B]

def toIterable : Iterable[RowLike]

def toIterator : Iterator[RowLike]

def toList : List[Row]

def toMap [T, U] (implicit ev: <:<[RowLike, (T, U)]): Map[T, U]

def toSeq : Seq[RowLike]

def toSet [B >: RowLike] : Set[B]

def toStream : Stream[RowLike]

def toString (): String

needs to be overriden since super class implementation calls hasNext method

def toTraversable : Traversable[RowLike]

def typed [T] (idx: Int, conv: (Any) ⇒ T): T

def wait (): Unit

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

def wait (arg0: Long): Unit

def withFilter (p: (RowLike) ⇒ Boolean): Iterator[RowLike]

def zip [B] (that: Iterator[B]): Iterator[(RowLike, B)]

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

def zipWithIndex : Iterator[(RowLike, Int)] { ... /* 2 definitions in type refinement */ }

def append [B >: RowLike] (that: Iterator[B]): Iterator[B]

def counted : CountedIterator[RowLike]

def findIndexOf (p: (RowLike) ⇒ Boolean): Int

def readInto [B >: RowLike] (xs: Array[B]): Unit

def readInto [B >: RowLike] (xs: Array[B], start: Int): Unit

def readInto [B >: RowLike] (xs: Array[B], start: Int, sz: Int): Unit