Skip to content
This repository
Fetching contributors…

Octocat-spinner-32-eaf2f5

Cannot retrieve contributors at this time

file 68 lines (60 sloc) 2.49 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */


package scala.collection

import generic._
import mutable.ListBuffer
import immutable.List
import scala.util.control.Breaks._

/** A template trait for linear sequences of type `LinearSeq[A]`.
*
* $linearSeqInfo
*
* This trait just implements `iterator` in terms of `isEmpty, ``head`, and `tail`.
* However, see `LinearSeqOptimized` for an implementation trait that overrides operations
* to make them run faster under the assumption of fast linear access with `head` and `tail`.
*
* @define linearSeqInfo
* Linear sequences are defined in terms of three abstract methods, which are assumed
* to have efficient implementations. These are:
* {{{
* def isEmpty: Boolean
* def head: A
* def tail: Repr
* }}}
* Here, `A` is the type of the sequence elements and `Repr` is the type of the sequence itself.
*
* Linear sequences do not add any new methods to `Seq`, but promise efficient implementations
* of linear access patterns.
* @author Martin Odersky
* @version 2.8
* @since 2.8
*
* @tparam A the element type of the $coll
* @tparam Repr the type of the actual $coll containing the elements.
*/
trait LinearSeqLike[+A, +Repr <: LinearSeqLike[A, Repr]] extends SeqLike[A, Repr] { self: Repr =>

  override protected[this] def thisCollection: LinearSeq[A] = this.asInstanceOf[LinearSeq[A]]
  override protected[this] def toCollection(repr: Repr): LinearSeq[A] = repr.asInstanceOf[LinearSeq[A]]

  override /*IterableLike*/
  def iterator: Iterator[A] = new Iterator[A] {
    var these = self
    def hasNext: Boolean = !these.isEmpty
    def next: A =
      if (hasNext) {
        val result = these.head; these = these.tail; result
      } else Iterator.empty.next

    /** Have to clear `these` so the iterator is exhausted like
* it would be without the optimization.
*/
    override def toList: List[A] = {
      val xs = these.toList
      these = newBuilder.result
      xs
    }
  }
}
Something went wrong with that request. Please try again.