Xml

Type Members

type CPredicate = Predicate[Cursor]

Definition Classes
Predicates
type Forest = List[Content]

Definition Classes
Contents
type LChar = (CData.Line, Char)

Definition Classes
Tokens
type LStr = List[LChar]

Definition Classes
Tokens
type Line = Long

Definition Classes
CDatas
type Path = List[(List[Content], cursor.Tag, List[Content])]

Definition Classes
Cursors
type Str = List[Char]

Definition Classes
QNames

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
implicit val AttrEqual: Equal[Attr]

Definition Classes
Attrs
implicit val AttrOrder: Order[Attr]

Definition Classes
Attrs
implicit val AttrShow: Show[Attr]

Definition Classes
Attrs
implicit val CDataEqual: Equal[CData]

Definition Classes
CDatas
implicit val CDataKindEqual: Equal[CDataKind]

Definition Classes
CDataKinds
implicit val CDataKindShow: Show[CDataKind]

Definition Classes
CDataKinds
implicit val CDataShow: Show[CData]

Definition Classes
CDatas
implicit val CDataXPrint: XPrint[CData]

Definition Classes
XPrints
implicit val ContentEqual: Equal[Content]

Definition Classes
Contents
implicit val ContentShow: Show[Content]

Definition Classes
Contents
implicit val ContentXPrint: XPrint[Content]

Definition Classes
XPrints
implicit val CursorEqual: Equal[Cursor]

Definition Classes
Cursors
implicit val CursorShow: Show[Cursor]

Definition Classes
Cursors
implicit val ElementEqual: Equal[Element]

Definition Classes
Elements
implicit val ElementShow: Show[Element]

Definition Classes
Elements
implicit val ElementXPrint: XPrint[Element]

Definition Classes
XPrints
implicit val HCursorEqual: Equal[HCursor]

Definition Classes
HCursors
implicit val HCursorShow: Show[HCursor]

Definition Classes
HCursors
implicit val HistoryEqual: Equal[History]

Definition Classes
Historys
implicit val HistoryShow: Show[History]

Definition Classes
Historys
implicit val NSInfoEqual: Equal[NSInfo]

Definition Classes
NSInfos
implicit val NSInfoShow: Show[NSInfo]

Definition Classes
NSInfos
implicit def PreciateEqual[A]: Equal[Predicate[A]]

Definition Classes
Predicates
implicit def PredicateShow[A]: Show[Predicate[A]]

Definition Classes
Predicates
implicit val QNameOrder: Order[QName]

Definition Classes
QNames
implicit val QNameShow: Show[QName]

Definition Classes
QNames
implicit val StrXSource: XSource[QName.Str]

A list of characters as an XML data source.
A list of characters as an XML data source.

Definition Classes
XSources
implicit def StringXSource: XSource[String]

A string as an XML data source.
A string as an XML data source.

Definition Classes
XSources
implicit val TagEqual: Equal[cursor.Tag]

Definition Classes
Tags
implicit val TagShow: Show[cursor.Tag]

Definition Classes
Tags
implicit def ToIdentityXml[A](a: A): IdentityXml[A]

Definition Classes
IdentityXmls
implicit val TokenShow: Show[Token]

Definition Classes
Tokens
def apply(o: Op): History

Definition Classes
Historys
final def asInstanceOf[T0]: T0

Definition Classes
Any
def attr(key: QName, value: QName.Str): Attr

Definition Classes
Attrs
def attrs(key: String, value: String): Attr

Definition Classes
Attrs
def blankCdata: CData

Definition Classes
CDatas
def blankElement: Element

Definition Classes
Elements
def blankQname: QName

Definition Classes
QNames
def cdata(verbatim: CDataKind, data: QName.Str, line: Option[Line] = None): CData

Definition Classes
CDatas
val cdataRaw: CDataKind

Definition Classes
CDataKinds
val cdataText: CDataKind

Definition Classes
CDataKinds
val cdataVerbatim: CDataKind

Definition Classes
CDataKinds
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def comment(s: QName.Str): Content

Definition Classes
Contents
def commentToken(s: QName.Str): Token

Definition Classes
Tokens
def config(short_empty_tag: (QName) ⇒ Boolean = _ => true, prettify: Option[QName.Str] = None): Config

Definition Classes
Configs
def cref(s: QName.Str): Content

Definition Classes
Contents
def crefBit(s: QName.Str): Txt

Definition Classes
Txts
def crefToChar(s: QName.Str): Option[Char]

Definition Classes
XSources
def crefToken(s: QName.Str): Token

Definition Classes
Tokens
def cursor(current: Content, lefts: List[Content] = Nil, rights: List[Content] = Nil, parents: Path = Nil): Cursor

Definition Classes
Cursors
def decodeAttr(s: QName.Str): QName.Str

Definition Classes
Txts
def decodeText(s: QName.Str): List[Txt]

Definition Classes
Txts
def elem(e: Element): Content

Definition Classes
Contents
def element(name: QName, attribs: List[Attr] = Nil, content: List[Content] = Nil, line: Option[CData.Line] = None): Element

Definition Classes
Elements
def elems(c: List[Content]): List[Element]

Definition Classes
Contents
def endToken(l: CData.Line, q: QName): Token

Definition Classes
Tokens
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def falsePredicate[A]: Predicate[A]

Definition Classes
Predicates
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def findChild(p: cursor.Predicate.CPredicate): Shift

Definition Classes
Shifts
def findLeft(p: cursor.Predicate.CPredicate): Shift

Definition Classes
Shifts
def findRec(p: cursor.Predicate.CPredicate): Shift

Definition Classes
Shifts
def findRight(p: cursor.Predicate.CPredicate): Shift

Definition Classes
Shifts
def firstChild: Shift

Definition Classes
Shifts
def forestToCursor(forest: Forest): Option[Cursor]

Definition Classes
Contents
def forestToCursorOr(forest: Forest, c: ⇒ Cursor): Cursor

Definition Classes
Contents
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def hcursor(history: History = History.history, cursor: Option[Cursor] = None): HCursor

Definition Classes
HCursors
def hcursorc(history: History = History.history, cursor: Cursor): HCursor

Definition Classes
HCursors
def history: History

Definition Classes
Historys
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lastChild: Shift

Definition Classes
Shifts
def left: Shift

Definition Classes
Shifts
def lookup(n: QName, as: List[Attr]): Option[QName.Str]

Definition Classes
Attrs
def lookupBy(p: (QName) ⇒ Boolean, as: List[Attr]): Option[QName.Str]

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

Definition Classes
AnyRef
def nextDepthFirst: Shift

Definition Classes
Shifts
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def npredicate[A](p: (A) ⇒ Boolean, n: String): Predicate[A]

Definition Classes
Predicates
def nsInfo(prefixes: List[(QName.Str, QName.Str)], uri: Option[QName.Str] = None): NSInfo

Definition Classes
NSInfos
def nthChild(n: ⇒ Int): Shift

Definition Classes
Shifts
def parent: Shift

Definition Classes
Shifts
def parse(ts: List[Token]): List[Content]

Definition Classes
Tokens
def point: Shift

Definition Classes
Shifts
def predicate[A](p: (A) ⇒ Boolean, n: Option[List[Char]] = None): Predicate[A]

Definition Classes
Predicates
val pretty: Config

Definition Classes
Configs
def qname(name: Str, uri: Option[Str] = None, prefix: Option[Str] = None): QName

Definition Classes
QNames
def qnames(name: String, uri: Option[Str] = None, prefix: Option[Str] = None): QName

Definition Classes
QNames
def remove: Shift

Definition Classes
Shifts
def removeLeft: Shift

Definition Classes
Shifts
def removeRight: Shift

Definition Classes
Shifts
def right: Shift

Definition Classes
Shifts
def root: Shift

Definition Classes
Shifts
def shift(k: (Cursor) ⇒ HCursor): Shift

Definition Classes
Shifts
def shiftChoice(s: Shift*): Shift

Definition Classes
Shifts
def shiftConcat(s: Shift*): Shift

Definition Classes
Shifts
def shiftSplit(history: (Cursor) ⇒ History, cursor: (Cursor) ⇒ Option[Cursor]): Shift

Definition Classes
Shifts
def shiftSplits(history: (Cursor) ⇒ History, cursor: (Cursor) ⇒ Cursor): Shift

Definition Classes
Shifts
def shifts(k: (Cursor) ⇒ Cursor): Shift

Definition Classes
Shifts
def showAttr(a: Attr): List[Char]

Definition Classes
XPrints
def showCdata(d: CData): List[Char]

Definition Classes
XPrints
def showQname(n: QName): List[Char]

Definition Classes
XPrints
def startToken(l: CData.Line, q: QName, a: List[Attr], e: Boolean): Token

Definition Classes
Tokens
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tag(name: QName, attribs: List[Attr] = Nil, line: Option[CData.Line] = None): cursor.Tag

Definition Classes
Tags
def text(d: CData): Content

Definition Classes
Contents
def textToken(d: CData): Token

Definition Classes
Tokens
def texts(c: List[Content]): List[CData]

Definition Classes
Contents
def toString(): String

Definition Classes
AnyRef → Any
def tokens(s: Token.LStr): List[Token]

Definition Classes
XSources
def truePredicate[A]: Predicate[A]

Definition Classes
Predicates
def txtBit(s: QName.Str): Txt

Definition Classes
Txts
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 xprint[A](f: (A) ⇒ (Config) ⇒ List[Char]): XPrint[A]

Definition Classes
XPrints
def xprints[A](f: (A) ⇒ (Config) ⇒ String): XPrint[A]

Definition Classes
XPrints
def xsource[S](f: (S) ⇒ Option[(Char, S)]): XSource[S]

Definition Classes
XSources

Related Doc: package xml

object Xml extends Xmls

Type Members

type CPredicate = Predicate[Cursor]

type Forest = List[Content]

type LChar = (CData.Line, Char)

type LStr = List[LChar]

type Line = Long

type Path = List[(List[Content], cursor.Tag, List[Content])]

type Str = List[Char]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit val AttrEqual: Equal[Attr]

implicit val AttrOrder: Order[Attr]

implicit val AttrShow: Show[Attr]

implicit val CDataEqual: Equal[CData]

implicit val CDataKindEqual: Equal[CDataKind]

implicit val CDataKindShow: Show[CDataKind]

implicit val CDataShow: Show[CData]

implicit val CDataXPrint: XPrint[CData]

implicit val ContentEqual: Equal[Content]

implicit val ContentShow: Show[Content]

implicit val ContentXPrint: XPrint[Content]

implicit val CursorEqual: Equal[Cursor]

implicit val CursorShow: Show[Cursor]

implicit val ElementEqual: Equal[Element]

implicit val ElementShow: Show[Element]

implicit val ElementXPrint: XPrint[Element]

implicit val HCursorEqual: Equal[HCursor]

implicit val HCursorShow: Show[HCursor]

implicit val HistoryEqual: Equal[History]

implicit val HistoryShow: Show[History]

implicit val NSInfoEqual: Equal[NSInfo]

implicit val NSInfoShow: Show[NSInfo]

implicit def PreciateEqual[A]: Equal[Predicate[A]]

implicit def PredicateShow[A]: Show[Predicate[A]]

implicit val QNameOrder: Order[QName]

implicit val QNameShow: Show[QName]

implicit val StrXSource: XSource[QName.Str]

implicit def StringXSource: XSource[String]

implicit val TagEqual: Equal[cursor.Tag]

implicit val TagShow: Show[cursor.Tag]

implicit def ToIdentityXml[A](a: A): IdentityXml[A]

implicit val TokenShow: Show[Token]

def apply(o: Op): History

final def asInstanceOf[T0]: T0

def attr(key: QName, value: QName.Str): Attr

def attrs(key: String, value: String): Attr

def blankCdata: CData

def blankElement: Element

def blankQname: QName

def cdata(verbatim: CDataKind, data: QName.Str, line: Option[Line] = None): CData

val cdataRaw: CDataKind

val cdataText: CDataKind

val cdataVerbatim: CDataKind

def clone(): AnyRef

def comment(s: QName.Str): Content

def commentToken(s: QName.Str): Token

def config(short_empty_tag: (QName) ⇒ Boolean = _ => true, prettify: Option[QName.Str] = None): Config

def cref(s: QName.Str): Content

def crefBit(s: QName.Str): Txt

def crefToChar(s: QName.Str): Option[Char]

def crefToken(s: QName.Str): Token

def cursor(current: Content, lefts: List[Content] = Nil, rights: List[Content] = Nil, parents: Path = Nil): Cursor

def decodeAttr(s: QName.Str): QName.Str

def decodeText(s: QName.Str): List[Txt]

def elem(e: Element): Content

def element(name: QName, attribs: List[Attr] = Nil, content: List[Content] = Nil, line: Option[CData.Line] = None): Element

def elems(c: List[Content]): List[Element]

def endToken(l: CData.Line, q: QName): Token

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def falsePredicate[A]: Predicate[A]

def finalize(): Unit

def findChild(p: cursor.Predicate.CPredicate): Shift

def findLeft(p: cursor.Predicate.CPredicate): Shift

def findRec(p: cursor.Predicate.CPredicate): Shift