UpdatableElemLike

Returns the child nodes of this element, in the correct order

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.

Returns all child elements paired with their path entries.

Finds the child element with the given Path.Entry (where this element is the root), if any, wrapped in an Option.

Typically this method must be very efficient, in order for methods like findElemOrSelfByPath to be efficient.

Returns an element with the same name, attributes and scope as this element, but with the given child nodes

Finds the child node index of the given path entry, or -1 if not found. More precisely, returns:

collectChildNodeIndexes(Set(pathEntry)).getOrElse(pathEntry, -1)

Finds the element with the given Path (where this element is the root), if any, wrapped in an Option.

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))

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.

Returns (the equivalent of) findChildElemByPathEntry(entry).get

Returns (the equivalent of) findElemOrSelfByPath(path).get

Returns (the equivalent of) findReverseAncestryOrSelfByPath(path).get

Returns a copy in which the child at the given position (0-based) has been removed. Throws an exception if index >= children.size.

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). If index == children.size, adds the element at the end. If index > children.size, throws an exception.

Afterwards, the resulting element indeed has the given child at position index (0-based).

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.

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.

Returns a copy in which the given children have been inserted at the end

Returns updateChildElem(pathEntry) { e => newElem }

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) }

Returns updateChildElemWithNodeSeq(pathEntry) { 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.core.Path.Entry (compared to this element as root).

It can be defined as follows:

updateChildElemsWithNodeSeq(Set(pathEntry)) { case (che, pe) => f(che) }

Invokes updateChildElems, passing the path entries for which the passed function is defined. It is equivalent to:

val editsByPathEntries: Map[Path.Entry, E] =
  findAllChildElemsWithPathEntries.flatMap({ case (che, pe) => f(che, pe).map(newE => (pe, newE)) }).toMap

updateChildElems(editsByPathEntries.keySet) { case (che, pe) => editsByPathEntries.getOrElse(pe, che) }

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.

Invokes updateChildElemsWithNodeSeq, passing the path entries for which the passed function is defined. It is equivalent to:

val editsByPathEntries: Map[Path.Entry, immutable.IndexedSeq[N]] =
  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))
}

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[E]
      accChildNodes.patch(idx, f(che, pathEntry), 1)
  }
  self.withChildren(newChildren)
}

If the set of path entries is small, this method is rather efficient.

Returns updateElemOrSelf(path) { e => newElem }

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) }

Returns updateElemWithNodeSeq(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.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) }

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(_.isRoot).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.

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(_.isRoot).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.Root)) f(descendantUpdateResult, Path.Root) else descendantUpdateResult

In other words, returns:

val descendantUpdateResult = updateElems(paths)(f)
if (paths.contains(Path.Root)) f(descendantUpdateResult, Path.Root) else descendantUpdateResult

If the set of paths is small, this method is rather efficient.

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(_.isRoot).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.Root)) f(descendantUpdateResult, Path.Root) else Vector(descendantUpdateResult)

In other words, returns:

val descendantUpdateResult = updateElemsWithNodeSeq(paths)(f)
if (paths.contains(Path.Root)) f(descendantUpdateResult, Path.Root) else Vector(descendantUpdateResult)

If the set of paths is small, this method is rather efficient.

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(_.isRoot).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.

Invokes updateElems, passing the topmost non-empty paths for which the passed function is defined. It is equivalent to:

val mutableEditsByPaths = mutable.Map[Path, E]()

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)
}

Invokes updateElemsOrSelf, passing the topmost paths for which the passed function is defined. It is equivalent to:

val mutableEditsByPaths = mutable.Map[Path, E]()

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)
}

Invokes updateElemsOrSelfWithNodeSeq, passing the topmost paths for which the passed function is defined. It is equivalent to:

val mutableEditsByPaths = mutable.Map[Path, immutable.IndexedSeq[N]]()

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))
}

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[N]]()

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))
}

Shorthand for withChildren(newChildSeqs.flatten)

Shorthand for withChildren(children.patch(from, newChildren, replace))

Shorthand for withChildren(children.updated(index, newChild))