CommitIterator

Instance Constructors

new CommitIterator(finalColumns: Array[String], repo: Repository, prevIter: ReferenceIterator, filters: Seq[CompiledFilter])

finalColumns
final columns that must be in the resultant row
repo
repository to get the data from
prevIter
previous iterator, if the iterator is chained
filters
filters for the iterator

Type Members

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

Definition Classes
Iterator
type RawRow = Map[String, Any]

Raw values of the row.
Raw values of the row.

Definition Classes
ChainableIterator

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
Iterator
def /:[B](z: B)(op: (B, Row) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: (Row, 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, Row) ⇒ B, combop: (B, B) ⇒ B): B

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

Definition Classes
Any
def buffered: BufferedIterator[Row]

Definition Classes
Iterator
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B](pf: PartialFunction[Row, 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[Row, B]): Option[B]

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

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

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

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

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

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

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

Definition Classes
TraversableOnce → GenTraversableOnce
def drop(n: Int): Iterator[Row]

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

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

Definition Classes
Iterator
final def eq(arg0: AnyRef): Boolean

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

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

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

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

Definition Classes
Iterator
def finalize(): Unit

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

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

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

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

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

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

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

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

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

Definition Classes
Iterator
def hasDefiniteSize: Boolean

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
final def hasNext: Boolean

<invalid inheritdoc annotation>
<invalid inheritdoc annotation>

Definition Classes
ChainableIterator → Iterator
Annotations
@tailrec()
def hashCode(): Int

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

Definition Classes
Iterator
def indexWhere(p: (Row) ⇒ 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 loadIterator(filters: Seq[CompiledFilter]): Iterator[ReferenceWithCommit]

Returns the internal iterator that will return the data used to construct the final row.
Returns the internal iterator that will return the data used to construct the final row.
filters
filters for the iterator
returns
internal iterator

Attributes
protected
Definition Classes
CommitIterator → ChainableIterator
def map[B](f: (Row) ⇒ B): Iterator[B]

Definition Classes
Iterator
def mapColumns(obj: ReferenceWithCommit): RawRow

Given the object returned by the internal iterator, this method must transform that object into a RawRow.
Given the object returned by the internal iterator, this method must transform that object into a RawRow.
obj
object returned by the internal iterator
returns
raw row

Attributes
protected
Definition Classes
CommitIterator → ChainableIterator
def max[B >: Row](implicit cmp: Ordering[B]): Row

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

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

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

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(): Row

Definition Classes
ChainableIterator → Iterator
def nextRaw: RawRow

Definition Classes
ChainableIterator
def nonEmpty: Boolean

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

Definition Classes
AnyRef
final def notifyAll(): Unit

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

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

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

Definition Classes
Iterator
def product[B >: Row](implicit num: Numeric[B]): B

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

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

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

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

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

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

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

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

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

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

Definition Classes
Iterator
def seq: Iterator[Row]

Definition Classes
Iterator → TraversableOnce → GenTraversableOnce
def size: Int

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Definition Classes
Iterator → GenTraversableOnce
def toString(): String

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

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

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: (Row) ⇒ Boolean): Iterator[Row]

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

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

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

Definition Classes
Iterator

Related Docs: object CommitIterator | package iterator

class CommitIterator extends ChainableIterator[ReferenceWithCommit]

Instance Constructors

new CommitIterator(finalColumns: Array[String], repo: Repository, prevIter: ReferenceIterator, filters: Seq[CompiledFilter])

Type Members

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

type RawRow = Map[String, Any]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

def :\[B](z: B)(op: (Row, 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, Row) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def buffered: BufferedIterator[Row]

def clone(): AnyRef

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

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

def contains(elem: Any): Boolean

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

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

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

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

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

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

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

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

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

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

def finalize(): Unit

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

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

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

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

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

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

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

final def getClass(): Class[_]

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

def hasDefiniteSize: Boolean

final def hasNext: Boolean

def hashCode(): Int

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

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

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isTraversableAgain: Boolean

def length: Int

def loadIterator(filters: Seq[CompiledFilter]): Iterator[ReferenceWithCommit]

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

def mapColumns(obj: ReferenceWithCommit): RawRow

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

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

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

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

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(): Row

def nextRaw: RawRow

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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

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