PositionedResultIterator

abstract def closeUnderlying(): Unit

abstract def extractValue(): T

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ++[B >: T](that: ⇒ GenTraversableOnce[B]): collection.Iterator[B]

def ->[B](y: B): (PositionedResultIterator[T], B)

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

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

final def <<[T](implicit f: GetResult[T]): T

final def <<?[T](implicit f: GetResult[Option[T]]): Option[T]

final def ==(arg0: AnyRef): Boolean

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: collection.BufferedIterator[T]

final def build[C[_], R](gr: GetResult[R])(implicit canBuildFrom: CanBuildFrom[Nothing, R, C[R]]): C[R]

def clone(): AnyRef

final def close(): Unit

Close the underlying data source.

def collect[B](pf: PartialFunction[T, B]): collection.Iterator[B]

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

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 corresponds[B](that: GenTraversableOnce[B])(p: (T, B) ⇒ Boolean): Boolean

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

final def currentPos: Int

def drop(n: Int): collection.Iterator[T]

def dropWhile(p: (T) ⇒ Boolean): collection.Iterator[T]

def duplicate: (collection.Iterator[T], collection.Iterator[T])

def ensuring(cond: (PositionedResultIterator[T]) ⇒ Boolean, msg: ⇒ Any): PositionedResultIterator[T]

def ensuring(cond: (PositionedResultIterator[T]) ⇒ Boolean): PositionedResultIterator[T]

def ensuring(cond: Boolean, msg: ⇒ Any): PositionedResultIterator[T]

def ensuring(cond: Boolean): PositionedResultIterator[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def filter(p: (T) ⇒ Boolean): collection.Iterator[T]

def filterNot(p: (T) ⇒ Boolean): collection.Iterator[T]

def finalize(): Unit

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

def flatMap[B](f: (T) ⇒ GenTraversableOnce[B]): collection.Iterator[B]

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 forall(p: (T) ⇒ Boolean): Boolean

final def foreach[U](f: (T) ⇒ U): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

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

def hasDefiniteSize: Boolean

final def hasMoreColumns: Boolean

final def hasNext: Boolean

def hashCode(): Int

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

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

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isTraversableAgain: Boolean

def length: Int

def map[B](f: (T) ⇒ B): CloseableIterator[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

final def next(): T

final def nextBigDecimal(): math.BigDecimal

final def nextBigDecimalOption(): Option[math.BigDecimal]

final def nextBlob(): Blob

final def nextBlobOption(): Option[Blob]

final def nextBoolean(): Boolean

final def nextBooleanOption(): Option[Boolean]

final def nextByte(): Byte

final def nextByteOption(): Option[Byte]

final def nextBytes(): Array[Byte]

final def nextBytesOption(): Option[Array[Byte]]

final def nextClob(): Clob

final def nextClobOption(): Option[Clob]

final def nextDate(): Date

final def nextDateOption(): Option[Date]

final def nextDouble(): Double

final def nextDoubleOption(): Option[Double]

final def nextFloat(): Float

final def nextFloatOption(): Option[Float]

final def nextInt(): Int

final def nextIntOption(): Option[Int]

final def nextLong(): Long

final def nextLongOption(): Option[Long]

final def nextObject(): AnyRef

final def nextObjectOption(): Option[AnyRef]

final def nextRow: Boolean

final def nextShort(): Short

final def nextShortOption(): Option[Short]

final def nextString(): String

final def nextStringOption(): Option[String]

final def nextTime(): Time

final def nextTimeOption(): Option[Time]

final def nextTimestamp(): Timestamp

final def nextTimestampOption(): Option[Timestamp]

final def noNext: Nothing

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val numColumns: Int

def padTo[A1 >: T](len: Int, elem: A1): collection.Iterator[A1]

def partition(p: (T) ⇒ Boolean): (collection.Iterator[T], collection.Iterator[T])

def patch[B >: T](from: Int, patchElems: collection.Iterator[B], replaced: Int): collection.Iterator[B]

var pos: Int

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]

final def restart: PositionedResult

def reversed: List[T]

final def rewind: PositionedResult

val rs: ResultSet

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

def scanLeft[B](z: B)(op: (B, T) ⇒ B): collection.Iterator[B]

def scanRight[B](z: B)(op: (T, B) ⇒ B): collection.Iterator[B]

def seq: collection.Iterator[T]

def size: Int

final def skip: PositionedResult

def slice(from: Int, until: Int): collection.Iterator[T]

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

def span(p: (T) ⇒ Boolean): (collection.Iterator[T], collection.Iterator[T])

val startPos: Int

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

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

def take(n: Int): collection.Iterator[T]

def takeWhile(p: (T) ⇒ Boolean): collection.Iterator[T]

final def thenClose(c: Closeable): CloseableIterator[T]

Return a new CloseableIterator which also closes the supplied Closeable object when itself gets closed.

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T]]): Col[T]

final def to[C[_]]: To[C]

def toArray[B >: T](implicit arg0: ClassTag[B]): Array[B]

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

def toIndexedSeq: collection.immutable.IndexedSeq[T]

def toIterable: collection.Iterable[T]

def toIterator: collection.Iterator[T]

def toList: List[T]

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

def toSeq: collection.Seq[T]

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

def toStream: collection.immutable.Stream[T]

def toString(): String

def toTraversable: collection.Traversable[T]

def toVector: Vector[T]

final def updateBigDecimal(v: BigDecimal): Unit

final def updateBigDecimalOption(v: Option[BigDecimal]): Unit

final def updateBlob(v: Blob): Unit

final def updateBlobOption(v: Option[Blob]): Unit

final def updateBoolean(v: Boolean): Unit

final def updateBooleanOption(v: Option[Boolean]): Unit

final def updateByte(v: Byte): Unit

final def updateByteOption(v: Option[Byte]): Unit

final def updateBytes(v: Array[Byte]): Unit

final def updateBytesOption(v: Option[Array[Byte]]): Unit

final def updateClob(v: Clob): Unit

final def updateClobOption(v: Option[Clob]): Unit

final def updateDate(v: Date): Unit

final def updateDateOption(v: Option[Date]): Unit

final def updateDouble(v: Double): Unit

final def updateDoubleOption(v: Option[Double]): Unit

final def updateFloat(v: Float): Unit

final def updateFloatOption(v: Option[Float]): Unit

final def updateInt(v: Int): Unit

final def updateIntOption(v: Option[Int]): Unit

final def updateLong(v: Long): Unit

final def updateLongOption(v: Option[Long]): Unit

final def updateNull(): Unit

final def updateObject(v: AnyRef): Unit

final def updateObjectOption(v: Option[AnyRef]): Unit

final def updateShort(v: Short): Unit

final def updateShortOption(v: Option[Short]): Unit

final def updateString(v: String): Unit

final def updateStringOption(v: Option[String]): Unit

final def updateTime(v: Time): Unit

final def updateTimeOption(v: Option[Time]): Unit

final def updateTimestamp(v: Timestamp): Unit

final def updateTimestampOption(v: Option[Timestamp]): Unit

final def use[R](f: ⇒ R): R

final def use[R](f: (Iterator[T]) ⇒ R): R

def view(discriminatorPos: Int, dataPos: Int, discriminator: (PositionedResult) ⇒ Boolean): PositionedResult

Create an embedded PositionedResult which extends from the given dataPos column until the end of this PositionedResult, starts at the current row and ends when the discriminator predicate (which can read columns starting at discriminatorPos) returns false or when this PositionedResult ends.

def view1: PositionedResult

Create an embedded PositionedResult with a single discriminator column followed by the embedded data, starting at the current position.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (T) ⇒ Boolean): collection.Iterator[T]

def zip[B](that: collection.Iterator[B]): collection.Iterator[(T, B)]

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

def zipWithIndex: collection.Iterator[(T, Int)]

def →[B](y: B): (PositionedResultIterator[T], B)

def filter(p: (T) ⇒ Boolean): collection.TraversableOnce[T]

def flatMap[B](f: (T) ⇒ GenTraversableOnce[B]): collection.TraversableOnce[B]

def map[B](f: (T) ⇒ B): collection.TraversableOnce[B]

val self: Any

val self: Any

def withFilter(p: (T) ⇒ Boolean): collection.Iterator[T]

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

def x: PositionedResultIterator[T]

def x: PositionedResultIterator[T]