Elem

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 \(expandedName: EName): IndexedSeq[Elem]

Shorthand for filterChildElems(expandedName).

final def \(p: (Elem) ⇒ Boolean): IndexedSeq[Elem]

Shorthand for filterChildElems(p).

final def \@(expandedName: EName): Option[String]

Shorthand for attributeOption(expandedName)

final def \\(expandedName: EName): IndexedSeq[Elem]

Shorthand for filterElemsOrSelf(expandedName).

final def \\(p: (Elem) ⇒ Boolean): IndexedSeq[Elem]

Shorthand for filterElemsOrSelf(p).

final def \\!(expandedName: EName): IndexedSeq[Elem]

Shorthand for findTopmostElemsOrSelf(expandedName).

final def \\!(p: (Elem) ⇒ Boolean): IndexedSeq[Elem]

Shorthand for findTopmostElemsOrSelf(p).

final def asInstanceOf[T0]: T0

final def attribute(expandedName: EName): String

Returns the value of the attribute with the given expanded name, and throws an exception otherwise

final def attributeOption(expandedName: EName): Option[String]

Returns the value of the attribute with the given expanded name, if any, wrapped in an Option

def canEqual(arg0: Any): Boolean

final def childNodeIndex(childPathEntry: Entry): Int

Shorthand for childNodeIndexesByPathEntries.getOrElse(childPathEntry, -1).

val childNodeIndexesByPathEntries: Map[Entry, Int]

Cache for speeding up child element lookups by element path

val children: IndexedSeq[Node]

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

def clone(): AnyRef

def coalesceAllAdjacentText: Elem

Returns a copy where adjacent text nodes have been combined into one text node, throughout the node tree

def coalesceAndNormalizeAllText: Elem

Returns a copy where adjacent text nodes have been combined into one text node, and where all text is normalized, throughout the node tree.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def filterChildElemPaths(p: (Elem) ⇒ Boolean): IndexedSeq[ElemPath]

Returns the paths of child elements obeying the given predicate

final def filterChildElems(expandedName: EName): IndexedSeq[Elem]

Returns the child elements with the given expanded name

final def filterChildElems(p: (Elem) ⇒ Boolean): IndexedSeq[Elem]

Core method that returns the child elements obeying the given predicate.

def filterChildElems(p: E => Boolean): immutable.IndexedSeq[E] =
  this.findAllChildElems.filter(p)

final def filterElemOrSelfPaths(p: (Elem) ⇒ Boolean): IndexedSeq[ElemPath]

Returns the paths of descendant-or-self elements that obey the given predicate.

final def filterElemPaths(p: (Elem) ⇒ Boolean): IndexedSeq[ElemPath]

Returns the paths of descendant elements obeying the given predicate, that is, the paths of findAllElems filter p

final def filterElems(expandedName: EName): IndexedSeq[Elem]

Returns the descendant elements with the given expanded name

final def filterElems(p: (Elem) ⇒ Boolean): IndexedSeq[Elem]

Returns the descendant elements obeying the given predicate.

this.findAllChildElems flatMap (_.filterElemsOrSelf(p))

final def filterElemsOrSelf(expandedName: EName): IndexedSeq[Elem]

Returns the descendant-or-self elements that have the given expanded name

final def filterElemsOrSelf(p: (Elem) ⇒ Boolean): IndexedSeq[Elem]

Core method that returns the descendant-or-self elements obeying the given predicate.

def filterElemsOrSelf(p: E => Boolean): immutable.IndexedSeq[E] =
  Vector(this).filter(p) ++ (this.findAllChildElems flatMap (_.filterElemsOrSelf(p)))

def finalize(): Unit

final def findAllChildElemPathEntries: IndexedSeq[Entry]

Returns the ElemPath entries of all child elements, in the correct order.

final def findAllChildElemPaths: IndexedSeq[ElemPath]

Returns findAllChildElemsWithPathEntries map { case (e, pe) => ElemPath.from(pe) }

def findAllChildElems: IndexedSeq[Elem]

Returns the element children

def findAllChildElemsWithPathEntries: IndexedSeq[(Elem, Entry)]

Returns all child elements with their ElemPath entries, in the correct order.

final def findAllElemOrSelfPaths: IndexedSeq[ElemPath]

Returns the path of this element followed by the paths of all descendant elements (that is, the descendant-or-self elements)

final def findAllElemPaths: IndexedSeq[ElemPath]

Returns the paths of all descendant elements (not including this element).

final def findAllElems: IndexedSeq[Elem]

Returns all descendant elements (not including this element).

final def findAllElemsOrSelf: IndexedSeq[Elem]

Returns this element followed by all descendant elements (that is, the descendant-or-self elements).

final def findAttributeByLocalName(localName: String): Option[String]

Returns the first found attribute value of an attribute with the given local name, if any, wrapped in an Option.

final def findChildElem(expandedName: EName): Option[Elem]

Returns the first found child element with the given expanded name, if any, wrapped in an Option

final def findChildElem(p: (Elem) ⇒ Boolean): Option[Elem]

Returns the first found child element obeying the given predicate, if any, wrapped in an Option.

final def findChildElemPath(p: (Elem) ⇒ Boolean): Option[ElemPath]

Returns the path of the first found child element obeying the given predicate, if any, wrapped in an Option

final def findElem(expandedName: EName): Option[Elem]

Returns the first found (topmost) descendant element with the given expanded name, if any, wrapped in an Option

final def findElem(p: (Elem) ⇒ Boolean): Option[Elem]

Returns the first found (topmost) descendant element obeying the given predicate, if any, wrapped in an Option.

final def findElemOrSelf(expandedName: EName): Option[Elem]

Returns the first found (topmost) descendant-or-self element with the given expanded name, if any, wrapped in an Option

final def findElemOrSelf(p: (Elem) ⇒ Boolean): Option[Elem]

Returns the first found (topmost) descendant-or-self element obeying the given predicate, if any, wrapped in an Option.

final def findElemOrSelfPath(p: (Elem) ⇒ Boolean): Option[ElemPath]

Returns the path of the first found (topmost) descendant-or-self element obeying the given predicate, if any, wrapped in an Option

final def findElemPath(p: (Elem) ⇒ Boolean): Option[ElemPath]

Returns the path of the first found (topmost) descendant element obeying the given predicate, if any, wrapped in an Option

final def findTopmostElemOrSelfPaths(p: (Elem) ⇒ Boolean): IndexedSeq[ElemPath]

Returns the paths of the descendant-or-self elements that obey the given predicate, such that no ancestor obeys the predicate.

final def findTopmostElemPaths(p: (Elem) ⇒ Boolean): IndexedSeq[ElemPath]

Returns the paths of the descendant elements obeying the given predicate that have no ancestor obeying the predicate

final def findTopmostElems(expandedName: EName): IndexedSeq[Elem]

Returns the descendant elements with the given expanded name that have no ancestor with the same name

final def findTopmostElems(p: (Elem) ⇒ Boolean): IndexedSeq[Elem]

Returns the descendant elements obeying the given predicate that have no ancestor obeying the predicate.

this.findAllChildElems flatMap (_.findTopmostElemsOrSelf(p))

final def findTopmostElemsOrSelf(expandedName: EName): IndexedSeq[Elem]

Returns the descendant-or-self elements with the given expanded name that have no ancestor with the same name

final def findTopmostElemsOrSelf(p: (Elem) ⇒ Boolean): IndexedSeq[Elem]

Core method that returns the descendant-or-self elements obeying the given predicate, such that no ancestor obeys the predicate.

def findTopmostElemsOrSelf(p: E => Boolean): immutable.IndexedSeq[E] =
  if (p(this)) Vector(this)
  else (this.findAllChildElems flatMap (_.findTopmostElemsOrSelf(p)))

final def findWithElemPath(path: ElemPath): Option[Elem]

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

def findWithElemPathEntry(entry: Entry): Option[Elem]

Returns the equivalent of findWithElemPath(ElemPath(immutable.IndexedSeq(entry))), but it should be very efficient.

final def getChildElem(expandedName: EName): Elem

Returns the single child element with the given expanded name, and throws an exception otherwise

final def getChildElem(p: (Elem) ⇒ Boolean): Elem

Returns the single child element obeying the given predicate, and throws an exception otherwise.

final def getChildElemPath(p: (Elem) ⇒ Boolean): ElemPath

Returns the path of the single child element obeying the given predicate, and throws an exception otherwise

final def getClass(): java.lang.Class[_]

final def getWithElemPath(path: ElemPath): Elem

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

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def localName: String

The local name (or local part).

final def minusChild(index: Int): Elem

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

final def ne(arg0: AnyRef): Boolean

def normalizeAllText: Elem

Returns a copy where text nodes have been normalized, throughout the node tree.

final def normalizedText: String

Returns XmlStringUtils.normalizeString(text).

final def notify(): Unit

final def notifyAll(): Unit

final def plusChild(child: Node): Elem

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

final def plusChild(index: Int, child: Node): Elem

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

def productArity: Int

def productElement(arg0: Int): Any

def productIterator: Iterator[Any]

def productPrefix: String

def removeAllInterElementWhitespace: Elem

Returns a copy where inter-element whitespace has been removed, throughout the node tree

val resolvedAttributes: Map[EName, String]

The attributes as a mapping from ENames (instead of QNames) to values.

val resolvedName: EName

Resolved name of the element, as EName

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

def text: String

Returns the concatenation of the texts of text children, including whitespace.

def textChildren: IndexedSeq[Text]

Returns the text children

def toString(): String

def transformChildElems(f: (Elem) ⇒ Elem): Elem

Returns the same element, except that child elements have been replaced by applying the given function.

val newChildren =
  children map {
    case e: E => f(e)
    case n: N => n
  }
withChildren(newChildren)

def transformChildElemsToNodeSeq(f: (Elem) ⇒ IndexedSeq[Node]): Elem

Returns the same element, except that child elements have been replaced by applying the given function.

val newChildren =
  children flatMap {
    case e: E => f(e)
    case n: N => Vector(n)
  }
withChildren(newChildren)

final def transformElems(f: (Elem) ⇒ Elem): Elem

Transforms the element by applying the given function to all its descendant elements, in a bottom-up manner.

transformChildElems (e => e.transformElemsOrSelf(f))

final def transformElemsOrSelf(f: (Elem) ⇒ Elem): Elem

Transforms the element by applying the given function to all its descendant-or-self elements, in a bottom-up manner.

f(transformChildElems (e => e.transformElemsOrSelf(f)))

f(transformElems(f))

final def transformElemsOrSelfToNodeSeq(f: (Elem) ⇒ IndexedSeq[Node]): IndexedSeq[Node]

Transforms each descendant element to a node sequence by applying the given function to all its descendant-or-self elements, in a bottom-up manner.

f(transformChildElemsToNodeSeq(e => e.transformElemsOrSelfToNodeSeq(f)))

f(transformElemsToNodeSeq(f))

final def transformElemsToNodeSeq(f: (Elem) ⇒ IndexedSeq[Node]): Elem

Transforms each descendant element to a node sequence by applying the given function to all its descendant elements, in a bottom-up manner.

transformChildElemsToNodeSeq(e => e.transformElemsOrSelfToNodeSeq(f))

transformElemsOrSelf { e => e.transformChildElemsToNodeSeq(che => f(che)) }

final def trimmedText: String

Returns text.trim.

final def updated(path: ElemPath, newElem: Elem): Elem

Returns updated(path) { e => newElem }

final def updated(path: ElemPath)(f: (Elem) ⇒ Elem): Elem

Method that "functionally updates" the tree with this element as root element, by applying the passed function to the element that has the given ElemPath (compared to this element as root).

if (path == ElemPath.Root) f(self)
else updated(path.firstEntry) { e => e.updated(path.withoutFirstEntry)(f) }

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

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 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: (Elem, Entry) ⇒ Elem): Elem

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 = childNodeIndexesByPathEntries.filterKeys(pathEntries).foldLeft(children) {
  case (acc, (pathEntry, idx)) =>
    acc.updated(idx, f(acc(idx).asInstanceOf[E], pathEntry))
}
withChildren(newChildren)

final def updatedAtPaths(paths: Set[ElemPath])(f: (Elem, ElemPath) ⇒ Elem): Elem

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[ElemPath])(f: (E, ElemPath) => E): E = {
  val pathsByPathEntries = paths.filter(path => !path.isRoot).groupBy(path => path.firstEntry)
  val resultWithoutSelf = self.updatedAtPathEntries(pathsByPathEntries.keySet) { (che, pathEntry) =>
    val che = findWithElemPathEntry(pathEntry).get
    val newChe = che.updatedAtPaths(paths.map(_.withoutFirstEntry)) { (elem, relativePath) =>
      f(elem, relativePath.prepend(pathEntry))
    }
    newChe
  }
  if (paths.contains(ElemPath.Root)) f(resultWithoutSelf, ElemPath.Root) else resultWithoutSelf
}

val pathsReversed = findAllElemOrSelfPaths.filter(p => paths.contains(p)).reverse
pathsReversed.foldLeft(self) { case (acc, path) => acc.updated(path) { e => f(e, path) } }

final def updatedWithNodeSeq(path: ElemPath, newNodes: IndexedSeq[Node]): Elem

Returns updatedWithNodeSeq(path) { e => newNodes }

final def updatedWithNodeSeq(path: ElemPath)(f: (Elem) ⇒ IndexedSeq[Node]): Elem

"Functionally updates" the tree with this element as root element, by applying the passed function to the element that has the given ElemPath (compared to this element as root).

// First define function g as follows:

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

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

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

final def updatedWithNodeSeqAtPathEntries(pathEntries: Set[Entry])(f: (Elem, Entry) ⇒ IndexedSeq[Node]): Elem

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 = childNodeIndexesByPathEntries.filterKeys(pathEntries)
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[ElemPath])(f: (Elem, ElemPath) ⇒ IndexedSeq[Node]): Elem

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

def withChildren(newChildren: IndexedSeq[Node]): Elem

Creates a copy, but with (only) the children passed as parameter newChildren

final def withPatchedChildren(from: Int, newChildren: IndexedSeq[Node], replace: Int): Elem

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

final def withUpdatedChildren(index: Int, newChild: Node): Elem

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

def productElements: Iterator[Any]