A class supporting filtered operations
[use case] Concatenates this sequence with the elements of an iterator
Concatenates this sequence with the elements of an iterator
[use case] Concatenates this sequence with the elements of a traversable collection
Concatenates this sequence with the elements of a traversable collection
[use case] Prepends an element to this sequence
Prepends an element to this sequence
Applies a binary operator to a start value and all elements of this sequence, going left to right
[use case] Appends an element to this sequence
Appends an element to this sequence
Applies a binary operator to all elements of this sequence and a start value, going right to left
Projection function
projection function
Appends all elements of this sequence to a string builder
Appends all elements of this sequence to a string builder using a separator string
Appends all elements of this sequence to a string builder using start, end, and separator strings
Composes this partial function with a transformation function that gets applied to results of this partial function
Selects an element by its index in the sequence
returns text, with some characters escaped according to XML spec @param sb
String representation of this node
Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind
The factory companion object that builds instances of class Seq
(f compose g)(x) == f(g(x))
Tests whether this sequence contains a given value as an element
Tests whether this sequence contains a given sequence as a slice
[use case] Copies elements of this sequence to an array
Copies elements of this sequence to an array
[use case] Copies elements of this sequence to an array
Copies elements of this sequence to an array
[use case] Copies elements of this sequence to an array
Copies elements of this sequence to an array
Copies all elements of this sequence to a buffer
Tests whether every element of this sequence relates to the corresponding element of another sequence by satisfying a test predicate
Counts the number of elements in the sequence which satisfy a predicate
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
Computes the multiset difference between this sequence and another sequence
Selects all elements except first n ones
Selects all elements except first n ones
Drops longest prefix of elements that satisfy a predicate
Tests whether this sequence ends with the given sequence
Tests whether every element of this sequence relates to the corresponding element of another sequence by satisfying a test predicate
Tests whether a predicate holds for some of the elements of this sequence
Selects all elements of this sequence which satisfy a predicate
Selects all elements of this sequence which do not satisfy a predicate
Finds the first element of the sequence satisfying a predicate, if any
Returns index of the first element satisying a predicate, or -1
Returns index of the last element satisying a predicate, or -1
None
if iterable is empty
[use case] Builds a new collection by applying a function to all elements of this sequence and concatenating the results
Builds a new collection by applying a function to all elements of this sequence and concatenating the results
[use case] Converts this sequence of traversable collections into a sequence in which all element collections are concatenated
Converts this sequence of traversable collections into a sequence in which all element collections are concatenated
Applies a binary operator to a start value and all elements of this sequence, going left to right
Applies a binary operator to all elements of this sequence and a start value, going right to left
Tests whether a predicate holds for all elements of this sequence
[use case] Applies a function f
to all elements of this sequence
Applies a function f
to all elements of this sequence
The generic builder that builds instances of Seq at arbitrary element types
Convenience method, same as scope
def
groupBy[K](f: (Node) ⇒ K): Map[K, NodeSeq]
Partitions this sequence into a map of sequences according to some discriminator function
def
grouped(size: Int): Iterator[NodeSeq]
Partitions elements in fixed size sequences
def
hasDefiniteSize: Boolean
Tests whether this sequence is known to have a finite size
def
hashCode(): Int
Returns a hashcode
def
head: Node
Selects the first element of this sequence
def
headOption: Option[Node]
Optionally selects the first element
def
indexOf(elem: Node): Int
[use case] Finds index of first occurrence of some value in this sequence after or at some start index
def
indexOf[B >: Node](elem: B, from: Int): Int
Finds index of first occurrence of some value in this sequence after or at some start index
def
indexOf(elem: Node): Int
[use case] Finds index of first occurrence of some value in this sequence
def
indexOf[B >: Node](elem: B): Int
Finds index of first occurrence of some value in this sequence
def
indexOfSlice[B >: Node](that: Seq[B], from: Int): Int
Finds first index after or at a start index where this sequence contains a given sequence as a slice
def
indexOfSlice[B >: Node](that: Seq[B]): Int
Finds first index where this sequence contains a given sequence as a slice
def
indexWhere(p: (Node) ⇒ Boolean, from: Int): Int
Finds index of the first element satisfying some predicate after or at some start index
def
indexWhere(p: (Node) ⇒ Boolean): Int
Finds index of first element satisfying some predicate
def
indices: Range
Produces the range of all indices of this sequence
def
init: NodeSeq
Selects all elements except the last
def
intersect[B >: Node, That](that: Seq[B]): NodeSeq
Computes the multiset intersection between this sequence and another sequence
def
isAtom: Boolean
used internally
def
isDefinedAt(idx: Int): Boolean
Tests whether this sequence contains given index
def
isEmpty: Boolean
Tests whether this sequence is empty
def
iterator: Iterator[Node]
Creates a new iterator over all elements contained in this
iterable object
def
label: String
label of this node
def
last: Node
Selects the last element
def
lastIndexOf(elem: Node): Int
[use case] Finds index of last occurrence of some value in this sequence before or at a given end index
def
lastIndexOf[B >: Node](elem: B, end: Int): Int
Finds index of last occurrence of some value in this sequence before or at a given end index
def
lastIndexOf(elem: Node): Int
[use case] Finds index of last occurrence of some value in this sequence
def
lastIndexOf[B >: Node](elem: B): Int
Finds index of last occurrence of some value in this sequence
def
lastIndexOfSlice[B >: Node](that: Seq[B], end: Int): Int
Finds last index before or at a given end index where this sequence contains a given sequence as a slice
def
lastIndexOfSlice[B >: Node](that: Seq[B]): Int
Finds last index where this sequence contains a given sequence as a slice
def
lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int
Finds index of last element satisfying some predicate before or at given end index
def
lastIndexWhere(p: (Node) ⇒ Boolean): Int
Finds index of last element satisfying some predicate
def
lastOption: Option[Node]
Optionally selects the last element
def
length: Int
The length of the sequence
def
lengthCompare(len: Int): Int
Compares the length of this sequence to a test value
def
lift: (Int) ⇒ Option[Node]
Turns this partial function into an plain function returning an Option
result
def
map[B](f: (Node) ⇒ B): Traversable[B]
[use case] Builds a new collection by applying a function to all elements of this sequence
def
map[B, That](f: (Node) ⇒ B)(bf: CanBuildFrom[NodeSeq, B, That]): That
Builds a new collection by applying a function to all elements of this sequence
def
max[B >: Node](cmp: Ordering[B]): Node
Finds the largest element
def
min: Node
[use case] Finds the largest element
def
min: Node
[use case] Finds the smallest element
def
min[B >: Node](cmp: Ordering[B]): Node
Finds the smallest element
def
mkString: String
Displays all elements of this sequence in a string
def
mkString(sep: String): String
Displays all elements of this sequence in a string using a separator string
def
mkString(start: String, sep: String, end: String): String
Displays all elements of this sequence in a string using start, end, and separator strings
def
nameToString(sb: StringBuilder): StringBuilder
Appends qualified name of this node to StringBuilder
def
nonEmpty: Boolean
Tests whether the sequence is not empty
def
orElse[A1 <: Int, B1 >: Node](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
Composes this partial function with a fallback partial function which gets applied where this partial function
is not defined
def
padTo(len: Int, elem: Node): Seq[Node]
[use case] Appends an element value to this sequence until a given target length is reached
def
padTo[B >: Node, That](len: Int, elem: B)(bf: CanBuildFrom[NodeSeq, B, That]): That
Appends an element value to this sequence until a given target length is reached
def
partialMap[B](pf: PartialFunction[Node, B]): Traversable[B]
[use case] Builds a new collection by applying a partial function to all elements of this sequence
on which the function is defined
def
partialMap[B, That](pf: PartialFunction[Node, B])(bf: CanBuildFrom[NodeSeq, B, That]): That
Builds a new collection by applying a partial function to all elements of this sequence
on which the function is defined
def
partition(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
Partitions this sequence in two sequences according to a predicate
def
patch(from: Int, that: Seq[Node], replaced: Int): Seq[Node]
[use case] Produces a new sequence where a slice of elements in this sequence is replaced by another sequence
def
patch[B >: Node, That](from: Int, patch: Seq[B], replaced: Int)(bf: CanBuildFrom[NodeSeq, B, That]): That
Produces a new sequence where a slice of elements in this sequence is replaced by another sequence
def
prefix: String
prefix of this node
def
prefixLength(p: (Node) ⇒ Boolean): Int
Returns the length of the longest prefix whose elements all satisfy some preficate
def
product: Int
[use case] Multiplies up the elements of this collection
def
product[B >: Node](num: Numeric[B]): B
Multiplies up the elements of this collection
def
projection: SeqView[Node, NodeSeq]
returns a projection that can be used to call non-strict filter
,
map
, and flatMap
methods that build projections
of the collection
def
reduceLeft[B >: Node](op: (B, Node) ⇒ B): B
Applies a binary operator to all elements of this sequence, going left to right
def
reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]
Optionally applies a binary operator to all elements of this sequence, going left to right
def
reduceRight[B >: Node](op: (Node, B) ⇒ B): B
Applies a binary operator to all elements of this sequence, going right to left
def
reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]
Optionally applies a binary operator to all elements of this sequence, going right to left
def
removeDuplicates: NodeSeq
Builds a new sequence from this sequence without any duplicate elements
def
repr: NodeSeq
The collection of type sequence underlying this TraversableLike
object
def
reverse: NodeSeq
Returns new sequence wih elements in reversed order
def
reverseIterator: Iterator[Node]
An iterator yielding elements in reversed order
def
reverseMap[B](f: (Node) ⇒ B): Seq[B]
[use case] Builds a new collection by applying a function to all elements of this sequence and
collecting the results in reversed order
def
reverseMap[B, That](f: (Node) ⇒ B)(bf: CanBuildFrom[NodeSeq, B, That]): That
Builds a new collection by applying a function to all elements of this sequence and
collecting the results in reversed order
def
reversedElements: Iterator[Node]
def
sameElements(that: Iterable[Node]): Boolean
[use case] Checks if the other iterable collection contains the same elements in the same order as this sequence
def
sameElements[B >: Node](that: Iterable[B]): Boolean
Checks if the other iterable collection contains the same elements in the same order as this sequence
def
scope: NamespaceBinding
method returning the namespace bindings of this node
def
segmentLength(p: (Node) ⇒ Boolean, from: Int): Int
Computes length of longest segment whose elements all satisfy some preficate
def
size: Int
The size of this sequence, equivalent to length
def
slice(from: Int, until: Int): NodeSeq
Selects an interval of elements
def
sliding[B >: Node](size: Int, step: Int): Iterator[NodeSeq]
def
sliding[B >: Node](size: Int): Iterator[NodeSeq]
Groups elements in fixed size blocks by passing a "sliding window"
over them (as opposed to partitioning them, as is done in grouped
def
sortBy[B](f: (Node) ⇒ B)(ord: Ordering[B]): NodeSeq
Sorts this Seq according to the Ordering which results from transforming
an implicitly given Ordering with a transformation function
def
sortWith[B >: Node](ord: Ordering[B]): NodeSeq
Sorts this sequence according to an Ordering
def
sortWith(lt: (Node, Node) ⇒ Boolean): NodeSeq
Sorts this sequence according to a comparison function
def
span(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
Spits this sequence into a prefix/suffix pair according to a predicate
def
splitAt(n: Int): (NodeSeq, NodeSeq)
Splits this sequence into two at a given position
def
startsWith[B](that: Seq[B]): Boolean
Tests whether this sequence starts with the given sequence
def
startsWith[B](that: Seq[B], offset: Int): Boolean
Tests whether this sequence contains the given sequence at a given index
def
stringPrefix: String
Defines the prefix of this object's toString
representation
def
sum: Int
[use case] Sums up the elements of this collection
def
sum[B >: Node](num: Numeric[B]): B
Sums up the elements of this collection
def
tail: NodeSeq
Selects all elements except the first
def
take(n: Int): NodeSeq
Selects first n elements
def
takeRight(n: Int): NodeSeq
Selects last n elements
def
takeWhile(p: (Node) ⇒ Boolean): NodeSeq
Takes longest prefix of elements that satisfy a predicate
def
text: String
Returns a text representation of this node
def
theSeq: Seq[Node]
returns a sequence consisting of only this node
def
toArray: Array[Node]
[use case] Converts this sequence to an array
def
toArray[B >: Node](arg0: ClassManifest[B]): Array[B]
Converts this sequence to an array
def
toIndexedSeq[B >: Node]: IndexedSeq[B]
Converts this sequence to an indexed sequence
def
toIterable: Iterable[Node]
Converts this sequence to an iterable collection
def
toList: List[Node]
Converts this sequence to a list
def
toMap[T, U](ev: <:<[Node, (T, U)]): Map[T, U]
Converts this sequence to a map
def
toSeq: Seq[Node]
Converts this sequence to a sequence
def
toSet[B >: Node]: Set[B]
Converts this sequence to a set
def
toStream: Stream[Node]
Converts this sequence to a stream
def
toString(): String
Same as toString(false)
def
transpose[B](asTraversable: (Node) ⇒ Traversable[B]): Seq[Seq[B]]
Transposes this sequence of traversable collections into
def
union(that: Seq[Node]): Seq[Node]
[use case] Computes the multiset intersection between this sequence and another sequence
def
union(that: Seq[Node]): Seq[Node]
[use case] Computes the multiset difference between this sequence and another sequence
def
union(that: Seq[Node]): Seq[Node]
[use case] Produces a new sequence which contains all elements of this sequence and also all elements of
a given sequence
def
union[B >: Node, That](that: Seq[B])(bf: CanBuildFrom[NodeSeq, B, That]): That
Produces a new sequence which contains all elements of this sequence and also all elements of
a given sequence
def
unzip[A1, A2](asPair: (Node) ⇒ (A1, A2)): (Seq[A1], Seq[A2])
Converts this sequence of pairs into two collections of the first and second
halfs of each pair
def
updated(index: Int, elem: Node): Seq[Node]
[use case] A copy of this sequence with one single replaced element
def
updated[B >: Node, That](index: Int, elem: B)(bf: CanBuildFrom[NodeSeq, B, That]): That
A copy of this sequence with one single replaced element
def
view(from: Int, until: Int): SeqView[Node, NodeSeq]
Creates a non-strict view of a slice of this sequence
def
view: SeqView[Node, NodeSeq]
Creates a non-strict view of this sequence
def
withFilter(p: (Node) ⇒ Boolean): WithFilter
Creates a non-strict filter of this sequence
def
xmlType(): TypeSymbol
Returns a type symbol (e
def
zip[B](that: Iterable[B]): Iterable[(Node, B)]
[use case] Returns a sequence formed from this sequence and another iterable collection
by combining corresponding elements in pairs
def
zip[A1 >: Node, B, That](that: Iterable[B])(bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
Returns a sequence formed from this sequence and another iterable collection
by combining corresponding elements in pairs
def
zipAll[B](that: Iterable[B], thisElem: Node, thatElem: B): Iterable[(Node, B)]
[use case] Returns a sequence formed from this sequence and another iterable collection
by combining corresponding elements in pairs
def
zipAll[B, A1 >: Node, That](that: Iterable[B], thisElem: A1, thatElem: B)(bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
Returns a sequence formed from this sequence and another iterable collection
by combining corresponding elements in pairs
def
zipWithIndex: Iterable[(Node, Int)]
[use case] Zips this sequence with its indices
def
zipWithIndex[A1 >: Node, That](bf: CanBuildFrom[NodeSeq, (A1, Int), That]): That
Zips this sequence with its indices
Instance constructors
-
new
Unparsed(data: String)
-
new
Unparsed()
An XML node for unparsed content. It will be output verbatim, all bets are off regarding wellformedness etc.