DirectXPath

Instance Constructors

new DirectXPath(path: XPathInfo, cbf: CanBuildFrom[PT, xml.XmlPath, PT])

Type Members

type T = PT

Definition Classes
XPath → Axis

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
def *: XPath[T]

all child elements
all child elements

Definition Classes
ElementStep
def *(pos: Int): XPath[T]

Immediate child with position pos, should only be an element.
Immediate child with position pos, should only be an element. NOTE this will always be evaluated in place and is 1 indexed

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

Search for all immediate child elements matching the predicate
Search for all immediate child elements matching the predicate

Definition Classes
ElementStep
def *(qname: QName): XPath[T]

Search for all immediate child elements with a matching qname
Search for all immediate child elements with a matching qname

Definition Classes
ElementStep
def *:*(local: String): XPath[T]

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

Definition Classes
ElementStep
def *:@(local: String): AttributePaths[T]

Only matches local name
Only matches local name

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

Loose match for UnprefixedQNames only, only matches local and namespace
Loose match for UnprefixedQNames only, only matches local and namespace

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

Special case for AttributeQNames, only local and namespace match
Special case for AttributeQNames, only local and namespace match

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

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

Definition Classes
AttributeAxis
def *@: AttributePaths[T]

All immediate attributes
All immediate attributes

Definition Classes
AttributeAxis
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

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

simple test for string equality
simple test for string equality

Definition Classes
Axis
def \: XPath[T]

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

Definition Classes
Axis
def \*: XPath[T]

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

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

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

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

Definition Classes
ElementStep
def \*:@(local: String): AttributePaths[T]

Definition Classes
AttributeAxis
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.
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.

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

Loose match for UnprefixedQNames only, only matches local and namespace
Loose match for UnprefixedQNames only, only matches local and namespace

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

Special case for AttributeQNames, only local and namespace match
Special case for AttributeQNames, only local and namespace match

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

Definition Classes
AttributeAxis
def \@: AttributePaths[T]

Definition Classes
AttributeAxis
def \\: XPath[T]

All descendants, uses XPathInfo eager to choose an implementation
All descendants, uses XPathInfo eager to choose an implementation

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

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

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

Definition Classes
ElementStep
def \\*: XPath[T]

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

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

Loose match for UnprefixedQNames only, only matches local and namespace
Loose match for UnprefixedQNames only, only matches local and namespace

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

Special case for AttributeQNames, only local and namespace match
Special case for AttributeQNames, only local and namespace match

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

Definition Classes
AttributeAxis
def \\@: AttributePaths[T]

Definition Classes
AttributeAxis
def \^: XPath[T]

Parents of these paths
Parents of these paths

Definition Classes
Axis
def ancestor_::: XPath[T]

All parents of this node
All parents of this node

Definition Classes
DocumentSplitters
def ancestor_or_self_::: XPath[T]

All parents of this node or this node
All parents of this node or this node

Definition Classes
DocumentSplitters
final def asInstanceOf[T0]: T0

Definition Classes
Any
val cbf: CanBuildFrom[PT, xml.XmlPath, PT]

Definition Classes
DirectXPath → XPath → Axis
def cdata: XPath[T]

all cdata child elements
all cdata child elements

Definition Classes
OtherNodeTypes
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def comment: XPath[T]

all commnent child elements
all commnent child elements

Definition Classes
OtherNodeTypes
def descendant_::: XPath[T]

As per spec all children of a context but predicates work directly on these children.
As per spec all children of a context but predicates work directly on these children. i.e. path.\.descendant_::.*(pred).*(1) returns the first elem for which pred is true whereas path.\\*(pred).*(1) returns ALL the first elems for which this is true.

Definition Classes
DocumentSplitters
def descendant_or_self_::: XPath[T]

All descendants of this node or self
All descendants of this node or self

Definition Classes
DocumentSplitters
def empty: Iterable[xml.XmlPath]

Definition Classes
XPath → Axis
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def filter(pred: (xml.XmlPath) ⇒ Boolean): XPath[T]

filter through the current matches
filter through the current matches

Definition Classes
Axis
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def following_::: XPath[T]

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

Definition Classes
DocumentSplitters
def following_sibling_::: XPath[T]

All siblings after the context
All siblings after the context

Definition Classes
SiblingsAxis
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def i_*@: Iterable[AttributePath]

Definition Classes
AttributeAxis
def in(f: (XPath[T]) ⇒ XPath[T]): XPath[T]

Allow working within the XPath, easily extend and test
Allow working within the XPath, easily extend and test

Definition Classes
XPath
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def just(only: xml.XmlPath): Iterable[xml.XmlPath]

Definition Classes
XPath → Axis
def last_<(n: ⇒ Int): XPath[T]

Equivalent to [last() < n]
Equivalent to [last() < n]

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

Equivalent to [last() = n]
Equivalent to [last() = n]

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

Equivalent to [last() > n]
Equivalent to [last() > n]

Definition Classes
Axis
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newThis(xpathInfo: XPathInfo): XPath[T]

Definition Classes
XPath → Axis
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def one: Iterable[xml.XmlPath]

Some when its only one in the result set
Some when its only one in the result set

Definition Classes
XPath
def oneOr(handler: (XPath[T]) ⇒ Iterable[xml.XmlPath]): Iterable[xml.XmlPath]

Definition Classes
XPath
val path: XPathInfo

Definition Classes
DirectXPath → XPath → Axis
def pi: XPath[T]

all pi child elements
all pi child elements

Definition Classes
OtherNodeTypes
def pos(pos: ⇒ Int): XPath[T]

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

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

Equivalent to [position() < pos]
Equivalent to [position() < pos]

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

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

Equivalent to [position() > pos]
Equivalent to [position() > pos]

Definition Classes
Axis
def pos_eq_last: XPath[T]

Equivalent to position() = last()
Equivalent to position() = last()

Definition Classes
Axis
def preceding_::: XPath[T]

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

Definition Classes
DocumentSplitters
def preceding_sibling_::: XPath[T]

All siblings before the context
All siblings before the context

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

Definition Classes
DirectXPath → Axis
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def text: XPath[T]

all text child elements - xpath standard way, including cdata nodes, filtered to join adjacent text nodes
all text child elements - xpath standard way, including cdata nodes, filtered to join adjacent text nodes

Definition Classes
OtherNodeTypes
def textOnly: XPath[T]

all text child elements - not including cdata nodes, neither sorted nor dup filtered
all text child elements - not including cdata nodes, neither sorted nor dup filtered

Definition Classes
OtherNodeTypes
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def xfilter(f: (Iterable[xml.XmlPath]) ⇒ Boolean): XPath[T]

Definition Classes
Axis
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
x prefixed to avoid disturbing the use of an xpath as an iterable

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

Attributes
protected
Definition Classes
Axis
final def xmap(f: (Iterable[xml.XmlPath]) ⇒ Iterable[xml.XmlPath]): XPath[T]

Definition Classes
Axis
def |(other: XPath[T]): XPath[T]

Union of the two paths, they must use the same type however
Union of the two paths, they must use the same type however
x | x === x but only when apply fromXPathToIterable (default behaviour anyway)
For attribute paths only ++ on an iterable is supported.

Definition Classes
XPath
def |>(f: (XPath[T]) ⇒ XPath[T]): XPath[T]

Allow working within the XPath, easily extend and test
Allow working within the XPath, easily extend and test

Definition Classes
XPath

class DirectXPath[PT <: Iterable[xml.XmlPath]] extends XPath[PT]

Instance Constructors

new DirectXPath(path: XPathInfo, cbf: CanBuildFrom[PT, xml.XmlPath, PT])

Type Members

type T = PT

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

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

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

def *@: AttributePaths[T]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

def \: XPath[T]

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

def \+: XPath[T]

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

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

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

def \@: AttributePaths[T]

def \\: XPath[T]

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

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

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

def \\@: AttributePaths[T]

def \^: XPath[T]

def ancestor_::: XPath[T]

def ancestor_or_self_::: XPath[T]

final def asInstanceOf[T0]: T0

val cbf: CanBuildFrom[PT, xml.XmlPath, PT]

def cdata: XPath[T]

def clone(): AnyRef

def comment: XPath[T]

def descendant_::: XPath[T]

def descendant_or_self_::: XPath[T]

def empty: Iterable[xml.XmlPath]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def finalize(): Unit

def following_::: XPath[T]

def following_sibling_::: XPath[T]

final def getClass(): Class[_]

def hashCode(): Int

def i_*@: Iterable[AttributePath]

def in(f: (XPath[T]) ⇒ XPath[T]): XPath[T]

final def isInstanceOf[T0]: Boolean

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

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

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

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

final def ne(arg0: AnyRef): Boolean

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

final def notify(): Unit

final def notifyAll(): Unit

def one: Iterable[xml.XmlPath]

def oneOr(handler: (XPath[T]) ⇒ Iterable[xml.XmlPath]): Iterable[xml.XmlPath]

val path: XPathInfo

def pi: XPath[T]

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

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

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

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