Projection function, which returns elements of this sequence based
on the string that.
Projection function, which returns elements of this sequence based
on the string that. Use:
this \ "foo" to get a list of all elements that are labelled with "foo";\ "_" to get a list of all elements (wildcard);ns \ "@foo" to get the unprefixed attribute "foo";ns \ "@{uri}foo" to get the prefixed attribute "pre:foo" whose
prefix "pre" is resolved to the namespace "uri".For attribute projections, the resulting scala.xml.NodeSeq attribute values are wrapped in a scala.xml.Group.
There is no support for searching a prefixed attribute by its literal prefix.
The document order is preserved.
Convenience method which returns string text of the named attribute.
Convenience method which returns string text of the named attribute. Use:
that \@ "foo" to get the string text of attribute "foo";
Projection function, which returns elements of this sequence and of
all its subsequences, based on the string that.
Projection function, which returns elements of this sequence and of
all its subsequences, based on the string that. Use:
this \\ 'foo to get a list of all elements that are labelled with "foo";\\ "_" to get a list of all elements (wildcard);ns \\ "@foo" to get the unprefixed attribute "foo";ns \\ "@{uri}foo" to get each prefixed attribute "pre:foo" whose
prefix "pre" is resolved to the namespace "uri".For attribute projections, the resulting scala.xml.NodeSeq attribute values are wrapped in a scala.xml.Group.
There is no support for searching a prefixed attribute by its literal prefix.
The document order is preserved.
Convenience method, looks up a prefixed attribute in attributes of this node.
Convenience method, looks up a prefixed attribute in attributes of this node.
Same as attributes.getValue(uri, this, key)-
namespace of queried attribute (may not be null).
of queried attribute.
value of PrefixedAttribute with given namespace
and given key, otherwise null.
Convenience method, looks up an unprefixed attribute in attributes of this node.
Convenience method, looks up an unprefixed attribute in attributes of this node.
Same as attributes.getValue(key)
of queried attribute.
value of UnprefixedAttribute with given key
in attributes, if it exists, otherwise null.
Returns attribute meaning all attributes of this node, prefixed and unprefixed, in no particular order.
Returns attribute meaning all attributes of this node, prefixed and
unprefixed, in no particular order. In class Node, this
defaults to Null (the empty attribute list).
all attributes of this node
String representation of this node
String representation of this node
if true, strips comment nodes from result
We insist we're only equal to other xml.Equality implementors,
which heads off a lot of inconsistency up front.
Descendant axis (all descendants of this node, not including node itself) includes all text nodes, element nodes, comments and processing instructions.
Descendant axis (all descendants of this node, including thisa node) includes all text nodes, element nodes, comments and processing instructions.
The logic formerly found in typeTag$, as best I could infer it.
Convenience method, same as scope.getURI(pre) but additionally
checks if scope is null.
Convenience method, same as scope.getURI(pre) but additionally
checks if scope is null.
the prefix whose namespace name we would like to obtain
the namespace if scope != null and prefix was
found, else null
It's be nice to make these final, but there are probably people out there subclassing the XML types, especially when it comes to equals.
It's be nice to make these final, but there are probably people out there subclassing the XML types, especially when it comes to equals. However WE at least can pretend they are final since clearly individual classes cannot be trusted to maintain a semblance of order.
used internally.
used internally. Atom/Molecule = -1 PI = -2 Comment = -3 EntityRef = -5
Appends qualified name of this node to StringBuilder.
convenience, same as getNamespace(this.prefix)
Creates a list buffer as builder for this class
Creates a list buffer as builder for this class
Children which do not stringify to "" (needed for equality)
prefix of this node
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
method returning the namespace bindings of this node.
method returning the namespace bindings of this node. by default, this is TopScope, which means there are no namespace bindings except the predefined one for "xml".
Returns a text representation of this node.
Returns a text representation of this node. Note that this is not equivalent to the XPath node-test called text(), it is rather an implementation of the XPath function string() Martin to Burak: to do: if you make this method abstract, the compiler will now complain if there's no implementation in a subclass. Is this what we want? Note that this would break doc/DocGenator and doc/ModelToXML, with an error message like:
doc\DocGenerator.scala:1219: error: object creation impossible, since there is a deferred declaration of method text in class Node of type => String which is not implemented in a subclass new SpecialNode { ^
returns a sequence consisting of only this node
Same as toString(false).
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
Returns a type symbol (e.
Returns a type symbol (e.g. DTD, XSD), default null.
(node: NodeSeq).++(that)(bf)
(node: NodeSeq).++:(that)(bf)
(node: NodeSeq).++:(that)(bf)
(node: NodeSeq).+:(elem)(bf)
(node: NodeSeq)./:(z)(op)
(node: NodeSeq).:+(elem)(bf)
(node: NodeSeq).:\(z)(op)
Projection function, which returns elements of this sequence based
on the string that.
Projection function, which returns elements of this sequence based
on the string that. Use:
this \ "foo" to get a list of all elements that are labelled with "foo";\ "_" to get a list of all elements (wildcard);ns \ "@foo" to get the unprefixed attribute "foo";ns \ "@{uri}foo" to get the prefixed attribute "pre:foo" whose
prefix "pre" is resolved to the namespace "uri".For attribute projections, the resulting scala.xml.NodeSeq attribute values are wrapped in a scala.xml.Group.
There is no support for searching a prefixed attribute by its literal prefix.
The document order is preserved.
(node: NodeSeq).\(that)
Convenience method which returns string text of the named attribute.
Convenience method which returns string text of the named attribute. Use:
that \@ "foo" to get the string text of attribute "foo";
(node: NodeSeq).\@(attributeName)
Projection function, which returns elements of this sequence and of
all its subsequences, based on the string that.
Projection function, which returns elements of this sequence and of
all its subsequences, based on the string that. Use:
this \\ 'foo to get a list of all elements that are labelled with "foo";\\ "_" to get a list of all elements (wildcard);ns \\ "@foo" to get the unprefixed attribute "foo";ns \\ "@{uri}foo" to get each prefixed attribute "pre:foo" whose
prefix "pre" is resolved to the namespace "uri".For attribute projections, the resulting scala.xml.NodeSeq attribute values are wrapped in a scala.xml.Group.
There is no support for searching a prefixed attribute by its literal prefix.
The document order is preserved.
(node: NodeSeq).\\(that)
(node: NodeSeq).addString(b)
(node: NodeSeq).addString(b, sep)
(node: NodeSeq).addString(b, start, sep, end)
(node: NodeSeq).aggregate(z)(seqop, combop)
(node: NodeSeq).andThen(k)
(node: NodeSeq).apply(f)
(node: NodeSeq).apply(i)
(node: NodeSeq).applyOrElse(x, default)
We insist we're only equal to other xml.Equality implementors,
which heads off a lot of inconsistency up front.
We insist we're only equal to other xml.Equality implementors,
which heads off a lot of inconsistency up front.
(node: NodeSeq).canEqual(other)
(node: NodeSeq).collect(pf)(bf)
(node: NodeSeq).collectFirst(pf)
(node: NodeSeq).combinations(n)
(node: NodeSeq).companion
(node: NodeSeq).compose(g)
(node: NodeSeq).contains(elem)
(node: NodeSeq).containsSlice(that)
(node: NodeSeq).copyToArray(xs, start, len)
(node: NodeSeq).copyToArray(xs)
(node: NodeSeq).copyToArray(xs, start)
(node: NodeSeq).copyToBuffer(dest)
(node: NodeSeq).corresponds(that)(p)
(node: NodeSeq).count(p)
(node: NodeSeq).diff(that)
(node: NodeSeq).distinct
(node: NodeSeq).drop(n)
(node: NodeSeq).dropRight(n)
(node: NodeSeq).dropWhile(p)
(node: NodeSeq).endsWith(that)
(node: NodeSeq).equals(other)
(node: NodeSeq).exists(p)
(node: NodeSeq).filter(p)
(node: MonadOps[Node]).filter(p)
(node: NodeSeq).filterNot(p)
(node: NodeSeq).find(p)
(node: NodeSeq).flatMap(f)(bf)
(node: MonadOps[Node]).flatMap(f)
(node: NodeSeq).flatten(asTraversable)
(node: FlattenOps[Node]).flatten
(node: NodeSeq).fold(z)(op)
(node: NodeSeq).foldLeft(z)(op)
(node: NodeSeq).foldRight(z)(op)
(node: NodeSeq).forall(p)
(node: NodeSeq).foreach(f)
(node: NodeSeq).genericBuilder
(node: NodeSeq).groupBy(f)
(node: NodeSeq).grouped(size)
(node: NodeSeq).hasDefiniteSize
It's be nice to make these final, but there are probably people out there subclassing the XML types, especially when it comes to equals.
It's be nice to make these final, but there are probably people out there subclassing the XML types, especially when it comes to equals. However WE at least can pretend they are final since clearly individual classes cannot be trusted to maintain a semblance of order.
(node: NodeSeq).hashCode()
(node: NodeSeq).head
(node: NodeSeq).headOption
(node: NodeSeq).indexOf(elem, from)
(node: NodeSeq).indexOf(elem)
(node: NodeSeq).indexOfSlice(that, from)
(node: NodeSeq).indexOfSlice(that)
(node: NodeSeq).indexWhere(p, from)
(node: NodeSeq).indexWhere(p)
(node: NodeSeq).indices
(node: NodeSeq).init
(node: NodeSeq).inits
(node: NodeSeq).intersect(that)
(node: NodeSeq).isDefinedAt(idx)
(node: NodeSeq).isEmpty
(node: NodeSeq).isTraversableAgain
(node: NodeSeq).iterator
(node: NodeSeq).last
(node: NodeSeq).lastIndexOf(elem, end)
(node: NodeSeq).lastIndexOf(elem)
(node: NodeSeq).lastIndexOfSlice(that, end)
(node: NodeSeq).lastIndexOfSlice(that)
(node: NodeSeq).lastIndexWhere(p, end)
(node: NodeSeq).lastIndexWhere(p)
(node: NodeSeq).lastOption
(node: NodeSeq).length
(node: NodeSeq).lengthCompare(len)
(node: NodeSeq).lift
(node: NodeSeq).map(f)(bf)
(node: MonadOps[Node]).map(f)
(node: NodeSeq).max(cmp)
(node: NodeSeq).maxBy(f)(cmp)
(node: NodeSeq).min(cmp)
(node: NodeSeq).minBy(f)(cmp)
(node: NodeSeq).mkString
(node: NodeSeq).mkString(sep)
(node: NodeSeq).mkString(start, sep, end)
(node: NodeSeq).nonEmpty
(node: NodeSeq).orElse(that)
(node: NodeSeq).padTo(len, elem)(bf)
(node: NodeSeq).par
(node: NodeSeq).partition(p)
(node: NodeSeq).patch(from, patch, replaced)(bf)
(node: NodeSeq).permutations
(node: NodeSeq).prefixLength(p)
(node: NodeSeq).product(num)
(node: NodeSeq).reduce(op)
(node: NodeSeq).reduceLeft(op)
(node: NodeSeq).reduceLeftOption(op)
(node: NodeSeq).reduceOption(op)
(node: NodeSeq).reduceRight(op)
(node: NodeSeq).reduceRightOption(op)
(node: NodeSeq).repr
(node: NodeSeq).reverse
(node: NodeSeq).reverseIterator
(node: NodeSeq).reverseMap(f)(bf)
(node: NodeSeq).runWith(action)
(node: NodeSeq).sameElements(that)
(node: NodeSeq).scan(z)(op)(cbf)
(node: NodeSeq).scanLeft(z)(op)(bf)
(node: NodeSeq).scanRight(z)(op)(bf)
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
(node: NodeSeq).segmentLength(p, from)
(node: NodeSeq).seq
(node: NodeSeq).size
(node: NodeSeq).slice(from, until)
(node: NodeSeq).sliding(size, step)
(node: NodeSeq).sliding(size)
(node: NodeSeq).sortBy(f)(ord)
(node: NodeSeq).sortWith(lt)
(node: NodeSeq).sorted(ord)
(node: NodeSeq).span(p)
(node: NodeSeq).splitAt(n)
(node: NodeSeq).startsWith(that, offset)
(node: NodeSeq).startsWith(that)
(node: NodeSeq).strict_!=(other)
(node: NodeSeq).strict_==(other)
(node: NodeSeq).stringPrefix
(node: NodeSeq).sum(num)
(node: NodeSeq).tail
(node: NodeSeq).tails
(node: NodeSeq).take(n)
(node: NodeSeq).takeRight(n)
(node: NodeSeq).takeWhile(p)
(node: NodeSeq).text
(node: NodeSeq).theSeq
(node: NodeSeq).to(cbf)
(node: NodeSeq).toArray(arg0)
(node: NodeSeq).toBuffer
(node: NodeSeq).toIndexedSeq
(node: NodeSeq).toIterable
(node: NodeSeq).toIterator
(node: NodeSeq).toList
(node: NodeSeq).toMap(ev)
(node: NodeSeq).toSeq
(node: NodeSeq).toSet
(node: NodeSeq).toStream
(node: NodeSeq).toString()
(node: NodeSeq).toTraversable
(node: NodeSeq).toVector
(node: NodeSeq).transpose(asTraversable)
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
(node: NodeSeq).union(that)(bf)
(node: NodeSeq).unzip(asPair)
(node: NodeSeq).unzip3(asTriple)
(node: NodeSeq).updated(index, elem)(bf)
(node: NodeSeq).view(from, until)
(node: NodeSeq).view
(node: NodeSeq).withFilter(p)
(node: MonadOps[Node]).withFilter(p)
(node: NodeSeq).xml_!=(other)
(node: NodeSeq).xml_==(other)
(node: NodeSeq).xml_sameElements(that)
(node: NodeSeq).zip(that)(bf)
(node: NodeSeq).zipAll(that, thisElem, thatElem)(bf)
(node: NodeSeq).zipWithIndex(bf)
An abstract class representing XML with nodes of a labelled tree. This class contains an implementation of a subset of XPath for navigation.
1.1