TreeIterable

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: xml.PullType](that: ⇒ GenTraversableOnce[B]): Iterator[B]

def /:[B](z: B)(op: (B, xml.PullType) ⇒ B): B

def :\[B](z: B)(op: (xml.PullType, B) ⇒ B): B

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object End extends State with Product with Serializable

object EndElemS extends State with Product with Serializable

object OnItem extends State with Product with Serializable

object StartElem extends State with Product with Serializable

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, xml.PullType) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def buffered: BufferedIterator[xml.PullType]

final def canDoNext: Boolean

def clone(): AnyRef

def collect[B](pf: PartialFunction[xml.PullType, B]): Iterator[B]

def collectFirst[B](pf: PartialFunction[xml.PullType, B]): Option[B]

def contains(elem: Any): Boolean

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

def copyToArray[B >: xml.PullType](xs: Array[B]): Unit

def copyToArray[B >: xml.PullType](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: xml.PullType](dest: Buffer[B]): Unit

def corresponds[B](that: GenTraversableOnce[B])(p: (xml.PullType, B) ⇒ Boolean): Boolean

def count(p: (xml.PullType) ⇒ Boolean): Int

def doNext(ev: xml.PullType): (State, xml.PullType)

def drop(n: Int): Iterator[xml.PullType]

def dropWhile(p: (xml.PullType) ⇒ Boolean): Iterator[xml.PullType]

def duplicate: (Iterator[xml.PullType], Iterator[xml.PullType])

def end: xml.PullType

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def event: xml.PullType

def exists(p: (xml.PullType) ⇒ Boolean): Boolean

def filter(p: (xml.PullType) ⇒ Boolean): Iterator[xml.PullType]

def filterNot(p: (xml.PullType) ⇒ Boolean): Iterator[xml.PullType]

def finalize(): Unit

def find(p: (xml.PullType) ⇒ Boolean): Option[xml.PullType]

def flatMap[B](f: (xml.PullType) ⇒ GenTraversableOnce[B]): Iterator[B]

def fold[A1 >: xml.PullType](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, xml.PullType) ⇒ B): B

def foldRight[B](z: B)(op: (xml.PullType, B) ⇒ B): B

def forall(p: (xml.PullType) ⇒ Boolean): Boolean

def foreach[U](f: (xml.PullType) ⇒ U): Unit

final def getClass(): Class[_]

def grouped[B >: xml.PullType](size: Int): GroupedIterator[B]

def hasDefiniteSize: Boolean

def hasNext: Boolean

def hashCode(): Int

def indexOf[B >: xml.PullType](elem: B): Int

def indexWhere(p: (xml.PullType) ⇒ Boolean): Int

lazy val initialPath: Path[XmlItem, Elem, xml.XCC]

def isEmpty: Boolean

val isForward: Boolean

final def isInstanceOf[T0]: Boolean

def isTraversableAgain: Boolean

def length: Int

def map[B](f: (xml.PullType) ⇒ B): Iterator[B]

def max[B >: xml.PullType](implicit cmp: Ordering[B]): xml.PullType

def maxBy[B](f: (xml.PullType) ⇒ B)(implicit cmp: Ordering[B]): xml.PullType

def min[B >: xml.PullType](implicit cmp: Ordering[B]): xml.PullType

def minBy[B](f: (xml.PullType) ⇒ B)(implicit cmp: Ordering[B]): xml.PullType

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(): xml.PullType

var nextState: State

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def padTo[A1 >: xml.PullType](len: Int, elem: A1): Iterator[A1]

def partition(p: (xml.PullType) ⇒ Boolean): (Iterator[xml.PullType], Iterator[xml.PullType])

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

var path: Path[XmlItem, Elem, xml.XCC]

def prepareNext: Unit

called after nextState.

def product[B >: xml.PullType](implicit num: Numeric[B]): B

def reduce[A1 >: xml.PullType](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: xml.PullType](op: (B, xml.PullType) ⇒ B): B

def reduceLeftOption[B >: xml.PullType](op: (B, xml.PullType) ⇒ B): Option[B]

def reduceOption[A1 >: xml.PullType](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: xml.PullType](op: (xml.PullType, B) ⇒ B): B

def reduceRightOption[B >: xml.PullType](op: (xml.PullType, B) ⇒ B): Option[B]

def reversed: List[xml.PullType]

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

def scanLeft[B](z: B)(op: (B, xml.PullType) ⇒ B): Iterator[B]

def scanRight[B](z: B)(op: (xml.PullType, B) ⇒ B): Iterator[B]

def seq: Iterator[xml.PullType]

def size: Int

def slice(from: Int, until: Int): Iterator[xml.PullType]

def sliding[B >: xml.PullType](size: Int, step: Int): GroupedIterator[B]

def span(p: (xml.PullType) ⇒ Boolean): (Iterator[xml.PullType], Iterator[xml.PullType])

def sum[B >: xml.PullType](implicit num: Numeric[B]): B

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

def take(n: Int): Iterator[xml.PullType]

def takeWhile(p: (xml.PullType) ⇒ Boolean): Iterator[xml.PullType]

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, xml.PullType, Col[xml.PullType]]): Col[xml.PullType]

def toArray[B >: xml.PullType](implicit arg0: ClassTag[B]): Array[B]

def toBuffer[B >: xml.PullType]: Buffer[B]

def toIndexedSeq: IndexedSeq[xml.PullType]

def toIterable: Iterable[xml.PullType]

def toIterator: Iterator[xml.PullType]

def toList: List[xml.PullType]

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

def toSeq: Seq[xml.PullType]

def toSet[B >: xml.PullType]: Set[B]

def toStream: Stream[xml.PullType]

def toString(): String

def toTraversable: Traversable[xml.PullType]

def toVector: Vector[xml.PullType]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (xml.PullType) ⇒ Boolean): Iterator[xml.PullType]

def zip[B](that: Iterator[B]): Iterator[(xml.PullType, B)]

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

def zipWithIndex: Iterator[(xml.PullType, Int)]

def /:\[A1 >: xml.PullType](z: A1)(op: (A1, A1) ⇒ A1): A1