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

def childNodeIndex(childPathEntry: Entry): Int

Returns the child node index of the given ElemPath.Entry with respect to this element as parent element.

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

final def topmostUpdated(pf: PartialFunction[Elem, Elem]): Elem

Functionally updates the topmost descendant-or-self elements for which the partial function is defined, within the tree of which this element is the root element.

val p = { e: E => pf.isDefinedAt(e) }
val pathsReversed = findTopmostElemOrSelfPaths(p).reverse

pathsReversed.foldLeft(self) { case (acc, path) =>
  val e = acc.findWithElemPath(path).get
  acc.updated(path, pf(e))
}

final def trimmedText: String

Returns text.trim.

final def updated(pf: PartialFunction[Elem, Elem]): Elem

Functionally updates the descendant-or-self elements for which the partial function is defined, within the tree of which this element is the root element.

val p = { e: E => pf.isDefinedAt(e) }
val pathsReversed = filterElemOrSelfPaths(p).reverse

pathsReversed.foldLeft(self) { case (acc, path) =>
  val e = acc.findWithElemPath(path).get
  acc.updated(path, pf(e))
}

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

Returns updated(path) { e => newElem }

final def updated(path: ElemPath)(f: (Elem) ⇒ Elem): 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).

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]