trait UpdatableElemLike extends IsNavigable with UpdatableElemApi
API and implementation trait for functionally updatable elements. This trait extends trait eu.cdevreeze.yaidom.queryapi.IsNavigable, adding knowledge about child nodes in general, and about the correspondence between child path entries and child indexes.
More precisely, this trait adds the following abstract methods to the abstract methods required by its super-trait:
children
, withChildren
and collectChildNodeIndexes
. Based on these abstract methods (and the super-trait), this
trait offers a rich API for functionally updating elements.
The purely abstract API offered by this trait is eu.cdevreeze.yaidom.queryapi.UpdatableElemApi. See the documentation of that trait for examples of usage, and for a more formal treatment.
- Alphabetic
- By Inheritance
- UpdatableElemLike
- UpdatableElemApi
- AnyElemNodeApi
- IsNavigable
- IsNavigableApi
- AnyElemApi
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
abstract
type
ThisElem <: Aux[ThisNode, ThisElem]
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
- UpdatableElemLike → UpdatableElemApi → IsNavigable → 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
children: IndexedSeq[ThisNode]
Returns the child nodes of this element, in the correct order
Returns the child nodes of this element, in the correct order
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
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.
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
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
- IsNavigable → 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
- IsNavigable → IsNavigableApi
-
abstract
def
thisElem: ThisElem
This element itself.
This element itself.
- Definition Classes
- AnyElemApi
-
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
Returns an element with the same name, attributes and scope as this element, but with the given child nodes
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
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
-
final
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)
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
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
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 (e => e.findElemOrSelfByPath(path.withoutFirstEntry))
- Definition Classes
- IsNavigable → IsNavigableApi
-
final
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
- IsNavigable → IsNavigableApi
-
final
def
getChildElemByPathEntry(entry: Entry): ThisElem
Returns (the equivalent of)
findChildElemByPathEntry(entry).get
Returns (the equivalent of)
findChildElemByPathEntry(entry).get
- Definition Classes
- IsNavigable → IsNavigableApi
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
final
def
getElemOrSelfByPath(path: Path): ThisElem
Returns (the equivalent of)
findElemOrSelfByPath(path).get
Returns (the equivalent of)
findElemOrSelfByPath(path).get
- Definition Classes
- IsNavigable → IsNavigableApi
-
final
def
getReverseAncestryOrSelfByPath(path: Path): IndexedSeq[ThisElem]
Returns (the equivalent of)
findReverseAncestryOrSelfByPath(path).get
Returns (the equivalent of)
findReverseAncestryOrSelfByPath(path).get
- Definition Classes
- IsNavigable → IsNavigableApi
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
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
.- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
final
def
plusChild(child: ThisNode): ThisElem
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
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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).- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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.- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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.- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
plusChildren(childSeq: IndexedSeq[ThisNode]): ThisElem
Returns a copy in which the given children have been inserted at the end
Returns a copy in which the given children have been inserted at the end
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
updateChildElem(pathEntry: Entry, newElem: ThisElem): ThisElem
Returns
updateChildElem(pathEntry) { e => newElem }
Returns
updateChildElem(pathEntry) { e => newElem }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
updateChildElemWithNodeSeq(pathEntry: Entry, newNodes: IndexedSeq[ThisNode]): ThisElem
Returns
updateChildElemWithNodeSeq(pathEntry) { e => newNodes }
Returns
updateChildElemWithNodeSeq(pathEntry) { e => newNodes }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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.
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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)) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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.
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
updateElemOrSelf(path: Path, newElem: ThisElem): ThisElem
Returns
updateElemOrSelf(path) { e => newElem }
Returns
updateElemOrSelf(path) { e => newElem }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
updateElemWithNodeSeq(path: Path, newNodes: IndexedSeq[ThisNode]): ThisElem
Returns
updateElemWithNodeSeq(path) { e => newNodes }
Returns
updateElemWithNodeSeq(path) { e => newNodes }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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.
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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.
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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.
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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.
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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)) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
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)) }
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
withChildSeqs(newChildSeqs: IndexedSeq[IndexedSeq[ThisNode]]): ThisElem
Shorthand for
withChildren(newChildSeqs.flatten)
Shorthand for
withChildren(newChildSeqs.flatten)
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
withPatchedChildren(from: Int, newChildren: IndexedSeq[ThisNode], replace: Int): ThisElem
Shorthand for
withChildren(children.patch(from, newChildren, replace))
Shorthand for
withChildren(children.patch(from, newChildren, replace))
- Definition Classes
- UpdatableElemLike → UpdatableElemApi
-
final
def
withUpdatedChildren(index: Int, newChild: ThisNode): ThisElem
Shorthand for
withChildren(children.updated(index, newChild))
Shorthand for
withChildren(children.updated(index, newChild))
- Definition Classes
- UpdatableElemLike → UpdatableElemApi