UpdatableElemLike

abstract def childNodeIndex(childPathEntry: Entry): Int

Returns the child node index of the child element at the given path entry, if any, and -1 otherwise.

abstract def children: IndexedSeq[N]

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

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: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

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.

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

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 synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

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

Returns updated(path) { e => newElem }

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

Method that "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 (path == Path.Root) f(self)
else updated(path.firstEntry) { e => e.updated(path.withoutFirstEntry)(f) }

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

Core method that "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).

val idx = self.childNodeIndex(pathEntry)
self.withUpdatedChildren(idx, f(children(idx).asInstanceOf[E]))

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

Method that "functionally updates" the tree with this element as root element, by applying the passed function to all child elements with the given path entries (compared to this element as root).

val newChildren = pathEntries.toSeq.map(entry => (entry -> childNodeIndex(entry))).sortBy(_._2).reverse.foldLeft(children) {
  case (acc, (pathEntry, idx)) =>
    acc.updated(idx, f(acc(idx).asInstanceOf[E], pathEntry))
}
withChildren(newChildren)

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

Method that "functionally updates" the tree with this element as root element, by applying the passed function to all descendant-or-self elements with the given paths (compared to this element as root).

def updatedAtPaths(paths: Set[Path])(f: (E, Path) => E): E = {
  val pathsByPathEntries = paths.filter(path => !path.isRoot).groupBy(path => path.firstEntry)
  val resultWithoutSelf = self.updatedAtPathEntries(pathsByPathEntries.keySet) { (che, pathEntry) =>
    val newChe = che.updatedAtPaths(paths.map(_.withoutFirstEntry)) { (elem, relativePath) =>
      f(elem, relativePath.prepend(pathEntry))
    }
    newChe
  }
  if (paths.contains(Path.Root)) f(resultWithoutSelf, Path.Root) else resultWithoutSelf
}

val pathsReversed = indexed.Elem(this).findAllElemsOrSelf.map(_.path).filter(p => paths.contains(p)).reverse
pathsReversed.foldLeft(self) { case (acc, path) => acc.updated(path) { e => f(e, path) } }

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

Returns updatedWithNodeSeq(path) { e => newNodes }

final def updatedWithNodeSeq(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).

// First define function g as follows:

def g(e: Elem): Elem = {
  if (path == Path.Root) e
  else {
    e.withPatchedChildren(
      e.childNodeIndex(path.lastEntry),
      f(e.findChildElemByPathEntry(path.lastEntry).get),
      1)
  }
}

// Then the function updatedWithNodeSeq(path)(f) could be defined as:

updated(path.parentPathOption.getOrElse(Path.Root))(g)

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

Method that "functionally updates" the tree with this element as root element, by applying the passed function to all child elements with the given path entries (compared to this element as root).

val indexesByPathEntries = pathEntries.toSeq.map(entry => (entry -> childNodeIndex(entry))).sortBy(_._2).reverse
val newChildGroups =
  indexesByPathEntries.foldLeft(self.children.map(n => immutable.IndexedSeq(n))) {
    case (acc, (pathEntry, idx)) =>
      acc.updated(idx, f(acc(idx).head.asInstanceOf[E], pathEntry))
  }
withChildren(newChildGroups.flatten)

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

Method that "functionally updates" the tree with this element as root element, by applying the passed function to all descendant elements with the given paths (compared to this element as root), but ignoring the root path.

val pathsByParentPaths = paths.filter(path => !path.isRoot).groupBy(path => path.parentPath)
self.updatedAtPaths(pathsByParentPaths.keySet) { (elem, path) =>
  val childPathEntries = pathsByParentPaths(path).map(_.lastEntry)
  elem.updatedWithNodeSeqAtPathEntries(childPathEntries) { (che, pathEntry) =>
    f(che, path.append(pathEntry))
  }
}

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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