UpdatableElemLike

abstract def children: IndexedSeq[N]

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.

abstract def findAllChildElemsWithPathEntries: IndexedSeq[(E, Entry)]

Returns all child elements paired with their path entries.

abstract def findChildElemByPathEntry(entry: Entry): Option[E]

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

abstract def withChildren(newChildren: IndexedSeq[N]): E

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

final def childNodeIndex(pathEntry: Entry): Int

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

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

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def findElemOrSelfByPath(path: Path): Option[E]

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

findReverseAncestryOrSelfByPath(path).map(_.last)

findElemOrSelfByPath(path) == findChildElemByPathEntry(path.firstEntry) flatMap (e => e.findElemOrSelfByPath(path.withoutFirstEntry))

final def findReverseAncestryOrSelfByPath(path: Path): Option[IndexedSeq[E]]

Finds the reversed ancestry-or-self of the element with the given Path (where this element is the root), wrapped in an Option.

final def getChildElemByPathEntry(entry: Entry): E

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

final def getClass(): Class[_]

final def getElemOrSelfByPath(path: Path): E

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

final def getReverseAncestryOrSelfByPath(path: Path): IndexedSeq[E]

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

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def minusChild(index: Int): E

Returns a copy in which the child at the given position (0-based) has been removed.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def plusChild(child: N): E

Returns a copy in which the given child has been inserted at the end

final def plusChild(index: Int, child: N): E

Returns a copy in which the given child has been inserted at the given position (0-based).

final def plusChildOption(childOption: Option[N]): E

Returns a copy in which the given child, if any, has been inserted at the end.

final def plusChildOption(index: Int, childOption: Option[N]): E

Returns a copy in which the given child, if any, has been inserted at the given position (0-based).

final def plusChildren(childSeq: IndexedSeq[N]): E

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

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def updateChildElem(pathEntry: Entry, newElem: E): E

Returns updateChildElem(pathEntry) { e => newElem }

final def updateChildElem(pathEntry: Entry)(f: (E) ⇒ E): E

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

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

final def updateChildElemWithNodeSeq(pathEntry: Entry, newNodes: IndexedSeq[N]): E

Returns updateChildElemWithNodeSeq(pathEntry) { e => newNodes }

final def updateChildElemWithNodeSeq(pathEntry: Entry)(f: (E) ⇒ IndexedSeq[N]): E

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

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

final def updateChildElems(f: (E, Entry) ⇒ Option[E]): E

Invokes updateChildElems, passing the path entries for which the passed function is defined.

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

final def updateChildElems(pathEntries: Set[Entry])(f: (E, Entry) ⇒ E): E

Updates the child elements with the given path entries, applying the passed update function.

updateChildElemsWithNodeSeq(pathEntries) { case (che, pe) => Vector(f(che, pe)) }

final def updateChildElemsWithNodeSeq(f: (E, Entry) ⇒ Option[IndexedSeq[N]]): E

Invokes updateChildElemsWithNodeSeq, passing the path entries for which the passed function is defined.

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

final def updateChildElemsWithNodeSeq(pathEntries: Set[Entry])(f: (E, Entry) ⇒ IndexedSeq[N]): E

Updates the child elements with the given path entries, applying the passed update function.

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

final def updateElemOrSelf(path: Path, newElem: E): E

Returns updateElemOrSelf(path) { e => newElem }

final def updateElemOrSelf(path: Path)(f: (E) ⇒ E): E

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

updateElemsOrSelf(Set(path)) { case (e, path) => f(e) }

final def updateElemWithNodeSeq(path: Path, newNodes: IndexedSeq[N]): E

Returns updateElemWithNodeSeq(path) { e => newNodes }

final def updateElemWithNodeSeq(path: Path)(f: (E) ⇒ IndexedSeq[N]): E

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

updateElemsWithNodeSeq(Set(path)) { case (e, path) => f(e) }

final def updateElems(paths: Set[Path])(f: (E, Path) ⇒ E): E

Updates the descendant elements with the given paths, applying the passed update function.

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

final def updateElemsOrSelf(paths: Set[Path])(f: (E, Path) ⇒ E): E

Updates the descendant-or-self elements with the given paths, applying the passed update function.

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

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

final def updateElemsOrSelfWithNodeSeq(paths: Set[Path])(f: (E, Path) ⇒ IndexedSeq[N]): IndexedSeq[N]

Updates the descendant-or-self elements with the given paths, applying the passed update function.

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)

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

final def updateElemsWithNodeSeq(paths: Set[Path])(f: (E, Path) ⇒ IndexedSeq[N]): E

Updates the descendant elements with the given paths, applying the passed update function.

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

final def updateTopmostElems(f: (E, Path) ⇒ Option[E]): E

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

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

final def updateTopmostElemsOrSelf(f: (E, Path) ⇒ Option[E]): E

Invokes updateElemsOrSelf, passing the topmost paths for which the passed function is defined.

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

final def updateTopmostElemsOrSelfWithNodeSeq(f: (E, Path) ⇒ Option[IndexedSeq[N]]): IndexedSeq[N]

Invokes updateElemsOrSelfWithNodeSeq, passing the topmost paths for which the passed function is defined.

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

final def updateTopmostElemsWithNodeSeq(f: (E, Path) ⇒ Option[IndexedSeq[N]]): E

Invokes updateElemsWithNodeSeq, passing the topmost non-empty paths for which the passed function is defined.

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

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def withChildSeqs(newChildSeqs: IndexedSeq[IndexedSeq[N]]): E

Shorthand for withChildren(newChildSeqs.flatten)

final def withPatchedChildren(from: Int, newChildren: IndexedSeq[N], replace: Int): E

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

final def withUpdatedChildren(index: Int, newChild: N): E

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

final def updated(path: Path, newElem: E): E

final def updated(path: Path)(f: (E) ⇒ E): E

final def updated(pathEntry: Entry)(f: (E) ⇒ E): E

final def updatedAtPathEntries(pathEntries: Set[Entry])(f: (E, Entry) ⇒ E): E

final def updatedAtPaths(paths: Set[Path])(f: (E, Path) ⇒ E): E

final def updatedWithNodeSeq(path: Path, newNodes: IndexedSeq[N]): E

final def updatedWithNodeSeq(path: Path)(f: (E) ⇒ IndexedSeq[N]): E

final def updatedWithNodeSeqAtPathEntries(pathEntries: Set[Entry])(f: (E, Entry) ⇒ IndexedSeq[N]): E

final def updatedWithNodeSeqAtPaths(paths: Set[Path])(f: (E, Path) ⇒ IndexedSeq[N]): E