AttributeAxis

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

abstract def empty: Iterable[xml.XmlPath]

implicit abstract val helper: BuilderHelper[xml.XmlPath, T]

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 *:@(local: String): AttributePaths[T]

Only matches local name

def *@(qname: UnprefixedQName): AttributePaths[T]

Loose match for UnprefixedQNames only, only matches local and namespace

def *@(attrQName: xml.AttributeQName): AttributePaths[T]

Special case for AttributeQNames, only local and namespace match

def *@(pred: (AttributePath) ⇒ Boolean): AttributePaths[T]

Search for all immediate attributes with a matching predicate (allows localName only searches for example)

def *@: AttributePaths[T]

All immediate attributes

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 \*:@(local: String): AttributePaths[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 \@(qname: UnprefixedQName): AttributePaths[T]

Loose match for UnprefixedQNames only, only matches local and namespace

def \@(attrQName: xml.AttributeQName): AttributePaths[T]

Special case for AttributeQNames, only local and namespace match

def \@(pred: (AttributePath) ⇒ Boolean): AttributePaths[T]

def \@: AttributePaths[T]

def \\: XPath[T]

All descendants, uses XPathInfo eager to choose an implementation

def \\@(qname: UnprefixedQName): AttributePaths[T]

Loose match for UnprefixedQNames only, only matches local and namespace

def \\@(attrQName: xml.AttributeQName): AttributePaths[T]

Special case for AttributeQNames, only local and namespace match

def \\@(pred: (AttributePath) ⇒ Boolean): AttributePaths[T]

def \\@: AttributePaths[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

def i_*@: Iterable[AttributePath]

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]