ElementStep

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: Any): Boolean

final def ##(): Int

def *: XPath[T]

all child elements

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

Immediate child with position pos, should only be an element.

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

Search for all immediate child elements matching the predicate

def *(qname: QName): XPath[T]

Search for all immediate child elements with a matching qname

def *:*(local: String): XPath[T]

Search for all immediate child elements with a matching local name only

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]

def \*(pos: Int): XPath[T]

def \*(pred: (xml.XmlPath) ⇒ Boolean): XPath[T]

def \*(qname: QName): XPath[T]

def \*:*(local: String): XPath[T]

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 \\*(pos: Int): XPath[T]

def \\*(pred: (xml.XmlPath) ⇒ Boolean): XPath[T]

def \\*(qname: QName): XPath[T]

def \\*: XPath[T]

def \\*:*(local: String): XPath[T]

def \^: XPath[T]

Parents of these paths

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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 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]