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.
always empty
appends "<?" target (" "+text)?+"?>" to this stringbuffer.
appends "<?" target (" "+text)?+"?>" to this stringbuffer.
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.
always empty
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, 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.
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
label of this node.
Appends qualified name of this node to StringBuilder.
Appends qualified name of this node to StringBuilder.
always Node.
always Node.EmptyNamespace
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)
Children which do not stringify to "" (needed for equality)
prefix of this node
prefix of this node
text contained in this node, may not contain "?>"
(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".
target name of this PI
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.
(procInstr: NodeSeq).++(that)(bf)
(procInstr: NodeSeq).++:(that)(bf)
(procInstr: NodeSeq).++:(that)(bf)
(procInstr: NodeSeq).+:(elem)(bf)
(procInstr: NodeSeq)./:(z)(op)
(procInstr: NodeSeq).:+(elem)(bf)
(procInstr: 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.
(procInstr: 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";
(procInstr: 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.
(procInstr: NodeSeq).\\(that)
(procInstr: NodeSeq).addString(b)
(procInstr: NodeSeq).addString(b, sep)
(procInstr: NodeSeq).addString(b, start, sep, end)
(procInstr: NodeSeq).aggregate(z)(seqop, combop)
(procInstr: NodeSeq).andThen(k)
(procInstr: NodeSeq).apply(f)
(procInstr: NodeSeq).apply(i)
(procInstr: 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.
(procInstr: NodeSeq).canEqual(other)
(procInstr: NodeSeq).collect(pf)(bf)
(procInstr: NodeSeq).collectFirst(pf)
(procInstr: NodeSeq).combinations(n)
(procInstr: NodeSeq).companion
(procInstr: NodeSeq).compose(g)
(procInstr: NodeSeq).contains(elem)
(procInstr: NodeSeq).containsSlice(that)
(procInstr: NodeSeq).copyToArray(xs, start, len)
(procInstr: NodeSeq).copyToArray(xs)
(procInstr: NodeSeq).copyToArray(xs, start)
(procInstr: NodeSeq).copyToBuffer(dest)
(procInstr: NodeSeq).corresponds(that)(p)
(procInstr: NodeSeq).count(p)
(procInstr: NodeSeq).diff(that)
(procInstr: NodeSeq).distinct
(procInstr: NodeSeq).drop(n)
(procInstr: NodeSeq).dropRight(n)
(procInstr: NodeSeq).dropWhile(p)
(procInstr: NodeSeq).endsWith(that)
(procInstr: NodeSeq).equals(other)
(procInstr: NodeSeq).exists(p)
(procInstr: NodeSeq).filter(p)
(procInstr: MonadOps[Node]).filter(p)
(procInstr: NodeSeq).filterNot(p)
(procInstr: NodeSeq).find(p)
(procInstr: NodeSeq).flatMap(f)(bf)
(procInstr: MonadOps[Node]).flatMap(f)
(procInstr: NodeSeq).flatten(asTraversable)
(procInstr: FlattenOps[Node]).flatten
(procInstr: NodeSeq).fold(z)(op)
(procInstr: NodeSeq).foldLeft(z)(op)
(procInstr: NodeSeq).foldRight(z)(op)
(procInstr: NodeSeq).forall(p)
(procInstr: NodeSeq).foreach(f)
(procInstr: NodeSeq).genericBuilder
(procInstr: NodeSeq).groupBy(f)
(procInstr: NodeSeq).grouped(size)
(procInstr: 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.
(procInstr: NodeSeq).hashCode()
(procInstr: NodeSeq).head
(procInstr: NodeSeq).headOption
(procInstr: NodeSeq).indexOf(elem, from)
(procInstr: NodeSeq).indexOf(elem)
(procInstr: NodeSeq).indexOfSlice(that, from)
(procInstr: NodeSeq).indexOfSlice(that)
(procInstr: NodeSeq).indexWhere(p, from)
(procInstr: NodeSeq).indexWhere(p)
(procInstr: NodeSeq).indices
(procInstr: NodeSeq).init
(procInstr: NodeSeq).inits
(procInstr: NodeSeq).intersect(that)
(procInstr: NodeSeq).isDefinedAt(idx)
(procInstr: NodeSeq).isEmpty
(procInstr: NodeSeq).isTraversableAgain
(procInstr: NodeSeq).iterator
(procInstr: NodeSeq).last
(procInstr: NodeSeq).lastIndexOf(elem, end)
(procInstr: NodeSeq).lastIndexOf(elem)
(procInstr: NodeSeq).lastIndexOfSlice(that, end)
(procInstr: NodeSeq).lastIndexOfSlice(that)
(procInstr: NodeSeq).lastIndexWhere(p, end)
(procInstr: NodeSeq).lastIndexWhere(p)
(procInstr: NodeSeq).lastOption
(procInstr: NodeSeq).length
(procInstr: NodeSeq).lengthCompare(len)
(procInstr: NodeSeq).lift
(procInstr: NodeSeq).map(f)(bf)
(procInstr: MonadOps[Node]).map(f)
(procInstr: NodeSeq).max(cmp)
(procInstr: NodeSeq).maxBy(f)(cmp)
(procInstr: NodeSeq).min(cmp)
(procInstr: NodeSeq).minBy(f)(cmp)
(procInstr: NodeSeq).mkString
(procInstr: NodeSeq).mkString(sep)
(procInstr: NodeSeq).mkString(start, sep, end)
(procInstr: NodeSeq).nonEmpty
(procInstr: NodeSeq).orElse(that)
(procInstr: NodeSeq).padTo(len, elem)(bf)
(procInstr: NodeSeq).par
(procInstr: NodeSeq).partition(p)
(procInstr: NodeSeq).patch(from, patch, replaced)(bf)
(procInstr: NodeSeq).permutations
(procInstr: NodeSeq).prefixLength(p)
(procInstr: NodeSeq).product(num)
(procInstr: NodeSeq).reduce(op)
(procInstr: NodeSeq).reduceLeft(op)
(procInstr: NodeSeq).reduceLeftOption(op)
(procInstr: NodeSeq).reduceOption(op)
(procInstr: NodeSeq).reduceRight(op)
(procInstr: NodeSeq).reduceRightOption(op)
(procInstr: NodeSeq).repr
(procInstr: NodeSeq).reverse
(procInstr: NodeSeq).reverseIterator
(procInstr: NodeSeq).reverseMap(f)(bf)
(procInstr: NodeSeq).runWith(action)
(procInstr: NodeSeq).sameElements(that)
(procInstr: NodeSeq).scan(z)(op)(cbf)
(procInstr: NodeSeq).scanLeft(z)(op)(bf)
(procInstr: 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.
(procInstr: NodeSeq).segmentLength(p, from)
(procInstr: NodeSeq).seq
(procInstr: NodeSeq).size
(procInstr: NodeSeq).slice(from, until)
(procInstr: NodeSeq).sliding(size, step)
(procInstr: NodeSeq).sliding(size)
(procInstr: NodeSeq).sortBy(f)(ord)
(procInstr: NodeSeq).sortWith(lt)
(procInstr: NodeSeq).sorted(ord)
(procInstr: NodeSeq).span(p)
(procInstr: NodeSeq).splitAt(n)
(procInstr: NodeSeq).startsWith(that, offset)
(procInstr: NodeSeq).startsWith(that)
(procInstr: NodeSeq).strict_!=(other)
(procInstr: NodeSeq).strict_==(other)
(procInstr: NodeSeq).stringPrefix
(procInstr: NodeSeq).sum(num)
(procInstr: NodeSeq).tail
(procInstr: NodeSeq).tails
(procInstr: NodeSeq).take(n)
(procInstr: NodeSeq).takeRight(n)
(procInstr: NodeSeq).takeWhile(p)
(procInstr: NodeSeq).text
(procInstr: NodeSeq).theSeq
(procInstr: NodeSeq).to(cbf)
(procInstr: NodeSeq).toArray(arg0)
(procInstr: NodeSeq).toBuffer
(procInstr: NodeSeq).toIndexedSeq
(procInstr: NodeSeq).toIterable
(procInstr: NodeSeq).toIterator
(procInstr: NodeSeq).toList
(procInstr: NodeSeq).toMap(ev)
(procInstr: NodeSeq).toSeq
(procInstr: NodeSeq).toSet
(procInstr: NodeSeq).toStream
(procInstr: NodeSeq).toString()
(procInstr: NodeSeq).toTraversable
(procInstr: NodeSeq).toVector
(procInstr: NodeSeq).transpose(asTraversable)
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
(procInstr: NodeSeq).union(that)(bf)
(procInstr: NodeSeq).unzip(asPair)
(procInstr: NodeSeq).unzip3(asTriple)
(procInstr: NodeSeq).updated(index, elem)(bf)
(procInstr: NodeSeq).view(from, until)
(procInstr: NodeSeq).view
(procInstr: NodeSeq).withFilter(p)
(procInstr: MonadOps[Node]).withFilter(p)
(procInstr: NodeSeq).xml_!=(other)
(procInstr: NodeSeq).xml_==(other)
(procInstr: NodeSeq).xml_sameElements(that)
(procInstr: NodeSeq).zip(that)(bf)
(procInstr: NodeSeq).zipAll(that, thisElem, thatElem)(bf)
(procInstr: NodeSeq).zipWithIndex(bf)
an XML node for processing instructions (PI)
target name of this PI
text contained in this node, may not contain "?>"