Index

Modules: openparser, openparser/csv, openparser/feed, openparser/json, openparser/rss.

API symbols

`$`:

• csv: proc `$`(f: CsvFieldSlice): string

AnyTable:

• json: type AnyTable

arrayToJson:

• json: proc arrayToJson(v, valImpl: NimNode; opts: JsonOptions = nil): NimNode

asChars:

• csv: proc asChars(mfile: MemFile): ptr UncheckedArray[char]

AtomCategory:

• feed: object AtomCategory

AtomContent:

• feed: object AtomContent

AtomEntry:

• feed: object AtomEntry

AtomFeed:

• feed: object AtomFeed

AtomGenerator:

• feed: object AtomGenerator

AtomLink:

• feed: object AtomLink

AtomNs:

• feed: const AtomNs

AtomParsingError:

• feed: object AtomParsingError

AtomPerson:

• feed: object AtomPerson

AtomText:

• feed: object AtomText

AtomValidationError:

• feed: object AtomValidationError

CsvFieldSlice:

• csv: object CsvFieldSlice

CsvOptions:

• csv: object CsvOptions

CsvParseError:

• csv: object CsvParseError

CsvRowCallback:

• csv: type CsvRowCallback

defaultCsvOptions:

• csv: proc defaultCsvOptions(): CsvOptions

dumpHook:

• json: proc dumpHook(s: var string; val: float32 | float64)
• json: proc dumpHook(s: var string; val: tuple)
• json: proc dumpHook(s: var string; val: object)
• json: proc dumpHook(s: var string; v: enum)
• json: proc dumpHook[K: string; V](s: var string; val: AnyTable[K, V])
• json: proc dumpHook[N, T](s: var string; v: array[N, t[T]])
• json: proc dumpHook[N, T](s: var string; v: array[N, T])
• json: proc dumpHook(s: var string; val: bool)
• json: proc dumpHook(s: var string; val: Integers)
• json: proc dumpHook(s: var string; v: JsonNode)
• json: proc dumpHook[T](s: var string; v: Option[T])
• json: proc dumpHook[T](s: var string; arr: seq[T])
• json: proc dumpHook[T](s: var string; val: set[T])
• json: proc dumpHook(s: var string; val: string)
• json: proc dumpHook[T: ref object](s: var string; val: T)
• json: proc dumpHook[T: distinct](s: var string; v: T)

fetchAtom:

• feed: proc fetchAtom(url: string): AtomFeed

fetchRss:

• rss: proc fetchRss(url: string): RssFeed

fromJson:

• json: proc fromJson(mapped: MemFile): JsonNode
• json: proc fromJson(str: string): JsonNode
• json: proc fromJson[T](s: string; x: typedesc[T]): T

fromJsonFile:

• json: proc fromJsonFile(filename: string): JsonNode

fromJsonL:

• json: proc fromJsonL(mapped: MemFile): JsonNode
• json: proc fromJsonL(str: string): JsonNode

fromJsonLFile:

• json: proc fromJsonLFile(filename: string): JsonNode

Integers:

• json: type Integers

isMapped:

• json: proc isMapped(m: MemFile): bool

JsonOptions:

• json: type JsonOptions

JsonParser:

• json: object JsonParser

objectToJson:

• json: proc objectToJson(v, valImpl: NimNode; opts: JsonOptions = nil): NimNode

OpenParserJsonError:

• json: object OpenParserJsonError

openReadOnly:

• json: proc openReadOnly(filename: string; allowRemap = false; mapFlags = cint(-1)): MemFile

parseAtom:

• feed: proc parseAtom(xml: string): AtomFeed

parseCsv:

• csv: proc parseCsv(mfile: MemFile; onRow: CsvRowCallback; options: CsvOptions = defaultCsvOptions())

parseFile:

• csv: proc parseFile(filename: string; onRow: CsvRowCallback; options: CsvOptions = defaultCsvOptions())

parseHook:

• json: proc parseHook[K: string; V](parser: var JsonParser; v: var AnyTable[K, V])
• json: proc parseHook(parser: var JsonParser; v: var bool)
• json: proc parseHook[T](parser: var JsonParser; v: var Option[T])
• json: proc parseHook[T](parser: var JsonParser; v: var seq[T])
• json: proc parseHook[T](parser: var JsonParser; v: var set[T])
• json: proc parseHook(parser: var JsonParser; v: var string)
• json: proc parseHook[T: float | float32 | float64](parser: var JsonParser; v: var T)
• json: proc parseHook[T: ref object](parser: var JsonParser; v: var T)
• json: proc parseHook[T: enum](parser: var JsonParser; v: var T)
• json: proc parseHook[T: Integers](parser: var JsonParser; v: var T)
• json: proc parseHook[T: distinct](parser: var JsonParser; v: var T)
• json: proc parseHook[T: object | ref object](parser: var JsonParser; v: var T)

parseRss:

• rss: proc parseRss(xml: string): RssFeed

readAtom:

• feed: proc readAtom(filePath: string): AtomFeed

readRss:

• rss: proc readRss(filePath: string): RssFeed

RssFeed:

• rss: object RssFeed

RssImage:

• rss: object RssImage

RssItem:

• rss: object RssItem

RssMediaContent:

• rss: object RssMediaContent

RSSParsingError:

• rss: object RSSParsingError

skippable:

• json: template skippable()

skipValue:

• json: proc skipValue(parser: var JsonParser)

tkColon:

• json: TokenKind.tkColon

tkComma:

• json: TokenKind.tkComma

tkEof:

• json: TokenKind.tkEof

tkFalse:

• json: TokenKind.tkFalse

tkLBrace:

• json: TokenKind.tkLBrace

tkLBracket:

• json: TokenKind.tkLBracket

tkNull:

• json: TokenKind.tkNull

tkNumber:

• json: TokenKind.tkNumber

tkRBrace:

• json: TokenKind.tkRBrace

tkRBracket:

• json: TokenKind.tkRBracket

tkString:

• json: TokenKind.tkString

tkTrue:

• json: TokenKind.tkTrue

toAtomXml:

• feed: proc toAtomXml(feed: AtomFeed): string

toJson:

• json: proc toJson[T](v: T; opts: JsonOptions = nil): string

Token:

• json: type Token

TokenKind:

• json: enum TokenKind

toRssXml:

• rss: proc toRssXml(feed: RssFeed): string

toStaticJson:

• json: macro toStaticJson(v: typed; opts: static JsonOptions = nil): untyped

toString:

• csv: proc toString(f: CsvFieldSlice): string

walk:

• json: proc walk(parser: var JsonParser): Token