Elem
Shorthand for filterChildElems(p).
Shorthand for attributeOption(expandedName).
Shorthand for attributeOption(expandedName).
Shorthand for filterElemsOrSelf(p).
Shorthand for findTopmostElemsOrSelf(p).
Returns the value of the attribute with the given expanded name, and throws an exception otherwise.
Returns the value of the attribute with the given expanded name, and throws an exception otherwise.
Returns the value of the attribute with the given expanded name, if any, wrapped in an Option.
Returns the value of the attribute with the given expanded name, if any, wrapped in an Option.
Returns the child node index of the child element at the given path entry, if any, and -1 otherwise.
Returns the child node index of the child element at the given path entry, if any, and -1 otherwise. The faster this method is, the better.
Returns the child nodes of this element, in the correct order
Returns the child nodes of this element, in the correct order
Returns a copy where adjacent text nodes have been combined into one text node, throughout the node tree
Returns a copy where adjacent text nodes have been combined into one text node, and where all text is normalized, throughout the node tree.
Returns a copy where adjacent text nodes have been combined into one text node, and where all
text is normalized, throughout the node tree. Same as calling coalesceAllAdjacentText followed by normalizeAllText,
but more efficient.
Returns the child elements obeying the given predicate.
Returns the descendant elements obeying the given predicate.
Returns the descendant-or-self elements obeying the given predicate.
Returns the descendant-or-self elements obeying the given predicate. This method could be defined as:
def filterElemsOrSelf(p: E => Boolean): immutable.IndexedSeq[E] = Vector(this).filter(p) ++ (this.findAllChildElems flatMap (_.filterElemsOrSelf(p)))
It can be proven that the result is equivalent to findAllElemsOrSelf filter p.
Returns the element children
Returns all child elements with Path entries, in the correct order.
Returns all descendant elements (not including this element).
Returns this element followed by all descendant elements (that is, the descendant-or-self elements).
Returns the first found attribute value of an attribute with the given local name, if any, wrapped in an Option.
Returns the first found attribute value of an attribute with the given local name, if any, wrapped in an Option.
Because of differing namespaces, it is possible that more than one such attribute exists, although this is not often the case.
Returns the first found child element obeying the given predicate, if any, wrapped in an Option.
Finds the child element with the given Path.Entry (where this element is the root), if any, wrapped in an Option.
Finds the child element with the given Path.Entry (where this element is the root), if any, wrapped in an Option.
Returns the first found (topmost) descendant element obeying the given predicate, if any, wrapped in an Option.
Returns the first found (topmost) descendant-or-self element obeying the given predicate, if any, wrapped in an Option.
Finds the element with the given Path (where this element is the root), if any, wrapped in an Option.
Finds the element with the given Path (where this element is the root), if any, wrapped in an Option.
This method must be very efficient, which depends on the efficiency of method findChildElemByPathEntry.
Returns the descendant elements obeying the given predicate that have no ancestor obeying the predicate.
Returns the descendant-or-self elements obeying the given predicate, such that no ancestor obeys the predicate.
Returns the descendant-or-self elements obeying the given predicate, such that no ancestor obeys the predicate. This method could be defined as:
def findTopmostElemsOrSelf(p: E => Boolean): immutable.IndexedSeq[E] = if (p(this)) Vector(this) else (this.findAllChildElems flatMap (_.findTopmostElemsOrSelf(p)))
Returns the single child element obeying the given predicate, and throws an exception otherwise.
Returns (the equivalent of) findChildElemByPathEntry(entry).get
Returns (the equivalent of) findChildElemByPathEntry(entry).get
Returns (the equivalent of) findElemOrSelfByPath(path).get
Returns (the equivalent of) findElemOrSelfByPath(path).get
The local name, that is, the local part of the EName
The local name, that is, the local part of the EName
Returns a copy in which the child at the given position (0-based) has been removed
Returns a copy in which the child at the given position (0-based) has been removed
Returns a copy where text nodes have been normalized, throughout the node tree.
Returns a copy where text nodes have been normalized, throughout the node tree.
Note that it makes little sense to call this method before coalesceAllAdjacentText.
Returns XmlStringUtils.normalizeString(text).
Returns XmlStringUtils.normalizeString(text).
Returns a copy in which the given child has been inserted at the end
Returns a copy in which the given child has been inserted at the end
Returns a copy in which the given child has been inserted at the given position (0-based)
Returns a copy in which the given child has been inserted at the given position (0-based)
Returns a copy in which the given child, if any, has been inserted at the end
Returns a copy in which the given child, if any, has been inserted at the end
Returns a copy in which the given child, if any, has been inserted at the given position (0-based)
Returns a copy in which the given child, if any, has been inserted at the given position (0-based)
Returns a copy where inter-element whitespace has been removed, throughout the node tree
The resolved attributes of the element as mapping from ENames to values
The resolved attributes of the element as mapping from ENames to values
The EName of the element
The EName of the element
Returns the concatenation of the texts of text children, including whitespace.
Returns the concatenation of the texts of text children, including whitespace. Non-text children are ignored. If there are no text children, the empty string is returned.
Returns the text children
Returns the same element, except that child elements have been replaced by applying the given function.
Returns the same element, except that child elements have been replaced by applying the given function. Non-element child nodes occur in the result element unaltered.
That is, returns the equivalent of:
val newChildren = children map { case e: E => f(e) case n: N => n } withChildren(newChildren)
Returns the same element, except that child elements have been replaced by applying the given function.
Returns the same element, except that child elements have been replaced by applying the given function. Non-element child nodes occur in the result element unaltered.
That is, returns the equivalent of:
val newChildren = children flatMap { case e: E => f(e) case n: N => Vector(n) } withChildren(newChildren)
Transforms the element by applying the given function to all its descendant elements, in a bottom-up manner.
Transforms the element by applying the given function to all its descendant elements, in a bottom-up manner.
That is, returns the equivalent of:
transformChildElems (e => e.transformElemsOrSelf(f))
Transforms the element by applying the given function to all its descendant-or-self elements, in a bottom-up manner.
Transforms the element by applying the given function to all its descendant-or-self elements, in a bottom-up manner.
That is, returns the equivalent of:
f(transformChildElems (e => e.transformElemsOrSelf(f)))In other words, returns the equivalent of:
f(transformElems(f))
Transforms each descendant element to a node sequence by applying the given function to all its descendant-or-self elements, in a bottom-up manner.
Transforms each descendant element to a node sequence by applying the given function to all its descendant-or-self elements, in a bottom-up manner.
That is, returns the equivalent of:
f(transformChildElemsToNodeSeq(e => e.transformElemsOrSelfToNodeSeq(f)))In other words, returns the equivalent of:
f(transformElemsToNodeSeq(f))
Transforms each descendant element to a node sequence by applying the given function to all its descendant elements, in a bottom-up manner.
Transforms each descendant element to a node sequence by applying the given function to all its descendant elements, in a bottom-up manner. The function is not applied to this element itself.
That is, returns the equivalent of:
transformChildElemsToNodeSeq(e => e.transformElemsOrSelfToNodeSeq(f))It is equivalent to the following expression:
transformElemsOrSelf { e => e.transformChildElemsToNodeSeq(che => f(che)) }
Returns text.trim.
Returns text.trim.
Returns updated(path) { e => newElem }
Returns updated(path) { e => newElem }
Method that "functionally updates" the tree with this element as root element, by applying the passed function to the element that has the given eu.cdevreeze.yaidom.Path (compared to this element as root).
Method that "functionally updates" the tree with this element as root element, by applying the passed function to the element that has the given eu.cdevreeze.yaidom.Path (compared to this element as root).
The method throws an exception if no element is found with the given path.
It can be defined (recursively) as follows:
if (path == Path.Root) f(self) else updated(path.firstEntry) { e => e.updated(path.withoutFirstEntry)(f) }
Core method that "functionally updates" the tree with this element as root element, by applying the passed function to the element that has the given eu.cdevreeze.yaidom.Path.Entry (compared to this element as root).
Core method that "functionally updates" the tree with this element as root element, by applying the passed function to the element that has the given eu.cdevreeze.yaidom.Path.Entry (compared to this element as root).
The method throws an exception if no element is found with the given path entry.
It can be defined as follows:
val idx = self.childNodeIndex(pathEntry)
self.withUpdatedChildren(idx, f(children(idx).asInstanceOf[E]))
Method that "functionally updates" the tree with this element as root element, by applying the passed function to all child elements with the given path entries (compared to this element as root).
Method that "functionally updates" the tree with this element as root element, by applying the passed function to all child elements with the given path entries (compared to this element as root).
It can be defined as follows (ignoring exceptions):
val newChildren = pathEntries.toSeq.map(entry => (entry -> childNodeIndex(entry))).sortBy(_._2).reverse.foldLeft(children) { case (acc, (pathEntry, idx)) => acc.updated(idx, f(acc(idx).asInstanceOf[E], pathEntry)) } withChildren(newChildren)
Method that "functionally updates" the tree with this element as root element, by applying the passed function to all descendant-or-self elements with the given paths (compared to this element as root).
Method that "functionally updates" the tree with this element as root element, by applying the passed function to all descendant-or-self elements with the given paths (compared to this element as root).
It can be defined (recursively) as follows (ignoring exceptions):
def updatedAtPaths(paths: Set[Path])(f: (E, Path) => E): E = { val pathsByPathEntries = paths.filter(path => !path.isRoot).groupBy(path => path.firstEntry) val resultWithoutSelf = self.updatedAtPathEntries(pathsByPathEntries.keySet) { (che, pathEntry) => val newChe = che.updatedAtPaths(paths.map(_.withoutFirstEntry)) { (elem, relativePath) => f(elem, relativePath.prepend(pathEntry)) } newChe } if (paths.contains(Path.Root)) f(resultWithoutSelf, Path.Root) else resultWithoutSelf }
For simple elements, it is also equivalent to:
val pathsReversed = indexed.Elem(this).findAllElemsOrSelf.map(_.path).filter(p => paths.contains(p)).reverse pathsReversed.foldLeft(self) { case (acc, path) => acc.updated(path) { e => f(e, path) } }
Returns updatedWithNodeSeq(path) { e => newNodes }
Returns updatedWithNodeSeq(path) { e => newNodes }
"Functionally updates" the tree with this element as root element, by applying the passed function to the element that has the given eu.cdevreeze.yaidom.Path (compared to this element as root).
"Functionally updates" the tree with this element as root element, by applying the passed function to the element that has the given eu.cdevreeze.yaidom.Path (compared to this element as root). If the given path is the root path, this element itself is returned unchanged.
This function could be defined as follows:
// First define function g as follows: def g(e: Elem): Elem = { if (path == Path.Root) e else { e.withPatchedChildren( e.childNodeIndex(path.lastEntry), f(e.findChildElemByPathEntry(path.lastEntry).get), 1) } } // Then the function updatedWithNodeSeq(path)(f) could be defined as: updated(path.parentPathOption.getOrElse(Path.Root))(g)
After all, this is just a functional update that replaces the parent element, if it exists.
The method throws an exception if no element is found with the given path.
Method that "functionally updates" the tree with this element as root element, by applying the passed function to all child elements with the given path entries (compared to this element as root).
Method that "functionally updates" the tree with this element as root element, by applying the passed function to all child elements with the given path entries (compared to this element as root).
It can be defined as follows (ignoring exceptions):
val indexesByPathEntries = pathEntries.toSeq.map(entry => (entry -> childNodeIndex(entry))).sortBy(_._2).reverse val newChildGroups = indexesByPathEntries.foldLeft(self.children.map(n => immutable.IndexedSeq(n))) { case (acc, (pathEntry, idx)) => acc.updated(idx, f(acc(idx).head.asInstanceOf[E], pathEntry)) } withChildren(newChildGroups.flatten)
Method that "functionally updates" the tree with this element as root element, by applying the passed function to all descendant elements with the given paths (compared to this element as root), but ignoring the root path.
Method that "functionally updates" the tree with this element as root element, by applying the passed function to all descendant elements with the given paths (compared to this element as root), but ignoring the root path.
It can be defined as follows (ignoring exceptions):
val pathsByParentPaths = paths.filter(path => !path.isRoot).groupBy(path => path.parentPath) self.updatedAtPaths(pathsByParentPaths.keySet) { (elem, path) => val childPathEntries = pathsByParentPaths(path).map(_.lastEntry) elem.updatedWithNodeSeqAtPathEntries(childPathEntries) { (che, pathEntry) => f(che, path.append(pathEntry)) } }
Creates a copy, but with (only) the children passed as parameter newChildren
Creates a copy, but with (only) the children passed as parameter newChildren
Shorthand for withChildren(children.patch(from, newChildren, replace))
Shorthand for withChildren(children.patch(from, newChildren, replace))
Shorthand for withChildren(children.updated(index, newChild))
Shorthand for withChildren(children.updated(index, newChild))
Element as abstract data type. It contains only expanded names, not qualified names. This reminds of James Clark notation for XML trees and expanded names, where qualified names are absent.
See the documentation of the mixed-in query API trait(s) for more details on the uniform query API offered by this class.
Namespace declarations (and undeclarations) are not considered attributes in this API, just like in the rest of yaidom.
To illustrate equality comparisons in action, consider the following example yaidom
Elem, namedschemaElem1:Now consider the following equivalent yaidom
Elem, namedschemaElem2, differing only in namespace prefixes, and in indentation:These 2 XML trees can be considered equal, if we take indentation and namespace prefixes out of the equation. Note that namespace prefixes also occur in the "type" attributes! The following equality comparison returns true: