trait UpdatableElemApi extends AnyElemNodeApi with IsNavigableApi
This is the functional update part of the yaidom uniform query API. It is a sub-trait of trait eu.cdevreeze.yaidom.queryapi.IsNavigableApi. Only a few DOM-like element implementations in yaidom mix in this trait (indirectly, because some implementing sub-trait is mixed in), thus sharing this query API.
This trait typically does not show up in application code using yaidom, yet its (uniform) API does. Hence, it makes sense to read the documentation of this trait, knowing that the API is offered by multiple element implementations.
This trait is purely abstract. The most common implementation of this trait is eu.cdevreeze.yaidom.queryapi.UpdatableElemLike. The trait has all the knowledge of its super-trait, but in addition to that knows the following:
- An element has child nodes, which may or may not be elements. Hence the extra type parameter for nodes.
- An element knows the child node indexes of the path entries of the child elements.
Obviously methods
, children
and withChildren
must be consistent with
methods such as collectChildNodeIndexes
.findAllChildElems
Using this minimal knowledge alone, trait
not only offers the methods of its parent trait, but also:UpdatableElemLike
- methods to functionally update an element by replacing, adding or deleting child nodes
- methods to functionally update an element by replacing descendant-or-self elements at specified paths
For the conceptual difference with "transformable" elements, see trait eu.cdevreeze.yaidom.queryapi.TransformableElemApi.
This query API leverages the Scala Collections API. Query results can be manipulated using the Collections API, and the
query API implementation (in
) uses the Collections API internally.UpdatableElemLike
UpdatableElemApi examples
To illustrate the use of this API, consider the following example XML:
<book:Bookstore xmlns:book="http://bookstore/book" xmlns:auth="http://bookstore/author"> <book:Book ISBN="978-0321356680" Price="35" Edition="2"> <book:Title>Effective Java (2nd Edition)</book:Title> <book:Authors> <auth:Author> <auth:First_Name>Joshua</auth:First_Name> <auth:Last_Name>Bloch</auth:Last_Name> </auth:Author> </book:Authors> </book:Book> <book:Book ISBN="978-0981531649" Price="35" Edition="2"> <book:Title>Programming in Scala: A Comprehensive Step-by-Step Guide, 2nd Edition</book:Title> <book:Authors> <auth:Author> <auth:First_Name>Martin</auth:First_Name> <auth:Last_Name>Odersky</auth:Last_Name> </auth:Author> <auth:Author> <auth:First_Name>Lex</auth:First_Name> <auth:Last_Name>Spoon</auth:Last_Name> </auth:Author> <auth:Author> <auth:First_Name>Bill</auth:First_Name> <auth:Last_Name>Venners</auth:Last_Name> </auth:Author> </book:Authors> </book:Book> </book:Bookstore>
Suppose this XML has been parsed into eu.cdevreeze.yaidom.simple.Elem variable named
. Then we can add a book
as follows, where we "forget" the 2nd author for the moment:bookstoreElem
import convert.ScalaXmlConversions._ val bookstoreNamespace = "http://bookstore/book" val authorNamespace = "http://bookstore/author" val fpBookXml = <book:Book xmlns:book="http://bookstore/book" xmlns:auth="http://bookstore/author" ISBN="978-1617290657" Price="33"> <book:Title>Functional Programming in Scala</book:Title> <book:Authors> <auth:Author> <auth:First_Name>Paul</auth:First_Name> <auth:Last_Name>Chiusano</auth:Last_Name> </auth:Author> </book:Authors> </book:Book> val fpBookElem = convertToElem(fpBookXml) bookstoreElem = bookstoreElem.plusChild(fpBookElem)
Note that the namespace declarations for prefixes
and book
had to be repeated in the Scala XML literal
for the added book, because otherwise the auth
method would throw an exception (since convertToElem
instances
cannot be created unless all element and attribute QNames can be resolved as ENames).Elem
The resulting bookstore seems ok, but if we print
, the result does not look pretty.
This can be fixed if the last assignment is replaced by:convertElem(bookstoreElem)
bookstoreElem = bookstoreElem.plusChild(fpBookElem).prettify(2)
knowing that an indentation of 2 spaces has been used throughout the original XML. Method
is expensive, so it
is best not to invoke it within a tight loop. As an alternative, formatting can be left to the prettify
, of
course.DocumentPrinter
The assignment above is the same as the following one:
bookstoreElem = bookstoreElem.withChildren(bookstoreElem.children :+ fpBookElem).prettify(2)
There are several methods to functionally update the children of an element. For example, method
is overloaded,
and the other variant can insert a child at a given 0-based position. Other "children update" methods are plusChild
,
minusChild
and withPatchedChildren
.withUpdatedChildren
Let's now turn to functional update methods that take
instances or collections thereof. In the example above
the second author of the added book is missing. Let's fix that:Path
val secondAuthorXml = <auth:Author xmlns:auth="http://bookstore/author"> <auth:First_Name>Runar</auth:First_Name> <auth:Last_Name>Bjarnason</auth:Last_Name> </auth:Author> val secondAuthorElem = convertToElem(secondAuthorXml) val fpBookAuthorsPaths = for { authorsPath <- indexed.Elem(bookstoreElem) filterElems { e => e.resolvedName == EName(bookstoreNamespace, "Authors") } map (_.path) if authorsPath.findAncestorPath(path => path.endsWithName(EName(bookstoreNamespace, "Book")) && bookstoreElem.getElemOrSelfByPath(path).attribute(EName("ISBN")) == "978-1617290657").isDefined } yield authorsPath require(fpBookAuthorsPaths.size == 1) val fpBookAuthorsPath = fpBookAuthorsPaths.head bookstoreElem = bookstoreElem.updateElemOrSelf(fpBookAuthorsPath) { elem => require(elem.resolvedName == EName(bookstoreNamespace, "Authors")) val rawResult = elem.plusChild(secondAuthorElem) rawResult transformElemsOrSelf (e => e.copy(scope = elem.scope.withoutDefaultNamespace ++ e.scope)) } bookstoreElem = bookstoreElem.prettify(2)
Clearly the resulting bookstore element is nicely formatted, but there was another possible issue that was taken into
account. See the line of code transforming the "raw result". That line was added in order to prevent namespace undeclarations,
which for XML version 1.0 are not allowed (with the exception of the default namespace). After all, the XML for the second
author was created with only the
namespace declared. Without the above-mentioned line of code, a namespace
undeclaration for prefix auth
would have occurred in the resulting XML, thus leading to an invalid XML 1.0 element tree.book
To illustrate functional update methods taking collections of paths, let's remove the added book from the book store. Here is one (somewhat inefficient) way to do that:
val bookPaths = indexed.Elem(bookstoreElem) filterElems (_.resolvedName == EName(bookstoreNamespace, "Book")) map (_.path) bookstoreElem = bookstoreElem.updateElemsWithNodeSeq(bookPaths.toSet) { (elem, path) => if ((elem \@ EName("ISBN")).contains("978-1617290657")) Vector() else Vector(elem) } bookstoreElem = bookstoreElem.prettify(2)
There are very many ways to write this functional update, using different functional update methods in trait
,
or even only using transformation methods in trait UpdatableElemApi
(thus not using paths).TransformableElemApi
The example code above is enough to get started using the
methods, but it makes sense to study the
entire API, and practice with it. Always keep in mind that functional updates typically mess up formatting and/or namespace
(un)declarations, unless these aspects are taken into account.
UpdatableElemApi
- Alphabetic
- By Inheritance
- UpdatableElemApi
- IsNavigableApi
- AnyElemNodeApi
- AnyElemApi
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- abstract type ThisElem <: UpdatableElemApi
The element type itself.
The element type itself. It must be restricted to a sub-type of the query API trait in question.
Concrete element classes will restrict this type to that element class itself.
- Definition Classes
- UpdatableElemApi → IsNavigableApi → AnyElemApi
- abstract type ThisNode >: ThisElem
The node type, that is a super-type of the element type, but also of corresponding text node types etc.
The node type, that is a super-type of the element type, but also of corresponding text node types etc.
- Definition Classes
- AnyElemNodeApi
Abstract Value Members
- abstract def childNodeIndex(pathEntry: Entry): Int
Finds the child node index of the given path entry, or -1 if not found.
Finds the child node index of the given path entry, or -1 if not found. More precisely, returns:
collectChildNodeIndexes(Set(pathEntry)).getOrElse(pathEntry, -1)
- abstract def children: IndexedSeq[ThisNode]
Returns the child nodes of this element, in the correct order
- abstract def collectChildNodeIndexes(pathEntries: Set[Entry]): Map[Entry, Int]
Filters the child elements with the given path entries, and returns a Map from the path entries of those filtered elements to the child node indexes.
Filters the child elements with the given path entries, and returns a Map from the path entries of those filtered elements to the child node indexes. The result Map has no entries for path entries that cannot be resolved. This method should be fast, especially if the passed path entry set is small.
- abstract def findAllChildElemsWithPathEntries: IndexedSeq[(ThisElem, Entry)]
Returns all child elements paired with their path entries.
Returns all child elements paired with their path entries.
- Definition Classes
- IsNavigableApi
- abstract def findChildElemByPathEntry(entry: Entry): Option[ThisElem]
Finds the child element with the given
Path.Entry
(where this element is the root), if any, wrapped in anOption
.Finds the child element with the given
Path.Entry
(where this element is the root), if any, wrapped in anOption
.Typically this method must be very efficient, in order for methods like findElemOrSelfByPath to be efficient.
- Definition Classes
- IsNavigableApi
- abstract def findElemOrSelfByPath(path: Path): Option[ThisElem]
Finds the element with the given
Path
(where this element is the root), if any, wrapped in anOption
.Finds the element with the given
Path
(where this element is the root), if any, wrapped in anOption
.That is, returns:
findReverseAncestryOrSelfByPath(path).map(_.last)
Note that for each non-empty Path, we have:
findElemOrSelfByPath(path) == findChildElemByPathEntry(path.firstEntry). flatMap(_.findElemOrSelfByPath(path.withoutFirstEntry))
- Definition Classes
- IsNavigableApi
- abstract def findReverseAncestryOrSelfByPath(path: Path): Option[IndexedSeq[ThisElem]]
Finds the reversed ancestry-or-self of the element with the given
Path
(where this element is the root), wrapped in an Option.Finds the reversed ancestry-or-self of the element with the given
Path
(where this element is the root), wrapped in an Option. None is returned if no element can be found at the given Path.Hence, the resulting element collection, if any, starts with this element and ends with the element at the given Path, relative to this element.
This method comes in handy for (efficiently) computing base URIs, where the (reverse) ancestry-or-self is needed as input.
- Definition Classes
- IsNavigableApi
- abstract def getChildElemByPathEntry(entry: Entry): ThisElem
Returns (the equivalent of)
findChildElemByPathEntry(entry).get
Returns (the equivalent of)
findChildElemByPathEntry(entry).get
- Definition Classes
- IsNavigableApi
- abstract def getElemOrSelfByPath(path: Path): ThisElem
Returns (the equivalent of)
findElemOrSelfByPath(path).get
Returns (the equivalent of)
findElemOrSelfByPath(path).get
- Definition Classes
- IsNavigableApi
- abstract def getReverseAncestryOrSelfByPath(path: Path): IndexedSeq[ThisElem]
Returns (the equivalent of)
findReverseAncestryOrSelfByPath(path).get
Returns (the equivalent of)
findReverseAncestryOrSelfByPath(path).get
- Definition Classes
- IsNavigableApi
- abstract def minusChild(index: Int): ThisElem
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. Throws an exception if
index >= children.size
. - abstract def plusChild(child: ThisNode): ThisElem
Returns a copy in which the given child has been inserted at the end
- abstract def plusChild(index: Int, child: ThisNode): ThisElem
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). If
index == children.size
, adds the element at the end. Ifindex > children.size
, throws an exception.Afterwards, the resulting element indeed has the given child at position
index
(0-based). - abstract def plusChildOption(childOption: Option[ThisNode]): ThisElem
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. That is, returns
plusChild(childOption.get)
if the given optional child element is non-empty. - abstract def plusChildOption(index: Int, childOption: Option[ThisNode]): ThisElem
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). That is, returns
plusChild(index, childOption.get)
if the given optional child element is non-empty. - abstract def plusChildren(childSeq: IndexedSeq[ThisNode]): ThisElem
Returns a copy in which the given children have been inserted at the end
- abstract def thisElem: ThisElem
This element itself.
This element itself.
- Definition Classes
- AnyElemApi
- abstract def updateChildElem(pathEntry: Entry, newElem: ThisElem): ThisElem
Returns
updateChildElem(pathEntry) { e => newElem }
- abstract def updateChildElem(pathEntry: Entry)(f: (ThisElem) ⇒ ThisElem): ThisElem
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.core.Path.Entry (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.core.Path.Entry (compared to this element as root).
It can be defined as follows:
updateChildElems(Set(pathEntry)) { case (che, pe) => f(che) }
- abstract def updateChildElemWithNodeSeq(pathEntry: Entry, newNodes: IndexedSeq[ThisNode]): ThisElem
Returns
updateChildElemWithNodeSeq(pathEntry) { e => newNodes }
- abstract def updateChildElemWithNodeSeq(pathEntry: Entry)(f: (ThisElem) ⇒ IndexedSeq[ThisNode]): ThisElem
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.core.Path.Entry (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.core.Path.Entry (compared to this element as root).
It can be defined as follows:
updateChildElemsWithNodeSeq(Set(pathEntry)) { case (che, pe) => f(che) }
- abstract def updateChildElems(f: (ThisElem, Entry) ⇒ Option[ThisElem]): ThisElem
Invokes
updateChildElems
, passing the path entries for which the passed function is defined.Invokes
updateChildElems
, passing the path entries for which the passed function is defined. It is equivalent to:val editsByPathEntries: Map[Path.Entry, ThisElem] = findAllChildElemsWithPathEntries.flatMap({ case (che, pe) => f(che, pe).map(newE => (pe, newE)) }).toMap updateChildElems(editsByPathEntries.keySet) { case (che, pe) => editsByPathEntries.getOrElse(pe, che) }
- abstract def updateChildElems(pathEntries: Set[Entry])(f: (ThisElem, Entry) ⇒ ThisElem): ThisElem
Updates the child elements with the given path entries, applying the passed update function.
Updates the child elements with the given path entries, applying the passed update function.
That is, returns the equivalent of:
updateChildElemsWithNodeSeq(pathEntries) { case (che, pe) => Vector(f(che, pe)) }
If the set of path entries is small, this method is rather efficient.
- abstract def updateChildElemsWithNodeSeq(f: (ThisElem, Entry) ⇒ Option[IndexedSeq[ThisNode]]): ThisElem
Invokes
updateChildElemsWithNodeSeq
, passing the path entries for which the passed function is defined.Invokes
updateChildElemsWithNodeSeq
, passing the path entries for which the passed function is defined. It is equivalent to:val editsByPathEntries: Map[Path.Entry, immutable.IndexedSeq[ThisNode]] = findAllChildElemsWithPathEntries.flatMap({ case (che, pe) => f(che, pe).map(newNodes => (pe, newNodes)) }).toMap updateChildElemsWithNodeSeq(editsByPathEntries.keySet) { case (che, pe) => editsByPathEntries.getOrElse(pe, immutable.IndexedSeq(che)) }
- abstract def updateChildElemsWithNodeSeq(pathEntries: Set[Entry])(f: (ThisElem, Entry) ⇒ IndexedSeq[ThisNode]): ThisElem
Updates the child elements with the given path entries, applying the passed update function.
Updates the child elements with the given path entries, applying the passed update function. This is the core method of the update API, and the other methods have implementations that directly or indirectly depend on this method.
That is, returns:
if (pathEntries.isEmpty) self else { val indexesByPathEntries: Seq[(Path.Entry, Int)] = collectChildNodeIndexes(pathEntries).toSeq.sortBy(_._2) // Updating in reverse order of indexes, in order not to invalidate the path entries val newChildren = indexesByPathEntries.reverse.foldLeft(self.children) { case (accChildNodes, (pathEntry, idx)) => val che = accChildNodes(idx).asInstanceOf[ThisElem] accChildNodes.patch(idx, f(che, pathEntry), 1) } self.withChildren(newChildren) }
If the set of path entries is small, this method is rather efficient.
- abstract def updateElemOrSelf(path: Path, newElem: ThisElem): ThisElem
Returns
updateElemOrSelf(path) { e => newElem }
- abstract def updateElemOrSelf(path: Path)(f: (ThisElem) ⇒ ThisElem): ThisElem
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.core.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.core.Path (compared to this element as root).
It can be defined as follows:
updateElemsOrSelf(Set(path)) { case (e, path) => f(e) }
- abstract def updateElemWithNodeSeq(path: Path, newNodes: IndexedSeq[ThisNode]): ThisElem
Returns
updateElemWithNodeSeq(path) { e => newNodes }
- abstract def updateElemWithNodeSeq(path: Path)(f: (ThisElem) ⇒ IndexedSeq[ThisNode]): ThisElem
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.core.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.core.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:
updateElemsWithNodeSeq(Set(path)) { case (e, path) => f(e) }
- abstract def updateElems(paths: Set[Path])(f: (ThisElem, Path) ⇒ ThisElem): ThisElem
Updates the descendant elements with the given paths, applying the passed update function.
Updates the descendant elements with the given paths, applying the passed update function.
That is, returns:
val pathsByFirstEntry: Map[Path.Entry, Set[Path]] = paths.filterNot(_.isEmpty).groupBy(_.firstEntry) updateChildElems(pathsByFirstEntry.keySet) { case (che, pathEntry) => che.updateElemsOrSelf(pathsByFirstEntry(pathEntry).map(_.withoutFirstEntry)) { case (elm, path) => f(elm, path.prepend(pathEntry)) } }
If the set of paths is small, this method is rather efficient.
- abstract def updateElemsOrSelf(paths: Set[Path])(f: (ThisElem, Path) ⇒ ThisElem): ThisElem
Updates the descendant-or-self elements with the given paths, applying the passed update function.
Updates the descendant-or-self elements with the given paths, applying the passed update function.
That is, returns:
val pathsByFirstEntry: Map[Path.Entry, Set[Path]] = paths.filterNot(_.isEmpty).groupBy(_.firstEntry) val descendantUpdateResult = updateChildElems(pathsByFirstEntry.keySet) { case (che, pathEntry) => // Recursive (but non-tail-recursive) call che.updateElemsOrSelf(pathsByFirstEntry(pathEntry).map(_.withoutFirstEntry)) { case (elm, path) => f(elm, path.prepend(pathEntry)) } } if (paths.contains(Path.Empty)) f(descendantUpdateResult, Path.Empty) else descendantUpdateResult
In other words, returns:
val descendantUpdateResult = updateElems(paths)(f) if (paths.contains(Path.Empty)) f(descendantUpdateResult, Path.Empty) else descendantUpdateResult
If the set of paths is small, this method is rather efficient.
- abstract def updateElemsOrSelfWithNodeSeq(paths: Set[Path])(f: (ThisElem, Path) ⇒ IndexedSeq[ThisNode]): IndexedSeq[ThisNode]
Updates the descendant-or-self elements with the given paths, applying the passed update function.
Updates the descendant-or-self elements with the given paths, applying the passed update function.
That is, returns:
val pathsByFirstEntry: Map[Path.Entry, Set[Path]] = paths.filterNot(_.isEmpty).groupBy(_.firstEntry) val descendantUpdateResult = updateChildElemsWithNodeSeq(pathsByFirstEntry.keySet) { case (che, pathEntry) => // Recursive (but non-tail-recursive) call che.updateElemsOrSelfWithNodeSeq( pathsByFirstEntry(pathEntry).map(_.withoutFirstEntry)) { case (elm, path) => f(elm, path.prepend(pathEntry)) } } if (paths.contains(Path.Empty)) f(descendantUpdateResult, Path.Empty) else Vector(descendantUpdateResult)
In other words, returns:
val descendantUpdateResult = updateElemsWithNodeSeq(paths)(f) if (paths.contains(Path.Empty)) f(descendantUpdateResult, Path.Empty) else Vector(descendantUpdateResult)
If the set of paths is small, this method is rather efficient.
- abstract def updateElemsWithNodeSeq(paths: Set[Path])(f: (ThisElem, Path) ⇒ IndexedSeq[ThisNode]): ThisElem
Updates the descendant elements with the given paths, applying the passed update function.
Updates the descendant elements with the given paths, applying the passed update function.
That is, returns:
val pathsByFirstEntry: Map[Path.Entry, Set[Path]] = paths.filterNot(_.isEmpty).groupBy(_.firstEntry) updateChildElemsWithNodeSeq(pathsByFirstEntry.keySet) { case (che, pathEntry) => che.updateElemsOrSelfWithNodeSeq( pathsByFirstEntry(pathEntry).map(_.withoutFirstEntry)) { case (elm, path) => f(elm, path.prepend(pathEntry)) } }
If the set of paths is small, this method is rather efficient.
- abstract def updateTopmostElems(f: (ThisElem, Path) ⇒ Option[ThisElem]): ThisElem
Invokes
updateElems
, passing the topmost non-empty paths for which the passed function is defined.Invokes
updateElems
, passing the topmost non-empty paths for which the passed function is defined. It is equivalent to:val mutableEditsByPaths = mutable.Map[Path, ThisElem]() val foundElems = ElemWithPath(self) findTopmostElems { elm => val optResult = f(elm.elem, elm.path) if (optResult.isDefined) { mutableEditsByPaths += (elm.path -> optResult.get) } optResult.isDefined } val editsByPaths = mutableEditsByPaths.toMap updateElems(editsByPaths.keySet) { case (elm, path) => editsByPaths.getOrElse(path, elm) }
- abstract def updateTopmostElemsOrSelf(f: (ThisElem, Path) ⇒ Option[ThisElem]): ThisElem
Invokes
updateElemsOrSelf
, passing the topmost paths for which the passed function is defined.Invokes
updateElemsOrSelf
, passing the topmost paths for which the passed function is defined. It is equivalent to:val mutableEditsByPaths = mutable.Map[Path, ThisElem]() val foundElems = ElemWithPath(self) findTopmostElemsOrSelf { elm => val optResult = f(elm.elem, elm.path) if (optResult.isDefined) { mutableEditsByPaths += (elm.path -> optResult.get) } optResult.isDefined } val editsByPaths = mutableEditsByPaths.toMap updateElemsOrSelf(editsByPaths.keySet) { case (elm, path) => editsByPaths.getOrElse(path, elm) }
- abstract def updateTopmostElemsOrSelfWithNodeSeq(f: (ThisElem, Path) ⇒ Option[IndexedSeq[ThisNode]]): IndexedSeq[ThisNode]
Invokes
updateElemsOrSelfWithNodeSeq
, passing the topmost paths for which the passed function is defined.Invokes
updateElemsOrSelfWithNodeSeq
, passing the topmost paths for which the passed function is defined. It is equivalent to:val mutableEditsByPaths = mutable.Map[Path, immutable.IndexedSeq[ThisNode]]() val foundElems = ElemWithPath(self) findTopmostElemsOrSelf { elm => val optResult = f(elm.elem, elm.path) if (optResult.isDefined) { mutableEditsByPaths += (elm.path -> optResult.get) } optResult.isDefined } val editsByPaths = mutableEditsByPaths.toMap updateElemsOrSelfWithNodeSeq(editsByPaths.keySet) { case (elm, path) => editsByPaths.getOrElse(path, immutable.IndexedSeq(elm)) }
- abstract def updateTopmostElemsWithNodeSeq(f: (ThisElem, Path) ⇒ Option[IndexedSeq[ThisNode]]): ThisElem
Invokes
updateElemsWithNodeSeq
, passing the topmost non-empty paths for which the passed function is defined.Invokes
updateElemsWithNodeSeq
, passing the topmost non-empty paths for which the passed function is defined. It is equivalent to:val mutableEditsByPaths = mutable.Map[Path, immutable.IndexedSeq[ThisNode]]() val foundElems = ElemWithPath(self) findTopmostElems { elm => val optResult = f(elm.elem, elm.path) if (optResult.isDefined) { mutableEditsByPaths += (elm.path -> optResult.get) } optResult.isDefined } val editsByPaths = mutableEditsByPaths.toMap updateElemsWithNodeSeq(editsByPaths.keySet) { case (elm, path) => editsByPaths.getOrElse(path, immutable.IndexedSeq(elm)) }
- abstract def withChildSeqs(newChildSeqs: IndexedSeq[IndexedSeq[ThisNode]]): ThisElem
Shorthand for
withChildren(newChildSeqs.flatten)
- abstract def withChildren(newChildren: IndexedSeq[ThisNode]): ThisElem
Returns an element with the same name, attributes and scope as this element, but with the given child nodes
- abstract def withPatchedChildren(from: Int, newChildren: IndexedSeq[ThisNode], replace: Int): ThisElem
Shorthand for
withChildren(children.patch(from, newChildren, replace))
- abstract def withUpdatedChildren(index: Int, newChild: ThisNode): ThisElem
Shorthand for
withChildren(children.updated(index, newChild))
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws(classOf[java.lang.CloneNotSupportedException])
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws(classOf[java.lang.InterruptedException])