Index (original) (raw)

Modules: src/fusion/astdsl, src/fusion/btreetables, src/fusion/compat, src/fusion/docutils, src/fusion/filepermissions, src/fusion/htmlparser, src/fusion/htmlparser/parsexml, src/fusion/htmlparser/xmltree, src/fusion/ioutils, src/fusion/js/jssets, src/fusion/js/jsxmlhttprequest, src/fusion/js/jsxmlserializer, src/fusion/matching, src/fusion/pointers, src/fusion/pools, src/fusion/scripting, src/fusion/smartptrs, stdinfile.

API symbols

`$`:

• btreetables: proc `$`[A](t: CountTable[A]): string
• btreetables: proc `$`[A](t: CountTableRef[A]): string
• btreetables: proc `$`[A, B](t: OrderedTable[A, B]): string
• btreetables: proc `$`[A, B](t: OrderedTableRef[A, B]): string
• btreetables: proc `$`[A, B](t: Table[A, B]): string
• btreetables: proc `$`[A, B](t: TableRef[A, B]): string
• xmltree: proc `$`(n: XmlNode): string
• jssets: proc `$`(this: JsSet): string
• matching: proc `$`(kvp: KVPair): string
• matching: proc `$`(match: Match): string
• matching: proc `$`(path: Path): string
• matching: proc `$`(ss: SeqStructure): string
• smartptrs: proc `$`[T](p: ConstPtr[T]): string
• smartptrs: proc `$`[T](p: SharedPtr[T]): string
• smartptrs: proc `$`[T](p: UniquePtr[T]): string

`:=`:

• matching: template `:=`(lhs, rhs: untyped): untyped

`<>`:

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

`==`:

• btreetables: proc `==`[A](s, t: CountTable[A]): bool
• btreetables: proc `==`[A](s, t: CountTableRef[A]): bool
• btreetables: proc `==`[A, B](s, t: OrderedTable[A, B]): bool
• btreetables: proc `==`[A, B](s, t: OrderedTableRef[A, B]): bool
• btreetables: proc `==`[A, B](a, b: Table[A, B]): bool
• btreetables: proc `==`[A, B](s, t: TableRef[A, B]): bool
• matching: proc `==`(idx: FieldIndex; i: SomeInteger): bool

`=`:

• smartptrs: proc `=`[T](dest: var SharedPtr[T]; src: SharedPtr[T])
• smartptrs: proc `=`[T](dest: var UniquePtr[T]; src: UniquePtr[T])

`=copy`:

• pools: proc `=copy`[T](dest: var Pool[T]; src: Pool[T])

`=destroy`:

• pools: proc `=destroy`[T](p: var Pool[T])
• smartptrs: proc `=destroy`[T](p: var SharedPtr[T])
• smartptrs: proc `=destroy`[T](p: var UniquePtr[T])

`?=`:

• matching: template `?=`(lhs, rhs: untyped): untyped

`[]=`:

• btreetables: proc `[]=`[A](t: var CountTable[A]; key: A; val: int)
• btreetables: proc `[]=`[A](t: CountTableRef[A]; key: A; val: int)
• btreetables: proc `[]=`[A, B](t: var OrderedTable[A, B]; k: A; v: B)
• btreetables: proc `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: B)
• btreetables: proc `[]=`[A, B](t: var Table[A, B]; key: A; val: B)
• btreetables: proc `[]=`[A, B](t: TableRef[A, B]; key: A; val: B)
• smartptrs: proc `[]=`[T](p: SharedPtr[T]; v: T)
• smartptrs: proc `[]=`[T](p: UniquePtr[T]; v: T)
• smartptrs: template `[]=`[T](p: ConstPtr[T]; v: T)

`[]`:

• btreetables: proc `[]`[A](t: CountTable[A]; key: A): int
• btreetables: proc `[]`[A](t: CountTableRef[A]; key: A): int
• btreetables: proc `[]`[A, B](t: OrderedTable[A, B]; key: A): B
• btreetables: proc `[]`[A, B](t: var OrderedTable[A, B]; key: A): var B
• btreetables: proc `[]`[A, B](t: OrderedTableRef[A, B]; key: A): var B
• btreetables: proc `[]`[A, B](t: Table[A, B]; x: A): B
• btreetables: proc `[]`[A, B](t: var Table[A, B]; x: A): var B
• btreetables: proc `[]`[A, B](t: TableRef[A, B]; key: A): var B
• xmltree: proc `[]`(n: XmlNode; i: int): XmlNode
• xmltree: proc `[]`(n: var XmlNode; i: int): var XmlNode
• matching: template `[]`(t: tuple; idx: static[FieldIndex]): untyped
• smartptrs: proc `[]`[T](p: ConstPtr[T]): lent T
• smartptrs: proc `[]`[T](p: SharedPtr[T]): var T
• smartptrs: proc `[]`[T](p: UniquePtr[T]): var T

`case`:

• matching: macro `case`(n: untyped): untyped

abort:

• jsxmlhttprequest: proc abort(this: XMLHttpRequest)

add:

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

addEscaped:

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

allowEmptyAttribs:

• parsexml: XmlParseOption.allowEmptyAttribs

allowUnquotedAttribs:

• parsexml: XmlParseOption.allowUnquotedAttribs

assertMatch:

• matching: macro assertMatch(input, pattern: untyped): untyped

attr:

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

attrKey:

• parsexml: template attrKey(my: XmlParser): string

attrs:

• xmltree: proc attrs(n: XmlNode): XmlAttributes

attrs=:

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

attrsLen:

• xmltree: proc attrsLen(n: XmlNode): int

attrValue:

• parsexml: template attrValue(my: XmlParser): string

BlockTags:

• htmlparser: const BlockTags

buildAst:

• astdsl: macro buildAst(children: untyped): NimNode
• astdsl: macro buildAst(node, children: untyped): NimNode

charData:

• parsexml: template charData(my: XmlParser): string

child:

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

chmod:

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

clear:

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

clientData:

• xmltree: proc clientData(n: XmlNode): int

clientData=:

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

close:

• parsexml: proc close(my: var XmlParser)

ConstPtr:

• smartptrs: type ConstPtr

contains:

• btreetables: proc contains[A](t: CountTable[A]; key: A): bool
• btreetables: proc contains[A](t: CountTableRef[A]; key: A): bool
• btreetables: proc contains[A, B](t: OrderedTable[A, B]; key: A): bool
• btreetables: proc contains[A, B](t: OrderedTableRef[A, B]; key: A): bool
• btreetables: proc contains[A, B](t: Table[A, B]; x: A): bool
• btreetables: proc contains[A, B](t: TableRef[A, B]; key: A): bool
• jssets: proc contains(this: JsSet; value: JsObject): bool

convertConstPtrToObj:

• smartptrs: converter convertConstPtrToObj[T](p: ConstPtr[T]): lent T

convertSharedPtrToObj:

• smartptrs: converter convertSharedPtrToObj[T](p: SharedPtr[T]): var T

convertUniquePtrToObj:

• smartptrs: converter convertUniquePtrToObj[T](p: UniquePtr[T]): var T

CountTable:

• btreetables: object CountTable

CountTableRef:

• btreetables: type CountTableRef

del:

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

delete:

• btreetables: proc delete[A, B](t: var OrderedTable[A, B]; key: A)
• btreetables: proc delete[A, B](t: OrderedTableRef[A, B]; key: A)
• xmltree: proc delete(n: XmlNode; i: Natural)
• jssets: proc delete(this: JsSet; value: JsObject)

duplicate:

• ioutils: proc duplicate(oldfd: FileHandle): FileHandle

duplicateTo:

• ioutils: proc duplicateTo(oldfd: FileHandle; newfd: FileHandle)

elementName:

• parsexml: template elementName(my: XmlParser): string

entityName:

• parsexml: template entityName(my: XmlParser): string

entityToRune:

• htmlparser: proc entityToRune(entity: string): Rune

entityToUtf8:

• htmlparser: proc entityToUtf8(entity: string): string

errAttributeValueExpected:

• parsexml: XmlErrorKind.errAttributeValueExpected

errEndOfCDataExpected:

• parsexml: XmlErrorKind.errEndOfCDataExpected

errEndOfCommentExpected:

• parsexml: XmlErrorKind.errEndOfCommentExpected

errEqExpected:

• parsexml: XmlErrorKind.errEqExpected

errGtExpected:

• parsexml: XmlErrorKind.errGtExpected

errNameExpected:

• parsexml: XmlErrorKind.errNameExpected

errNone:

• parsexml: XmlErrorKind.errNone

errorMsg:

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

errorMsgExpected:

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

errQmGtExpected:

• parsexml: XmlErrorKind.errQmGtExpected

errQuoteExpected:

• parsexml: XmlErrorKind.errQuoteExpected

errSemicolonExpected:

• parsexml: XmlErrorKind.errSemicolonExpected

escape:

• xmltree: proc escape(s: string): string

expand:

• matching: macro expand(body: typed): untyped

FieldIndex:

• matching: type FieldIndex

findAll:

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

findNimSrcFiles:

• docutils: iterator findNimSrcFiles(dir: string): string

fromFilePermissions:

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

genCodeImportAll:

• docutils: proc genCodeImportAll(dir: string): string

getAllResponseHeaders:

• jsxmlhttprequest: proc getAllResponseHeaders(this: XMLHttpRequest): cstring

getColumn:

• parsexml: proc getColumn(my: XmlParser): int

getFilename:

• parsexml: proc getFilename(my: XmlParser): string

getKindNames:

• matching: proc getKindNames(head: NimNode): (string, seq[string])

getLine:

• parsexml: proc getLine(my: XmlParser): int

getOrDefault:

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

hasKey:

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

hasKeyOrPut:

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

hasKind:

• matching: template hasKind(head, kindExpr: untyped): untyped

hasKindImpl:

• matching: macro hasKindImpl(head: typed; kind: untyped): untyped

HTML:

• parsexml: Module parsexml

HtmlTag:

• htmlparser: enum HtmlTag

htmlTag:

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

imkInfixEq:

• matching: ItemMatchKind.imkInfixEq

imkPredicate:

• matching: ItemMatchKind.imkPredicate

imkSubPattern:

• matching: ItemMatchKind.imkSubPattern

inc:

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

initCountTable:

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

initOrderedTable:

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

initTable:

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

InlineTags:

• htmlparser: const InlineTags

innerText:

• xmltree: proc innerText(n: XmlNode): string

insert:

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

isNil:

• smartptrs: proc isNil[T](p: ConstPtr[T]): bool
• smartptrs: proc isNil[T](p: SharedPtr[T]): bool
• smartptrs: proc isNil[T](p: UniquePtr[T]): bool

ItemMatchKind:

• matching: enum ItemMatchKind

items:

• xmltree: iterator items(n: XmlNode): XmlNode

JsSet:

• jssets: type JsSet

kAlt:

• matching: MatchKind.kAlt

keys:

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

keysBetween:

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

keysFrom:

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

kind:

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

kind=:

• matching: proc kind=(node: var NimNode; kind: NimNodeKind)

kItem:

• matching: MatchKind.kItem

kObject:

• matching: MatchKind.kObject

kPairs:

• matching: MatchKind.kPairs

kSeq:

• matching: MatchKind.kSeq

kSet:

• matching: MatchKind.kSet

kTuple:

• matching: MatchKind.kTuple

KVPair:

• matching: object KVPair

largest:

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

len:

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

lkAll:

• matching: SeqKeyword.lkAll

lkAny:

• matching: SeqKeyword.lkAny

lkNone:

• matching: SeqKeyword.lkNone

lkOpt:

• matching: SeqKeyword.lkOpt

lkPos:

• matching: SeqKeyword.lkPos

lkPref:

• matching: SeqKeyword.lkPref

lkSlice:

• matching: SeqKeyword.lkSlice

lkTrail:

• matching: SeqKeyword.lkTrail

lkUntil:

• matching: SeqKeyword.lkUntil

loadHtml:

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

makeMatchExpr:

• matching: proc makeMatchExpr(m: Match; mainExpr: NimNode; doRaise: bool; originalMainExpr: NimNode): tuple[expr: NimNode, vtable: VarTable, mixident: seq[string]]

makeTree:

• matching: template makeTree(T: typed; pattern: untyped): untyped

Match:

• matching: type Match

MatchError:

• matching: type MatchError

matches:

• matching: macro matches(input, pattern: untyped): untyped

MatchKind:

• matching: enum MatchKind

merge:

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

mgetOrPut:

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

mitems:

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

mpairs:

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

mvalues:

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

newCData:

• xmltree: proc newCData(cdata: string): XmlNode

newComment:

• xmltree: proc newComment(comment: string): XmlNode

newConstPtr:

• smartptrs: proc newConstPtr[T](val: sink T): ConstPtr[T]

newCountTable:

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

newElement:

• xmltree: proc newElement(tag: string): XmlNode

newEntity:

• xmltree: proc newEntity(entity: string): XmlNode

newJsSet:

• jssets: proc newJsSet(): JsSet
• jssets: proc newJsSet(items: openArray[JsObject]): JsSet

newNode:

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

newOrderedTable:

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

newSharedPtr:

• smartptrs: proc newSharedPtr[T](val: sink T): SharedPtr[T]

newTable:

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

newTableFrom:

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

newText:

• xmltree: proc newText(text: string): XmlNode

newUniquePtr:

• smartptrs: proc newUniquePtr[T](val: sink T): UniquePtr[T]

newVerbatimText:

• xmltree: proc newVerbatimText(text: string): XmlNode

newXMLHttpRequest:

• jsxmlhttprequest: proc newXMLHttpRequest(): XMLHttpRequest

newXMLSerializer:

• jsxmlserializer: proc newXMLSerializer(): XMLSerializer

newXmlTree:

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

next:

• parsexml: proc next(my: var XmlParser)

nnkFloatKinds:

• matching: const nnkFloatKinds

nnkIdentKinds:

• matching: const nnkIdentKinds

nnkIntKinds:

• matching: const nnkIntKinds

nnkStrKinds:

• matching: const nnkStrKinds

nnkTokenKinds:

• matching: const nnkTokenKinds

open:

• parsexml: proc open(my: var XmlParser; input: Stream; filename: string; options: set[XmlParseOption] = {})
• jsxmlhttprequest: proc open(this: XMLHttpRequest; metod, url: cstring; async = true; user = cstring.default; password = cstring.default)

OrderedTable:

• btreetables: object OrderedTable

OrderedTableRef:

• btreetables: type OrderedTableRef

overrideMimeType:

• jsxmlhttprequest: proc overrideMimeType(this: XMLHttpRequest; mimeType: cstring)

pairs:

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

pairsBetween:

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

pairsFrom:

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

parseHtml:

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

parseMatchExpr:

• matching: proc parseMatchExpr(n: NimNode): Match

piName:

• parsexml: template piName(my: XmlParser): string

piRest:

• parsexml: template piRest(my: XmlParser): string

Pool:

• pools: object Pool

pop:

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

rawData:

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

rawData2:

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

rawTag:

• xmltree: proc rawTag(n: XmlNode): string

rawText:

• xmltree: proc rawText(n: XmlNode): string

reportComments:

• parsexml: XmlParseOption.reportComments

reportWhitespace:

• parsexml: XmlParseOption.reportWhitespace

runeToEntity:

• htmlparser: proc runeToEntity(rune: Rune): string

send:

• jsxmlhttprequest: proc send(this: XMLHttpRequest; body: cstring | Node = cstring.default)

SeqKeyword:

• matching: enum SeqKeyword

SeqStructure:

• matching: object SeqStructure

serializeToString:

• jsxmlserializer: proc serializeToString(this: XMLSerializer; node: Node): cstring

setRequestHeader:

• jsxmlhttprequest: proc setRequestHeader(this: XMLHttpRequest; key, value: cstring)
• jsxmlhttprequest: proc setRequestHeader(this: XMLHttpRequest; keyValuePairs: openArray[tuple[key, val: cstring]])

SharedPtr:

• smartptrs: object SharedPtr

SingleTags:

• htmlparser: const SingleTags

smallest:

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

str:

• matching: proc str(node: NimNode): string

str=:

• matching: proc str=(node: var NimNode; val: string)

Table:

• btreetables: object Table

TableRef:

• btreetables: type TableRef

tag:

• xmltree: proc tag(n: XmlNode): string

tag=:

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

tagA:

• htmlparser: HtmlTag.tagA

tagAbbr:

• htmlparser: HtmlTag.tagAbbr

tagAcronym:

• htmlparser: HtmlTag.tagAcronym

tagAddress:

• htmlparser: HtmlTag.tagAddress

tagApplet:

• htmlparser: HtmlTag.tagApplet

tagArea:

• htmlparser: HtmlTag.tagArea

tagArticle:

• htmlparser: HtmlTag.tagArticle

tagAside:

• htmlparser: HtmlTag.tagAside

tagAudio:

• htmlparser: HtmlTag.tagAudio

tagB:

• htmlparser: HtmlTag.tagB

tagBase:

• htmlparser: HtmlTag.tagBase

tagBasefont:

• htmlparser: HtmlTag.tagBasefont

tagBdi:

• htmlparser: HtmlTag.tagBdi

tagBdo:

• htmlparser: HtmlTag.tagBdo

tagBig:

• htmlparser: HtmlTag.tagBig

tagBlockquote:

• htmlparser: HtmlTag.tagBlockquote

tagBody:

• htmlparser: HtmlTag.tagBody

tagBr:

• htmlparser: HtmlTag.tagBr

tagButton:

• htmlparser: HtmlTag.tagButton

tagCanvas:

• htmlparser: HtmlTag.tagCanvas

tagCaption:

• htmlparser: HtmlTag.tagCaption

tagCenter:

• htmlparser: HtmlTag.tagCenter

tagCite:

• htmlparser: HtmlTag.tagCite

tagCode:

• htmlparser: HtmlTag.tagCode

tagCol:

• htmlparser: HtmlTag.tagCol

tagColgroup:

• htmlparser: HtmlTag.tagColgroup

tagCommand:

• htmlparser: HtmlTag.tagCommand

tagDatalist:

• htmlparser: HtmlTag.tagDatalist

tagDd:

• htmlparser: HtmlTag.tagDd

tagDel:

• htmlparser: HtmlTag.tagDel

tagDetails:

• htmlparser: HtmlTag.tagDetails

tagDfn:

• htmlparser: HtmlTag.tagDfn

tagDialog:

• htmlparser: HtmlTag.tagDialog

tagDir:

• htmlparser: HtmlTag.tagDir

tagDiv:

• htmlparser: HtmlTag.tagDiv

tagDl:

• htmlparser: HtmlTag.tagDl

tagDt:

• htmlparser: HtmlTag.tagDt

tagEm:

• htmlparser: HtmlTag.tagEm

tagEmbed:

• htmlparser: HtmlTag.tagEmbed

tagFieldset:

• htmlparser: HtmlTag.tagFieldset

tagFigcaption:

• htmlparser: HtmlTag.tagFigcaption

tagFigure:

• htmlparser: HtmlTag.tagFigure

tagFont:

• htmlparser: HtmlTag.tagFont

tagFooter:

• htmlparser: HtmlTag.tagFooter

tagForm:

• htmlparser: HtmlTag.tagForm

tagFrame:

• htmlparser: HtmlTag.tagFrame

tagFrameset:

• htmlparser: HtmlTag.tagFrameset

tagH1:

• htmlparser: HtmlTag.tagH1

tagH2:

• htmlparser: HtmlTag.tagH2

tagH3:

• htmlparser: HtmlTag.tagH3

tagH4:

• htmlparser: HtmlTag.tagH4

tagH5:

• htmlparser: HtmlTag.tagH5

tagH6:

• htmlparser: HtmlTag.tagH6

tagHead:

• htmlparser: HtmlTag.tagHead

tagHeader:

• htmlparser: HtmlTag.tagHeader

tagHgroup:

• htmlparser: HtmlTag.tagHgroup

tagHr:

• htmlparser: HtmlTag.tagHr

tagHtml:

• htmlparser: HtmlTag.tagHtml

tagI:

• htmlparser: HtmlTag.tagI

tagIframe:

• htmlparser: HtmlTag.tagIframe

tagImg:

• htmlparser: HtmlTag.tagImg

tagInput:

• htmlparser: HtmlTag.tagInput

tagIns:

• htmlparser: HtmlTag.tagIns

tagIsindex:

• htmlparser: HtmlTag.tagIsindex

tagKbd:

• htmlparser: HtmlTag.tagKbd

tagKeygen:

• htmlparser: HtmlTag.tagKeygen

tagLabel:

• htmlparser: HtmlTag.tagLabel

tagLegend:

• htmlparser: HtmlTag.tagLegend

tagLi:

• htmlparser: HtmlTag.tagLi

tagLink:

• htmlparser: HtmlTag.tagLink

tagMap:

• htmlparser: HtmlTag.tagMap

tagMark:

• htmlparser: HtmlTag.tagMark

tagMenu:

• htmlparser: HtmlTag.tagMenu

tagMeta:

• htmlparser: HtmlTag.tagMeta

tagMeter:

• htmlparser: HtmlTag.tagMeter

tagNav:

• htmlparser: HtmlTag.tagNav

tagNobr:

• htmlparser: HtmlTag.tagNobr

tagNoframes:

• htmlparser: HtmlTag.tagNoframes

tagNoscript:

• htmlparser: HtmlTag.tagNoscript

tagObject:

• htmlparser: HtmlTag.tagObject

tagOl:

• htmlparser: HtmlTag.tagOl

tagOptgroup:

• htmlparser: HtmlTag.tagOptgroup

tagOption:

• htmlparser: HtmlTag.tagOption

tagOutput:

• htmlparser: HtmlTag.tagOutput

tagP:

• htmlparser: HtmlTag.tagP

tagParam:

• htmlparser: HtmlTag.tagParam

tagPre:

• htmlparser: HtmlTag.tagPre

tagProgress:

• htmlparser: HtmlTag.tagProgress

tagQ:

• htmlparser: HtmlTag.tagQ

tagRp:

• htmlparser: HtmlTag.tagRp

tagRt:

• htmlparser: HtmlTag.tagRt

tagRuby:

• htmlparser: HtmlTag.tagRuby

tagS:

• htmlparser: HtmlTag.tagS

tagSamp:

• htmlparser: HtmlTag.tagSamp

tagScript:

• htmlparser: HtmlTag.tagScript

tagSection:

• htmlparser: HtmlTag.tagSection

tagSelect:

• htmlparser: HtmlTag.tagSelect

tagSmall:

• htmlparser: HtmlTag.tagSmall

tagSource:

• htmlparser: HtmlTag.tagSource

tagSpan:

• htmlparser: HtmlTag.tagSpan

tagStrike:

• htmlparser: HtmlTag.tagStrike

tagStrong:

• htmlparser: HtmlTag.tagStrong

tagStyle:

• htmlparser: HtmlTag.tagStyle

tagSub:

• htmlparser: HtmlTag.tagSub

tagSummary:

• htmlparser: HtmlTag.tagSummary

tagSup:

• htmlparser: HtmlTag.tagSup

tagTable:

• htmlparser: HtmlTag.tagTable

tagTbody:

• htmlparser: HtmlTag.tagTbody

tagTd:

• htmlparser: HtmlTag.tagTd

tagTextarea:

• htmlparser: HtmlTag.tagTextarea

tagTfoot:

• htmlparser: HtmlTag.tagTfoot

tagTh:

• htmlparser: HtmlTag.tagTh

tagThead:

• htmlparser: HtmlTag.tagThead

tagTime:

• htmlparser: HtmlTag.tagTime

tagTitle:

• htmlparser: HtmlTag.tagTitle

tagToStr:

• htmlparser: const tagToStr

tagTr:

• htmlparser: HtmlTag.tagTr

tagTrack:

• htmlparser: HtmlTag.tagTrack

tagTt:

• htmlparser: HtmlTag.tagTt

tagU:

• htmlparser: HtmlTag.tagU

tagUl:

• htmlparser: HtmlTag.tagUl

tagUnknown:

• htmlparser: HtmlTag.tagUnknown

tagVar:

• htmlparser: HtmlTag.tagVar

tagVideo:

• htmlparser: HtmlTag.tagVideo

tagWbr:

• htmlparser: HtmlTag.tagWbr

take:

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

text:

• xmltree: proc text(n: XmlNode): string

text=:

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

toAccs:

• matching: proc toAccs(path: Path; name: NimNode; pathForType: bool): NimNode

toCountTable:

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

toFilePermissions:

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

toOrderedTable:

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

toString:

• jssets: proc toString(this: JsSet): seq[cstring]

toTable:

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

toUncheckedArray:

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

toXmlAttributes:

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

UniquePtr:

• smartptrs: object UniquePtr

values:

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

valuesBetween:

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

valuesFrom:

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

VarKind:

• matching: enum VarKind

varOfIteration:

• matching: template varOfIteration(arg: untyped): untyped

VarSpec:

• matching: object VarSpec

vkAlt:

• matching: VarKind.vkAlt

vkOption:

• matching: VarKind.vkOption

vkRegular:

• matching: VarKind.vkRegular

vkSequence:

• matching: VarKind.vkSequence

vkSet:

• matching: VarKind.vkSet

withDir:

• scripting: template withDir(dir: string; body: untyped): untyped

XML:

• parsexml: Module parsexml

xmlAttribute:

• parsexml: XmlEventKind.xmlAttribute

XmlAttributes:

• xmltree: type XmlAttributes

xmlCData:

• parsexml: XmlEventKind.xmlCData

xmlCharData:

• parsexml: XmlEventKind.xmlCharData

xmlComment:

• parsexml: XmlEventKind.xmlComment

xmlElementClose:

• parsexml: XmlEventKind.xmlElementClose

xmlElementEnd:

• parsexml: XmlEventKind.xmlElementEnd

xmlElementOpen:

• parsexml: XmlEventKind.xmlElementOpen

xmlElementStart:

• parsexml: XmlEventKind.xmlElementStart

xmlEntity:

• parsexml: XmlEventKind.xmlEntity

xmlEof:

• parsexml: XmlEventKind.xmlEof

xmlError:

• parsexml: XmlEventKind.xmlError

XmlErrorKind:

• parsexml: enum XmlErrorKind

XmlEventKind:

• parsexml: enum XmlEventKind

xmlHeader:

• xmltree: const xmlHeader

XMLHttpRequest:

• jsxmlhttprequest: type XMLHttpRequest

XmlNode:

• xmltree: type XmlNode

XmlNodeKind:

• xmltree: enum XmlNodeKind

XmlParseOption:

• parsexml: enum XmlParseOption

XmlParser:

• parsexml: object XmlParser

xmlPI:

• parsexml: XmlEventKind.xmlPI

XMLSerializer:

• jsxmlserializer: type XMLSerializer

xmlSpecial:

• parsexml: XmlEventKind.xmlSpecial

xmlWhitespace:

• parsexml: XmlEventKind.xmlWhitespace

xnCData:

• xmltree: XmlNodeKind.xnCData

xnComment:

• xmltree: XmlNodeKind.xnComment

xnElement:

• xmltree: XmlNodeKind.xnElement

xnEntity:

• xmltree: XmlNodeKind.xnEntity

xnText:

• xmltree: XmlNodeKind.xnText

xnVerbatimText:

• xmltree: XmlNodeKind.xnVerbatimText

Made with Nim. Generated: 2024-03-05 09:50:25 UTC