DocumentSplitters

abstract val cbf: CanBuildFrom[T, xml.XmlPath, T]

abstract def empty: Iterable[xml.XmlPath]

abstract def just(only: xml.XmlPath): Iterable[xml.XmlPath]

abstract def newThis(xpathInfo: XPathInfo): XPath[T]

abstract val path: XPathInfo

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def ===(textValue: ⇒ String): XPath[T]

simple test for string equality

def \: XPath[T]

simply forwards the current context, element\item specific versions exist that step downwards in document order

def \+: XPath[T]

all children unpacked, normal xpath requires the context in E1/E2, which hugely complicates things, so \ is this, \+ is \ in the case where unpacking is needed which just leaves \* varieties for elements.

def \\: XPath[T]

All descendants, uses XPathInfo eager to choose an implementation

def \^: XPath[T]

Parents of these paths

def ancestor_::: XPath[T]

All parents of this node

def ancestor_or_self_::: XPath[T]

All parents of this node or this node

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def descendant_::: XPath[T]

As per spec all children of a context but predicates work directly on these children.

def descendant_or_self_::: XPath[T]

All descendants of this node or self

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def filter(pred: (xml.XmlPath) ⇒ Boolean): XPath[T]

filter through the current matches

def finalize(): Unit

def following_::: XPath[T]

All nodes following this given node, in document order, excluding descendants

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def last_<(n: ⇒ Int): XPath[T]

Equivalent to [last() < n]

def last_==(n: ⇒ Int): XPath[T]

Equivalent to [last() = n]

def last_>(n: ⇒ Int): XPath[T]

Equivalent to [last() > n]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pos(pos: ⇒ Int): XPath[T]

1 index based, per spec, but unsure if it should be

def pos_<(pos: ⇒ Int): XPath[T]

Equivalent to [position() < pos]

def pos_==(p: ⇒ Int): XPath[T]

def pos_>(pos: ⇒ Int): XPath[T]

Equivalent to [position() > pos]

def pos_eq_last: XPath[T]

Equivalent to position() = last()

def preceding_::: XPath[T]

All nodes preceding this given context, in reverse document order, excluding parents

def process(newNodes: Iterable[Iterable[xml.XmlPath]], info: XPathInfo = path): XPath[T]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def xfilter(f: (Iterable[xml.XmlPath]) ⇒ Boolean): XPath[T]

final def xflatMap(f: (Iterable[xml.XmlPath]) ⇒ Iterable[Iterable[xml.XmlPath]]): XPath[T]

x prefixed to avoid disturbing the use of an xpath as an iterable

final def xlast(onN: (Int) ⇒ Boolean): XPath[T]

final def xmap(f: (Iterable[xml.XmlPath]) ⇒ Iterable[xml.XmlPath]): XPath[T]