Document

Document. Although at first sight the document root element seems to be the root node, this is not entirely true. For example, there may be comments at top level, outside the document root element.

The document is itself not a Node. This choice has the following advantages:

Documents are indeed prevented (at compile-time) from occurring as "child nodes"
The API is cleaner. For example, (unlike "elements") document methods like toTreeRepr should not be passed a parent scope. By not considering a Document a Node, it is more visible that parent scopes are irrelevant for Documents, unlike for "elements".

A Document is constructed from an optional URI, a document element (as Elem), top-level processing instructions, if any, and top-level comments, if any.

Note that class Document does not have any query methods for Elem instances. In particular, the ElemApi does not apply to documents. Therefore, given a document, querying for elements (other than the document element itself) always goes via the document element.

Annotations: @SerialVersionUID()

Linear Supertypes

Serializable, Serializable, Immutable, DocumentApi[Elem], AnyRef, Any

Instance Constructors

new Document(uriOption: Option[URI], documentElement: Elem, processingInstructions: IndexedSeq[ProcessingInstruction], comments: IndexedSeq[Comment])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def allComments: IndexedSeq[Comment]

Expensive method to obtain all comments, throughout the tree
def allProcessingInstructions: IndexedSeq[ProcessingInstruction]

Expensive method to obtain all processing instructions, throughout the tree
final def asInstanceOf[T0]: T0

Definition Classes
Any
def children: IndexedSeq[Node]

Returns the immediate child nodes of the document.
Returns the immediate child nodes of the document. That includes at least the document element, but top-level comments and processing instructions are also returned.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val comments: IndexedSeq[Comment]
val documentElement: Elem

Returns the document element
Returns the document element

Definition Classes
Document → DocumentApi
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val processingInstructions: IndexedSeq[ProcessingInstruction]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def toString(): String

Returns the tree representation string corresponding to this element, that is, toTreeRepr.
Returns the tree representation string corresponding to this element, that is, toTreeRepr. Possibly expensive!

Definition Classes
Document → AnyRef → Any
final def toTreeRepr(): String
def transformElemsOrSelf(f: (Elem) ⇒ Elem): Document

Returns withDocumentElement(this.documentElement.transformElemsOrSelf(f))
def transformElemsToNodeSeq(f: (Elem) ⇒ IndexedSeq[Node]): Document

Returns withDocumentElement(this.documentElement.transformElemsToNodeSeq(f))
def updated(path: Path, newElem: Elem): Document

Returns updated(path) { e => newElem }
def updated(path: Path)(f: (Elem) ⇒ Elem): Document

Returns withDocumentElement(this.documentElement.updated(path)(f)).
def updatedAtPaths(paths: Set[Path])(f: (Elem, Path) ⇒ Elem): Document

Returns withDocumentElement(this.documentElement.updatedAtPaths(paths)(f))
def updatedWithNodeSeq(path: Path, newNodes: IndexedSeq[Node]): Document

Returns withDocumentElement(this.documentElement.updatedWithNodeSeq(path, newNodes))
def updatedWithNodeSeq(path: Path)(f: (Elem) ⇒ IndexedSeq[Node]): Document

Returns withDocumentElement(this.documentElement.updatedWithNodeSeq(path)(f))
val uriOption: Option[URI]

Returns the optional document URI, wrapped in an Option
Returns the optional document URI, wrapped in an Option

Definition Classes
Document → DocumentApi
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withDocumentElement(newRoot: Elem): Document

Creates a copy, but with the new documentElement passed as parameter newRoot
def withUriOption(newUriOption: Option[URI]): Document

Creates a copy, but with the new uriOption passed as parameter newUriOption

final class Document extends DocumentApi[Elem] with Immutable with Serializable

Instance Constructors

new Document(uriOption: Option[URI], documentElement: Elem, processingInstructions: IndexedSeq[ProcessingInstruction], comments: IndexedSeq[Comment])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def allComments: IndexedSeq[Comment]

def allProcessingInstructions: IndexedSeq[ProcessingInstruction]

final def asInstanceOf[T0]: T0

def children: IndexedSeq[Node]

def clone(): AnyRef

val comments: IndexedSeq[Comment]

val documentElement: Elem

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 ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val processingInstructions: IndexedSeq[ProcessingInstruction]

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

final def toString(): String

final def toTreeRepr(): String

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

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

def updated(path: Path, newElem: Elem): Document

def updated(path: Path)(f: (Elem) ⇒ Elem): Document

def updatedAtPaths(paths: Set[Path])(f: (Elem, Path) ⇒ Elem): Document

def updatedWithNodeSeq(path: Path, newNodes: IndexedSeq[Node]): Document

def updatedWithNodeSeq(path: Path)(f: (Elem) ⇒ IndexedSeq[Node]): Document

val uriOption: Option[URI]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withDocumentElement(newRoot: Elem): Document

def withUriOption(newUriOption: Option[URI]): Document

Inherited from Serializable

Inherited from Serializable

Inherited from Immutable

Inherited from DocumentApi[Elem]

Inherited from AnyRef

Inherited from Any

Ungrouped