ElemUpdateLike

abstract def children(elem: ElemType): IndexedSeq[NodeType]

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

abstract def collectChildNodeIndexes(elem: ElemType, 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(elem: ElemType): IndexedSeq[(ElemType, Entry)]

Returns all child elements paired with their path entries.

abstract def withChildren(elem: ElemType, newChildren: IndexedSeq[NodeType]): ElemType

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

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

final def childNodeIndex(elem: ElemType, pathEntry: Entry): Int

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

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

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def minusChild(elem: ElemType, index: Int): ElemType

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(elem: ElemType, child: NodeType): ElemType

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

final def plusChild(elem: ElemType, index: Int, child: NodeType): ElemType

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

final def plusChildOption(elem: ElemType, childOption: Option[NodeType]): ElemType

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

final def plusChildOption(elem: ElemType, index: Int, childOption: Option[NodeType]): ElemType

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

final def plusChildren(elem: ElemType, childSeq: IndexedSeq[NodeType]): ElemType

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(elem: ElemType, pathEntry: Entry, newElem: ElemType): ElemType

Returns updateChildElem(elem, pathEntry) { e => newElem }

final def updateChildElem(elem: ElemType, pathEntry: Entry)(f: (ElemType) ⇒ ElemType): ElemType

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(elem, Set(pathEntry)) { case (che, pe) => f(che) }

final def updateChildElemWithNodeSeq(elem: ElemType, pathEntry: Entry, newNodes: IndexedSeq[NodeType]): ElemType

Returns updateChildElemWithNodeSeq(elem, pathEntry) { e => newNodes }

final def updateChildElemWithNodeSeq(elem: ElemType, pathEntry: Entry)(f: (ElemType) ⇒ IndexedSeq[NodeType]): ElemType

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(elem, Set(pathEntry)) { case (che, pe) => f(che) }

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

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

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

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

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

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

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

final def updateChildElemsWithNodeSeq(elem: ElemType, f: (ElemType, Entry) ⇒ Option[IndexedSeq[NodeType]]): ElemType

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

val editsByPathEntries: Map[Path.Entry, immutable.IndexedSeq[NodeType]] =
  findAllChildElemsWithPathEntries(elem).flatMap({ case (che, pe) =>
    f(che, pe).map(newNodes => (pe, newNodes)) }).toMap

updateChildElemsWithNodeSeq(elem, editsByPathEntries.keySet) { case (che, pe) =>
  editsByPathEntries.getOrElse(pe, immutable.IndexedSeq(che))
}

final def updateChildElemsWithNodeSeq(elem: ElemType, pathEntries: Set[Entry])(f: (ElemType, Entry) ⇒ IndexedSeq[NodeType]): ElemType

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

if (pathEntries.isEmpty) elem
else {
  val indexesByPathEntries: Seq[(Path.Entry, Int)] =
    collectChildNodeIndexes(elem, pathEntries).toSeq.sortBy(_._2)

  // Updating in reverse order of indexes, in order not to invalidate the path entries
  val newChildren = indexesByPathEntries.reverse.foldLeft(children(elem)) {
    case (accChildNodes, (pathEntry, idx)) =>
      val che = accChildNodes(idx).asInstanceOf[ElemType]
      accChildNodes.patch(idx, f(che, pathEntry), 1)
  }
  withChildren(elem, newChildren)
}

final def updateElemOrSelf(elem: ElemType, path: Path, newElem: ElemType): ElemType

Returns updateElemOrSelf(elem, path) { e => newElem }

final def updateElemOrSelf(elem: ElemType, path: Path)(f: (ElemType) ⇒ ElemType): ElemType

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(elem, Set(path)) { case (e, path) => f(e) }

final def updateElemWithNodeSeq(elem: ElemType, path: Path, newNodes: IndexedSeq[NodeType]): ElemType

Returns updateElemWithNodeSeq(elem, path) { e => newNodes }

final def updateElemWithNodeSeq(elem: ElemType, path: Path)(f: (ElemType) ⇒ IndexedSeq[NodeType]): ElemType

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(elem, Set(path)) { case (e, path) => f(e) }

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

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

val pathsByFirstEntry: Map[Path.Entry, Set[Path]] =
  paths.filterNot(_.isEmpty).groupBy(_.firstEntry)

updateChildElems(elem, pathsByFirstEntry.keySet) {
  case (che, pathEntry) =>
    updateElemsOrSelf(che, pathsByFirstEntry(pathEntry).map(_.withoutFirstEntry)) {
      case (elm, path) =>
        f(elm, path.prepend(pathEntry))
    }
}

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

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

val pathsByFirstEntry: Map[Path.Entry, Set[Path]] =
  paths.filterNot(_.isEmpty).groupBy(_.firstEntry)

val descendantUpdateResult =
  updateChildElems(elem, pathsByFirstEntry.keySet) {
    case (che, pathEntry) =>
      // Recursive (but non-tail-recursive) call
      updateElemsOrSelf(che, pathsByFirstEntry(pathEntry).map(_.withoutFirstEntry)) {
        case (elm, path) =>
          f(elm, path.prepend(pathEntry))
      }
  }

if (paths.contains(Path.Empty)) f(descendantUpdateResult, Path.Empty)
else descendantUpdateResult

val descendantUpdateResult = updateElems(elem, paths)(f)

if (paths.contains(Path.Empty)) f(descendantUpdateResult, Path.Empty)
else descendantUpdateResult

final def updateElemsOrSelfWithNodeSeq(elem: ElemType, paths: Set[Path])(f: (ElemType, Path) ⇒ IndexedSeq[NodeType]): IndexedSeq[NodeType]

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

val pathsByFirstEntry: Map[Path.Entry, Set[Path]] =
  paths.filterNot(_.isEmpty).groupBy(_.firstEntry)

val descendantUpdateResult =
  updateChildElemsWithNodeSeq(elem, pathsByFirstEntry.keySet) {
    case (che, pathEntry) =>
      // Recursive (but non-tail-recursive) call
      updateElemsOrSelfWithNodeSeq(
        che, pathsByFirstEntry(pathEntry).map(_.withoutFirstEntry)) {
        case (elm, path) =>
          f(elm, path.prepend(pathEntry))
      }
  }

if (paths.contains(Path.Empty)) f(descendantUpdateResult, Path.Empty)
else Vector(descendantUpdateResult)

val descendantUpdateResult = updateElemsWithNodeSeq(elem, paths)(f)

if (paths.contains(Path.Empty)) f(descendantUpdateResult, Path.Empty)
else Vector(descendantUpdateResult)

final def updateElemsWithNodeSeq(elem: ElemType, paths: Set[Path])(f: (ElemType, Path) ⇒ IndexedSeq[NodeType]): ElemType

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

val pathsByFirstEntry: Map[Path.Entry, Set[Path]] =
  paths.filterNot(_.isEmpty).groupBy(_.firstEntry)

updateChildElemsWithNodeSeq(elem, pathsByFirstEntry.keySet) {
  case (che, pathEntry) =>
    updateElemsOrSelfWithNodeSeq(
      che, pathsByFirstEntry(pathEntry).map(_.withoutFirstEntry)) {
      case (elm, path) =>
        f(elm, path.prepend(pathEntry))
    }
}

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withChildSeqs(elem: ElemType, newChildSeqs: IndexedSeq[IndexedSeq[NodeType]]): ElemType

Shorthand for withChildren(elem, newChildSeqs.flatten)

final def withPatchedChildren(elem: ElemType, from: Int, newChildren: IndexedSeq[NodeType], replace: Int): ElemType

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

final def withUpdatedChildren(elem: ElemType, index: Int, newChild: NodeType): ElemType

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