Index

Modules: parsexml, src/fusion/btreetables, src/fusion/docutils, src/fusion/filepermissions, src/fusion/htmlparser, src/fusion/htmlparser/xmltree, src/fusion/pointers, src/fusion/pools.

API symbols

`$`:

• btreetables: `$`[A](t: CountTable[A]): string
• btreetables: `$`[A](t: CountTableRef[A]): string
• btreetables: `$`[A, B](t: OrderedTable[A, B]): string
• btreetables: `$`[A, B](t: OrderedTableRef[A, B]): string
• btreetables: `$`[A, B](t: Table[A, B]): string
• btreetables: `$`[A, B](t: TableRef[A, B]): string
• xmltree: `$`(n: XmlNode): string

`<>`:

• xmltree: `<>`(x: untyped): untyped

`==`:

• btreetables: `==`[A](s, t: CountTable[A]): bool
• btreetables: `==`[A](s, t: CountTableRef[A]): bool
• btreetables: `==`[A, B](s, t: OrderedTable[A, B]): bool
• btreetables: `==`[A, B](s, t: OrderedTableRef[A, B]): bool
• btreetables: `==`[A, B](a, b: Table[A, B]): bool
• btreetables: `==`[A, B](s, t: TableRef[A, B]): bool

`[]=`:

• btreetables: `[]=`[A](t: var CountTable[A]; key: A; val: int)
• btreetables: `[]=`[A](t: CountTableRef[A]; key: A; val: int)
• btreetables: `[]=`[A, B](t: var OrderedTable[A, B]; k: A; v: B)
• btreetables: `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: B)
• btreetables: `[]=`[A, B](t: var Table[A, B]; key: A; val: B)
• btreetables: `[]=`[A, B](t: TableRef[A, B]; key: A; val: B)

`[]`:

• btreetables: `[]`[A](t: CountTable[A]; key: A): int
• btreetables: `[]`[A](t: CountTableRef[A]; key: A): int
• btreetables: `[]`[A, B](t: OrderedTable[A, B]; key: A): B
• btreetables: `[]`[A, B](t: var OrderedTable[A, B]; key: A): var B
• btreetables: `[]`[A, B](t: OrderedTableRef[A, B]; key: A): var B
• btreetables: `[]`[A, B](t: Table[A, B]; x: A): B
• btreetables: `[]`[A, B](t: var Table[A, B]; x: A): var B
• btreetables: `[]`[A, B](t: TableRef[A, B]; key: A): var B
• xmltree: `[]`(n: XmlNode; i: int): XmlNode
• xmltree: `[]`(n: var XmlNode; i: int): var XmlNode

add:

• btreetables: add[A, B](t: var OrderedTable[A, B]; key: A; val: B)
• xmltree: add(result: var string; n: XmlNode; indent = 0; indWidth = 2; addNewLines = true)
• xmltree: add(father, son: XmlNode)

addEscaped:

• xmltree: addEscaped(result: var string; s: string)

allowEmptyAttribs:

• XmlParseOption.allowEmptyAttribs

allowUnquotedAttribs:

• XmlParseOption.allowUnquotedAttribs

attr:

• xmltree: attr(n: XmlNode; name: string): string

attrKey:

• parsexml: attrKey(my: XmlParser): string

attrs:

• xmltree: attrs(n: XmlNode): XmlAttributes

attrs=:

• xmltree: attrs=(n: XmlNode; attr: XmlAttributes)

attrsLen:

• xmltree: attrsLen(n: XmlNode): int

attrValue:

• parsexml: attrValue(my: XmlParser): string

BlockTags:

• htmlparser: BlockTags

charData:

• parsexml: charData(my: XmlParser): string

child:

• xmltree: child(n: XmlNode; name: string): XmlNode

chmod:

• filepermissions: chmod(path: string; permissions: Natural)

clear:

• btreetables: clear[A](t: var CountTable[A])
• btreetables: clear[A](t: CountTableRef[A])
• btreetables: clear[A, B](t: var OrderedTable[A, B])
• btreetables: clear[A, B](t: OrderedTableRef[A, B])
• btreetables: clear[A, B](t: var Table[A, B])
• btreetables: clear[A, B](t: TableRef[A, B])
• xmltree: clear(n: var XmlNode)

clientData:

• xmltree: clientData(n: XmlNode): int

clientData=:

• xmltree: clientData=(n: XmlNode; data: int)

close:

• parsexml: close(my: var XmlParser)

contains:

• btreetables: contains[A](t: CountTable[A]; key: A): bool
• btreetables: contains[A](t: CountTableRef[A]; key: A): bool
• btreetables: contains[A, B](t: OrderedTable[A, B]; key: A): bool
• btreetables: contains[A, B](t: OrderedTableRef[A, B]; key: A): bool
• btreetables: contains[A, B](t: Table[A, B]; x: A): bool
• btreetables: contains[A, B](t: TableRef[A, B]; key: A): bool

CountTable:

• btreetables: CountTable

CountTableRef:

• btreetables: CountTableRef

del:

• btreetables: del[A](t: var CountTable[A]; key: A)
• btreetables: del[A](t: CountTableRef[A]; key: A)
• btreetables: del[A, B](t: var OrderedTable[A, B]; key: A)
• btreetables: del[A, B](t: OrderedTableRef[A, B]; key: A)
• btreetables: del[A, B](t: var Table[A, B]; key: A)
• btreetables: del[A, B](t: TableRef[A, B]; key: A)

delete:

• btreetables: delete[A, B](t: var OrderedTable[A, B]; key: A)
• btreetables: delete[A, B](t: OrderedTableRef[A, B]; key: A)
• xmltree: delete(n: XmlNode; i: Natural)

elementName:

• parsexml: elementName(my: XmlParser): string

entityName:

• parsexml: entityName(my: XmlParser): string

entityToRune:

• htmlparser: entityToRune(entity: string): Rune

entityToUtf8:

• htmlparser: entityToUtf8(entity: string): string

errAttributeValueExpected:

• XmlErrorKind.errAttributeValueExpected

errEndOfCDataExpected:

• XmlErrorKind.errEndOfCDataExpected

errEndOfCommentExpected:

• XmlErrorKind.errEndOfCommentExpected

errEqExpected:

• XmlErrorKind.errEqExpected

errGtExpected:

• XmlErrorKind.errGtExpected

errNameExpected:

• XmlErrorKind.errNameExpected

errNone:

• XmlErrorKind.errNone

errorMsg:

• parsexml: errorMsg(my: XmlParser): string
• parsexml: errorMsg(my: XmlParser; msg: string): string

errorMsgExpected:

• parsexml: errorMsgExpected(my: XmlParser; tag: string): string

errQmGtExpected:

• XmlErrorKind.errQmGtExpected

errQuoteExpected:

• XmlErrorKind.errQuoteExpected

errSemicolonExpected:

• XmlErrorKind.errSemicolonExpected

escape:

• xmltree: escape(s: string): string

findAll:

• xmltree: findAll(n: XmlNode; tag: string; caseInsensitive = false): seq[XmlNode]
• xmltree: findAll(n: XmlNode; tag: string; result: var seq[XmlNode]; caseInsensitive = false)

findNimSrcFiles:

• docutils: findNimSrcFiles(dir: string): string

fromFilePermissions:

• filepermissions: fromFilePermissions(perm: set[FilePermission]): uint

genCodeImportAll:

• docutils: genCodeImportAll(dir: string): string

getColumn:

• parsexml: getColumn(my: XmlParser): int

getFilename:

• parsexml: getFilename(my: XmlParser): string

getLine:

• parsexml: getLine(my: XmlParser): int

getOrDefault:

• btreetables: getOrDefault[A](t: CountTable[A]; key: A; default: int = 0): int
• btreetables: getOrDefault[A](t: CountTableRef[A]; key: A; default: int): int
• btreetables: getOrDefault[A, B](t: OrderedTable[A, B]; key: A): B
• btreetables: getOrDefault[A, B](t: OrderedTable[A, B]; key: A; default: B): B
• btreetables: getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A): B
• btreetables: getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A; default: B): B
• btreetables: getOrDefault[A, B](t: Table[A, B]; x: A): B
• btreetables: getOrDefault[A, B](t: Table[A, B]; x: A; default: B): B
• btreetables: getOrDefault[A, B](t: TableRef[A, B]; key: A): B
• btreetables: getOrDefault[A, B](t: TableRef[A, B]; key: A; default: B): B

hasKey:

• btreetables: hasKey[A](t: CountTable[A]; key: A): bool
• btreetables: hasKey[A](t: CountTableRef[A]; key: A): bool
• btreetables: hasKey[A, B](t: OrderedTable[A, B]; key: A): bool
• btreetables: hasKey[A, B](t: OrderedTableRef[A, B]; key: A): bool
• btreetables: hasKey[A, B](t: Table[A, B]; x: A): bool
• btreetables: hasKey[A, B](t: TableRef[A, B]; key: A): bool

hasKeyOrPut:

• btreetables: hasKeyOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): bool
• btreetables: hasKeyOrPut[A, B](t: var OrderedTableRef[A, B]; key: A; val: B): bool
• btreetables: hasKeyOrPut[A, B](t: var Table[A, B]; key: A; val: B): bool
• btreetables: hasKeyOrPut[A, B](t: var TableRef[A, B]; key: A; val: B): bool

HTML:

• Module parsexml

HtmlTag:

• htmlparser: HtmlTag

htmlTag:

• htmlparser: htmlTag(s: string): HtmlTag
• htmlparser: htmlTag(n: XmlNode): HtmlTag

inc:

• btreetables: inc[A](t: var CountTable[A]; key: A; val: Positive = 1)
• btreetables: inc[A](t: CountTableRef[A]; key: A; val = 1)

initCountTable:

• btreetables: initCountTable[A](initialSize = 64): CountTable[A]

initOrderedTable:

• btreetables: initOrderedTable[A, B](initialSize = 64): OrderedTable[A, B]

initTable:

• btreetables: initTable[A, B](initialSize = 0): Table[A, B]

InlineTags:

• htmlparser: InlineTags

innerText:

• xmltree: innerText(n: XmlNode): string

insert:

• xmltree: insert(father, son: XmlNode; index: int)

items:

• xmltree: items(n: XmlNode): XmlNode

keys:

• btreetables: keys[A](t: CountTable[A]): A
• btreetables: keys[A](t: CountTableRef[A]): A
• btreetables: keys[A, B](t: OrderedTable[A, B]): A
• btreetables: keys[A, B](t: OrderedTableRef[A, B]): A
• btreetables: keys[A, B](t: Table[A, B]): A
• btreetables: keys[A, B](t: TableRef[A, B]): A

keysBetween:

• btreetables: keysBetween[A, B](b: Table[A, B]; fromKey: A; toKey: A): A

keysFrom:

• btreetables: keysFrom[A, B](b: Table[A, B]; fromKey: A): A

kind:

• parsexml: kind(my: XmlParser): XmlEventKind
• xmltree: kind(n: XmlNode): XmlNodeKind

largest:

• btreetables: largest[A](t: CountTable[A]): tuple[key: A, val: int]
• btreetables: largest[A](t: CountTableRef[A]): (A, int)

len:

• btreetables: len[A](t: CountTable[A]): int
• btreetables: len[A](t: CountTableRef[A]): int
• btreetables: len[A, B](t: OrderedTable[A, B]): int
• btreetables: len[A, B](t: OrderedTableRef[A, B]): int
• btreetables: len[A, B](t: Table[A, B]): int
• btreetables: len[A, B](t: TableRef[A, B]): int
• xmltree: len(n: XmlNode): int

loadHtml:

• htmlparser: loadHtml(path: string): XmlNode
• htmlparser: loadHtml(path: string; errors: var seq[string]): XmlNode

merge:

• btreetables: merge[A](s: var CountTable[A]; t: CountTable[A])
• btreetables: merge[A](s, t: CountTableRef[A])

mgetOrPut:

• btreetables: mgetOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): var B
• btreetables: mgetOrPut[A, B](t: OrderedTableRef[A, B]; key: A; val: B): var B
• btreetables: mgetOrPut[A, B](t: var Table[A, B]; key: A; val: B): var B
• btreetables: mgetOrPut[A, B](t: TableRef[A, B]; key: A; val: B): var B

mitems:

• xmltree: mitems(n: var XmlNode): var XmlNode

mpairs:

• btreetables: mpairs[A](t: var CountTable[A]): (A, var int)
• btreetables: mpairs[A](t: CountTableRef[A]): (A, var int)
• btreetables: mpairs[A, B](t: var OrderedTable[A, B]): (A, var B)
• btreetables: mpairs[A, B](t: OrderedTableRef[A, B]): (A, var B)
• btreetables: mpairs[A, B](t: var Table[A, B]): (A, var B)
• btreetables: mpairs[A, B](t: TableRef[A, B]): (A, var B)

mvalues:

• btreetables: mvalues[A](t: var CountTable[A]): var int
• btreetables: mvalues[A](t: CountTableRef[A]): var int
• btreetables: mvalues[A, B](t: var OrderedTable[A, B]): var B
• btreetables: mvalues[A, B](t: OrderedTableRef[A, B]): var B
• btreetables: mvalues[A, B](t: var Table[A, B]): var B
• btreetables: mvalues[A, B](t: TableRef[A, B]): var B

newCData:

• xmltree: newCData(cdata: string): XmlNode

newComment:

• xmltree: newComment(comment: string): XmlNode

newCountTable:

• btreetables: newCountTable[A](initialSize = 64): CountTableRef[A]
• btreetables: newCountTable[A](keys: openArray[A]): CountTableRef[A]

newElement:

• xmltree: newElement(tag: string): XmlNode

newEntity:

• xmltree: newEntity(entity: string): XmlNode

newNode:

• pools: newNode[T](p: var Pool[T]): ptr T

newOrderedTable:

• btreetables: newOrderedTable[A, B](initialSize = 64): OrderedTableRef[A, B]
• btreetables: newOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B]

newTable:

• btreetables: newTable[A, B](): TableRef[A, B]
• btreetables: newTable[A, B](pairs: openArray[(A, B)]): TableRef[A, B]

newTableFrom:

• btreetables: newTableFrom[A, B, C](collection: A; index: proc (x: B): C): TableRef[C, B]

newText:

• xmltree: newText(text: string): XmlNode

newVerbatimText:

• xmltree: newVerbatimText(text: string): XmlNode

newXmlTree:

• xmltree: newXmlTree(tag: string; children: openArray[XmlNode]; attributes: XmlAttributes = nil): XmlNode

next:

• parsexml: next(my: var XmlParser)

open:

• parsexml: open(my: var XmlParser; input: Stream; filename: string; options: set[XmlParseOption] = {})

OrderedTable:

• btreetables: OrderedTable

OrderedTableRef:

• btreetables: OrderedTableRef

pairs:

• btreetables: pairs[A](t: CountTable[A]): (A, int)
• btreetables: pairs[A](t: CountTableRef[A]): (A, int)
• btreetables: pairs[A, B](t: OrderedTable[A, B]): (A, B)
• btreetables: pairs[A, B](t: OrderedTableRef[A, B]): (A, B)
• btreetables: pairs[A, B](t: Table[A, B]): (A, B)
• btreetables: pairs[A, B](t: TableRef[A, B]): (A, B)

pairsBetween:

• btreetables: pairsBetween[A, B](b: Table[A, B]; fromKey: A; toKey: A): tuple[key: A, val: B]

pairsFrom:

• btreetables: pairsFrom[A, B](b: Table[A, B]; fromKey: A): tuple[key: A, val: B]

parseHtml:

• htmlparser: parseHtml(s: Stream): XmlNode
• htmlparser: parseHtml(s: Stream; filename: string; errors: var seq[string]): XmlNode
• htmlparser: parseHtml(html: string): XmlNode

piName:

• parsexml: piName(my: XmlParser): string

piRest:

• parsexml: piRest(my: XmlParser): string

Pool:

• pools: Pool

pop:

• btreetables: pop[A](t: var CountTable[A]; key: A; val: var int): bool
• btreetables: pop[A](t: CountTableRef[A]; key: A; val: var int): bool
• btreetables: pop[A, B](t: var OrderedTable[A, B]; key: A; val: var B): bool
• btreetables: pop[A, B](t: OrderedTableRef[A, B]; key: A; val: var B): bool
• btreetables: pop[A, B](t: var Table[A, B]; key: A; val: var B): bool
• btreetables: pop[A, B](t: TableRef[A, B]; key: A; val: var B): bool

rawData:

• parsexml: rawData(my: var XmlParser): string

rawData2:

• parsexml: rawData2(my: var XmlParser): string

rawTag:

• xmltree: rawTag(n: XmlNode): string

rawText:

• xmltree: rawText(n: XmlNode): string

reportComments:

• XmlParseOption.reportComments

reportWhitespace:

• XmlParseOption.reportWhitespace

runeToEntity:

• htmlparser: runeToEntity(rune: Rune): string

SingleTags:

• htmlparser: SingleTags

smallest:

• btreetables: smallest[A](t: CountTable[A]): tuple[key: A, val: int]
• btreetables: smallest[A](t: CountTableRef[A]): (A, int)

Table:

• btreetables: Table

TableRef:

• btreetables: TableRef

tag:

• xmltree: tag(n: XmlNode): string

tag=:

• xmltree: tag=(n: XmlNode; tag: string)

tagA:

• HtmlTag.tagA

tagAbbr:

• HtmlTag.tagAbbr

tagAcronym:

• HtmlTag.tagAcronym

tagAddress:

• HtmlTag.tagAddress

tagApplet:

• HtmlTag.tagApplet

tagArea:

• HtmlTag.tagArea

tagArticle:

• HtmlTag.tagArticle

tagAside:

• HtmlTag.tagAside

tagAudio:

• HtmlTag.tagAudio

tagB:

• HtmlTag.tagB

tagBase:

• HtmlTag.tagBase

tagBasefont:

• HtmlTag.tagBasefont

tagBdi:

• HtmlTag.tagBdi

tagBdo:

• HtmlTag.tagBdo

tagBig:

• HtmlTag.tagBig

tagBlockquote:

• HtmlTag.tagBlockquote

tagBody:

• HtmlTag.tagBody

tagBr:

• HtmlTag.tagBr

tagButton:

• HtmlTag.tagButton

tagCanvas:

• HtmlTag.tagCanvas

tagCaption:

• HtmlTag.tagCaption

tagCenter:

• HtmlTag.tagCenter

tagCite:

• HtmlTag.tagCite

tagCode:

• HtmlTag.tagCode

tagCol:

• HtmlTag.tagCol

tagColgroup:

• HtmlTag.tagColgroup

tagCommand:

• HtmlTag.tagCommand

tagDatalist:

• HtmlTag.tagDatalist

tagDd:

• HtmlTag.tagDd

tagDel:

• HtmlTag.tagDel

tagDetails:

• HtmlTag.tagDetails

tagDfn:

• HtmlTag.tagDfn

tagDialog:

• HtmlTag.tagDialog

tagDir:

• HtmlTag.tagDir

tagDiv:

• HtmlTag.tagDiv

tagDl:

• HtmlTag.tagDl

tagDt:

• HtmlTag.tagDt

tagEm:

• HtmlTag.tagEm

tagEmbed:

• HtmlTag.tagEmbed

tagFieldset:

• HtmlTag.tagFieldset

tagFigcaption:

• HtmlTag.tagFigcaption

tagFigure:

• HtmlTag.tagFigure

tagFont:

• HtmlTag.tagFont

tagFooter:

• HtmlTag.tagFooter

tagForm:

• HtmlTag.tagForm

tagFrame:

• HtmlTag.tagFrame

tagFrameset:

• HtmlTag.tagFrameset

tagH1:

• HtmlTag.tagH1

tagH2:

• HtmlTag.tagH2

tagH3:

• HtmlTag.tagH3

tagH4:

• HtmlTag.tagH4

tagH5:

• HtmlTag.tagH5

tagH6:

• HtmlTag.tagH6

tagHead:

• HtmlTag.tagHead

tagHeader:

• HtmlTag.tagHeader

tagHgroup:

• HtmlTag.tagHgroup

tagHr:

• HtmlTag.tagHr

tagHtml:

• HtmlTag.tagHtml

tagI:

• HtmlTag.tagI

tagIframe:

• HtmlTag.tagIframe

tagImg:

• HtmlTag.tagImg

tagInput:

• HtmlTag.tagInput

tagIns:

• HtmlTag.tagIns

tagIsindex:

• HtmlTag.tagIsindex

tagKbd:

• HtmlTag.tagKbd

tagKeygen:

• HtmlTag.tagKeygen

tagLabel:

• HtmlTag.tagLabel

tagLegend:

• HtmlTag.tagLegend

tagLi:

• HtmlTag.tagLi

tagLink:

• HtmlTag.tagLink

tagMap:

• HtmlTag.tagMap

tagMark:

• HtmlTag.tagMark

tagMenu:

• HtmlTag.tagMenu

tagMeta:

• HtmlTag.tagMeta

tagMeter:

• HtmlTag.tagMeter

tagNav:

• HtmlTag.tagNav

tagNobr:

• HtmlTag.tagNobr

tagNoframes:

• HtmlTag.tagNoframes

tagNoscript:

• HtmlTag.tagNoscript

tagObject:

• HtmlTag.tagObject

tagOl:

• HtmlTag.tagOl

tagOptgroup:

• HtmlTag.tagOptgroup

tagOption:

• HtmlTag.tagOption

tagOutput:

• HtmlTag.tagOutput

tagP:

• HtmlTag.tagP

tagParam:

• HtmlTag.tagParam

tagPre:

• HtmlTag.tagPre

tagProgress:

• HtmlTag.tagProgress

tagQ:

• HtmlTag.tagQ

tagRp:

• HtmlTag.tagRp

tagRt:

• HtmlTag.tagRt

tagRuby:

• HtmlTag.tagRuby

tagS:

• HtmlTag.tagS

tagSamp:

• HtmlTag.tagSamp

tagScript:

• HtmlTag.tagScript

tagSection:

• HtmlTag.tagSection

tagSelect:

• HtmlTag.tagSelect

tagSmall:

• HtmlTag.tagSmall

tagSource:

• HtmlTag.tagSource

tagSpan:

• HtmlTag.tagSpan

tagStrike:

• HtmlTag.tagStrike

tagStrong:

• HtmlTag.tagStrong

tagStyle:

• HtmlTag.tagStyle

tagSub:

• HtmlTag.tagSub

tagSummary:

• HtmlTag.tagSummary

tagSup:

• HtmlTag.tagSup

tagTable:

• HtmlTag.tagTable

tagTbody:

• HtmlTag.tagTbody

tagTd:

• HtmlTag.tagTd

tagTextarea:

• HtmlTag.tagTextarea

tagTfoot:

• HtmlTag.tagTfoot

tagTh:

• HtmlTag.tagTh

tagThead:

• HtmlTag.tagThead

tagTime:

• HtmlTag.tagTime

tagTitle:

• HtmlTag.tagTitle

tagToStr:

• htmlparser: tagToStr

tagTr:

• HtmlTag.tagTr

tagTrack:

• HtmlTag.tagTrack

tagTt:

• HtmlTag.tagTt

tagU:

• HtmlTag.tagU

tagUl:

• HtmlTag.tagUl

tagUnknown:

• HtmlTag.tagUnknown

tagVar:

• HtmlTag.tagVar

tagVideo:

• HtmlTag.tagVideo

tagWbr:

• HtmlTag.tagWbr

take:

• btreetables: take[A, B](t: var Table[A, B]; key: A; val: var B): bool
• btreetables: take[A, B](t: TableRef[A, B]; key: A; val: var B): bool

text:

• xmltree: text(n: XmlNode): string

text=:

• xmltree: text=(n: XmlNode; text: string)

toCountTable:

• btreetables: toCountTable[A](keys: openArray[A]): CountTable[A]

toFilePermissions:

• filepermissions: toFilePermissions(perm: Natural): set[FilePermission]

toOrderedTable:

• btreetables: toOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTable[A, B]

toTable:

• btreetables: toTable[A, B](pairs: openArray[(A, B)]): Table[A, B]

toUncheckedArray:

• pointers: toUncheckedArray[T](a: ptr T): ptr UncheckedArray[T]

toXmlAttributes:

• xmltree: toXmlAttributes(keyValuePairs: varargs[tuple[key, val: string]]): XmlAttributes

values:

• btreetables: values[A](t: CountTable[A]): int
• btreetables: values[A](t: CountTableRef[A]): int
• btreetables: values[A, B](t: OrderedTable[A, B]): B
• btreetables: values[A, B](t: OrderedTableRef[A, B]): B
• btreetables: values[A, B](t: Table[A, B]): B
• btreetables: values[A, B](t: TableRef[A, B]): B

valuesBetween:

• btreetables: valuesBetween[A, B](b: Table[A, B]; fromKey: A; toKey: A): B

valuesFrom:

• btreetables: valuesFrom[A, B](b: Table[A, B]; fromKey: A): B

XML:

• Module parsexml

xmlAttribute:

• XmlEventKind.xmlAttribute

XmlAttributes:

• xmltree: XmlAttributes

xmlCData:

• XmlEventKind.xmlCData

xmlCharData:

• XmlEventKind.xmlCharData

xmlComment:

• XmlEventKind.xmlComment

xmlElementClose:

• XmlEventKind.xmlElementClose

xmlElementEnd:

• XmlEventKind.xmlElementEnd

xmlElementOpen:

• XmlEventKind.xmlElementOpen

xmlElementStart:

• XmlEventKind.xmlElementStart

xmlEntity:

• XmlEventKind.xmlEntity

xmlEof:

• XmlEventKind.xmlEof

xmlError:

• XmlEventKind.xmlError

XmlErrorKind:

• parsexml: XmlErrorKind

XmlEventKind:

• parsexml: XmlEventKind

xmlHeader:

• xmltree: xmlHeader

XmlNode:

• xmltree: XmlNode

XmlNodeKind:

• xmltree: XmlNodeKind

XmlParseOption:

• parsexml: XmlParseOption

XmlParser:

• parsexml: XmlParser

xmlPI:

• XmlEventKind.xmlPI

xmlSpecial:

• XmlEventKind.xmlSpecial

xmlWhitespace:

• XmlEventKind.xmlWhitespace

xnCData:

• XmlNodeKind.xnCData

xnComment:

• XmlNodeKind.xnComment

xnElement:

• XmlNodeKind.xnElement

xnEntity:

• XmlNodeKind.xnEntity

xnText:

• XmlNodeKind.xnText

xnVerbatimText:

• XmlNodeKind.xnVerbatimText