NimYAML Home Testing Ground API: Module yaml

Module yaml

This module provides facilities to generate and interpret YAML character streams. All primitive operations on data objects use a YamlStream either as source or as output. Because this stream is implemented as iterator, it is possible to process YAML input and output sequentially, i.e. without loading the processed data structure completely into RAM. This supports the processing of large data structures.

As YAML is a strict superset of JSON, JSON input is automatically supported. While JSON is less readable than YAML, this enhances interoperability with other languages.

Imports

streams, unicode, lexbase, tables, strutils, json, hashes, queues, macros, typetraits, typetraits

Types

TypeHint = enum
  yTypeInteger, yTypeFloat, yTypeFloatInf, yTypeFloatNaN, yTypeBoolTrue,
  yTypeBoolFalse, yTypeNull, yTypeUnknown

A type hint can be computed from scalar content and tells you what NimYAML thinks the scalar's type is. It is generated by guessType The first matching RegEx in the following table will be the type hint of a scalar string.

You can use it to determine the type of YAML scalars that have a '?' non-specific tag, but using this feature is completely optional.

NameRegEx
yTypeInteger0 | -? [1-9] [0-9]*
yTypeFloat-? [1-9] ( \. [0-9]* [1-9] )? ( e [-+] [1-9] [0-9]* )?
yTypeFloatInf-? \. (inf | Inf | INF)
yTypeFloatNaN-? \. (nan | NaN | NAN)
yTypeBoolTruey|Y|yes|Yes|YES|true|True|TRUE|on|On|ON
yTypeBoolFalsen|N|no|No|NO|false|False|FALSE|off|Off|OFF
yTypeNull~ | null | Null | NULL
yTypeUnknown*
  Source 
YamlStreamEventKind = enum
  yamlStartDocument, yamlEndDocument, yamlStartMap, yamlEndMap, yamlStartSequence,
  yamlEndSequence, yamlScalar, yamlAlias
Kinds of YAML events that may occur in an YamlStream. Event kinds are discussed in YamlStreamEvent.   Source 
TagId = distinct int

A TagId identifies a tag URI, like for example "tag:yaml.org,2002:str". The URI corresponding to a TagId can be queried from the TagLibrary which was used to create this TagId; e.g. when you parse a YAML character stream, the TagLibrary of the parser is the one which generates the resulting TagId s.

URI strings are mapped to TagId s for efficiency reasons (you do not need to compare strings every time) and to be able to discover unknown tag URIs early in the parsing process.

  Source 
AnchorId = distinct int
An AnchorId identifies an anchor in the current document. It becomes invalid as soon as the current document scope is invalidated (for example, because the parser yielded a yamlEndDocument event). AnchorId s exists because of efficiency, much like TagId s. The actual anchor name is a presentation detail and cannot be queried by the user.   Source 
YamlStreamEvent = object
  case kind*: YamlStreamEventKind
  of yamlStartMap:
      mapAnchor*: AnchorId
      mapTag*: TagId

  of yamlStartSequence:
      seqAnchor*: AnchorId
      seqTag*: TagId

  of yamlScalar:
      scalarAnchor*: AnchorId
      scalarTag*: TagId
      scalarContent*: string

  of yamlEndMap, yamlEndSequence, yamlStartDocument, yamlEndDocument:
      nil

  of yamlAlias:
      aliasTarget*: AnchorId

An element from a YamlStream. Events that start an object (yamlStartMap, yamlStartSequence, yamlScalar) have an optional anchor and a tag associated with them. The anchor will be set to yAnchorNone if it doesn't exist.

A non-existing tag in the YAML character stream will be resolved to the non-specific tags ? or ! according to the YAML specification. These are by convention mapped to the TagId s yTagQuestionMark and yTagExclamationMark respectively. Mapping is done by a TagLibrary.

  Source 
YamlStream = object
  backend: iterator (): YamlStreamEvent
  peeked: bool
  cached: YamlStreamEvent

A YamlStream is an iterator-like object that yields a well-formed stream of YamlStreamEvents. Well-formed means that every yamlStartMap is terminated by a yamlEndMap, every yamlStartSequence is terminated by a yamlEndSequence and every yamlStartDocument is terminated by a yamlEndDocument. Moreover, every emitted map has an even number of children.

The creator of a YamlStream is responsible for it being well-formed. A user of the stream may assume that it is well-formed and is not required to check for it. The procs in this module will always yield a well-formed YamlStream and expect it to be well-formed if it's an input.

  Source 
TagLibrary = ref object
  tags*: Table[string, TagId]
  nextCustomTagId*: TagId
  secondaryPrefix*: string

A TagLibrary maps tag URIs to TagId s.

When YamlParser encounters tags not existing in the tag library, it will use registerTagUri to add the tag to the library.

You can base your tag library on common tag libraries by initializing them with initFailsafeTagLibrary, initCoreTagLibrary or initExtendedTagLibrary.

  Source 
WarningCallback = proc (line, column: int; lineContent: string; message: string)
Callback for parser warnings. Currently, this callback may be called on two occasions while parsing a YAML document stream:
  • If the version number in the %YAML directive does not match 1.2.
  • If there is an unknown directive encountered.
  Source 
YamlParser = ref object
  tagLib: TagLibrary
  anchors: OrderedTable[string, AnchorId]
  callback: WarningCallback
  lexer: BaseLexer
  tokenstart: int
A parser object. Retains its TagLibrary across calls to parse. Can be used to access anchor names while parsing a YAML character stream, but only until the document goes out of scope (i.e. until yamlEndDocument is yielded).   Source 
PresentationStyle = enum
  psMinimal, psCanonical, psDefault, psJson, psBlockOnly
Different styles for YAML character stream output.
  • ypsMinimal: Single-line flow-only output which tries to use as few characters as possible.
  • ypsCanonical: Canonical YAML output. Writes all tags except for the non-specific tags ? and !, uses flow style, quotes all string scalars.
  • ypsDefault: Tries to be as human-readable as possible. Uses block style by default, but tries to condense maps and sequences which only contain scalar nodes into a single line using flow style.
  • ypsJson: Omits the %YAML directive and the --- marker. Uses flow style. Flattens anchors and aliases, omits tags. Output will be parseable as JSON. YamlStream to dump may only contain one document.
  • ypsBlockOnly: Formats all output in block style, does not use flow style at all.
  Source 
TagStyle = enum
  tsNone, tsRootOnly, tsAll
Whether object should be serialized with explicit tags.
  • tsNone: No tags will be outputted unless necessary.
  • tsRootOnly: A tag will only be outputted for the root tag and
    where necessary.
  • tsAll: Tags will be outputted for every object.
  Source 
AnchorStyle = enum
  asNone, asTidy, asAlways
How ref object should be serialized.
  • asNone: No anchors will be outputted. Values present at
    multiple places in the content that should be serialized will be fully serialized at every occurence. If the content is cyclic, this will lead to an endless loop!
  • asTidy: Anchors will only be generated for objects that
    actually occur more than once in the content to be serialized. This is a bit slower and needs more memory than asAlways.
  • asAlways: Achors will be generated for every ref object in the
    content to be serialized, regardless of whether the object is referenced again afterwards
  Source 
ConstructionContext = ref object
  refs: Table[AnchorId, pointer]
Context information for the process of constructing Nim values from YAML.   Source 
SerializationContext = ref object
  refsList: seq[RefNodeData]
  style: AnchorStyle
Context information for the process of serializing YAML from Nim values.   Source 
RawYamlStream = iterator (): YamlStreamEvent {.raises: [].}
Stream of YamlStreamEvent``s returned by ``representObject procs.   Source 
YamlLoadingError = object of Exception
  line*: int                   ## line number (1-based) where the error was encountered
  column*: int                 ## \
             ## column number (1-based) where the error was encountered
  lineContent*: string ## \
                     ## content of the line where the error was encountered. Includes a
                     ## second line with a marker ``^`` at the position where the error
                     ## was encountered.
Base class for all exceptions that may be raised during the process of loading a YAML character stream.   Source 
YamlParserError = object of YamlLoadingError

A parser error is raised if the character stream that is parsed is not a valid YAML character stream. This stream cannot and will not be parsed wholly nor partially and all events that have been emitted by the YamlStream the parser provides should be discarded.

A character stream is invalid YAML if and only if at least one of the following conditions apply:

  • There are invalid characters in an element whose contents is restricted to a limited set of characters. For example, there are characters in a tag URI which are not valid URI characters.
  • An element has invalid indentation. This can happen for example if a block list element indicated by "- " is less indented than the element in the previous line, but there is no block sequence list open at the same indentation level.
  • The YAML structure is invalid. For example, an explicit block map indicated by "? " and ": " may not suddenly have a block sequence item ("- ") at the same indentation level. Another possible violation is closing a flow style object with the wrong closing character (}, ]) or not closing it at all.
  • A custom tag shorthand is used that has not previously been declared with a %TAG directive.
  • Multiple tags or anchors are defined for the same node.
  • An alias is used which does not map to any anchor that has previously been declared in the same document.
  • An alias has a tag or anchor associated with it.

Some elements in this list are vague. For a detailed description of a valid YAML character stream, see the YAML specification.

  Source 
YamlPresenterJsonError = object of Exception
Exception that may be raised by the YAML presenter when it is instructed to output JSON, but is unable to do so. This may occur if:
  • The given YamlStream contains a map which has any non-scalar type as key.
  • Any float scalar bears a NaN or positive/negative infinity value
  Source 
YamlPresenterOutputError = object of Exception
Exception that may be raised by the YAML presenter. This occurs if writing character data to the output stream raises any exception. The error that has occurred is available from parent.   Source 
YamlStreamError = object of Exception
Exception that may be raised by a YamlStream when the underlying backend raises an exception. The error that has occurred is available from parent.   Source 
YamlConstructionError = object of YamlLoadingError
Exception that may be raised when constructing data objects from a YamlStream. The fields line, column and lineContent are only available if the costructing proc also does parsing, because otherwise this information is not available to the costruction proc.   Source

Vars

serializationTagLibrary = initSerializationTagLibrary()

contains all local tags that are used for type serialization. Does not contain any of the specific default tags for sequences or maps, as those are not suited for Nim's static type system.

Should not be modified manually. Will be extended by serializable.

  Source

Consts

yTagExclamationMark: TagId = 0
! non-specific tag   Source 
yTagQuestionMark: TagId = 1
? non-specific tag   Source 
yTagString: TagId = 2
!!str tag   Source 
yTagSequence: TagId = 3
!!seq tag   Source 
yTagMap: TagId = 4
!!map tag   Source 
yTagNull: TagId = 5
!!null tag   Source 
yTagBoolean: TagId = 6
!!bool tag   Source 
yTagInteger: TagId = 7
!!int tag   Source 
yTagFloat: TagId = 8
!!float tag   Source 
yTagOrderedMap: TagId = 9
!!omap tag   Source 
yTagPairs: TagId = 10
!!pairs tag   Source 
yTagSet: TagId = 11
!!set tag   Source 
yTagBinary: TagId = 12
!!binary tag   Source 
yTagMerge: TagId = 13
!!merge tag   Source 
yTagTimestamp: TagId = 14
!!timestamp tag   Source 
yTagValue: TagId = 15
!!value tag   Source 
yTagYaml: TagId = 16
!!yaml tag   Source 
yFirstCustomTagId: TagId = 1000
The first TagId which should be assigned to an URI that does not exist in the YamlTagLibrary which is used for parsing.   Source 
yAnchorNone: AnchorId = -1
yielded when no anchor was defined for a YAML node   Source 
yamlTagRepositoryPrefix = "tag:yaml.org,2002:"
  Source 
yTagNimInt8 = 100
tag for Nim's int8   Source 
yTagNimInt16 = 101
tag for Nim's int16   Source 
yTagNimInt32 = 102
tag for Nim's int32   Source 
yTagNimInt64 = 103
tag for Nim's int64   Source 
yTagNimUInt8 = 104
tag for Nim's uint8   Source 
yTagNimUInt16 = 105
tag for Nim's uint16   Source 
yTagNimUInt32 = 106
tag for Nim's uint32   Source 
yTagNimUInt64 = 107
tag for Nim's uint64   Source 
yTagNimFloat32 = 108
tag for Nim's float32   Source 
yTagNimFloat64 = 109
tag for Nim's float64   Source 
yTagNimChar = 110
tag for Nim's char   Source

Procs

proc `==`(left, right: TagId): bool {.borrow.}
  Source 
proc hash(id: TagId): Hash {.borrow.}
  Source 
proc `==`(left, right: AnchorId): bool {.borrow.}
  Source 
proc `$`(id: AnchorId): string {.borrow.}
  Source 
proc hash(id: AnchorId): Hash {.borrow.}
  Source 
proc `$`(id: TagId): string {.raises: [], tags: [].}
  Source 
proc initTagLibrary(): TagLibrary {.raises: [], tags: [].}
initializes the tags table and sets nextCustomTagId to yFirstCustomTagId.   Source 
proc registerUri(tagLib: TagLibrary; uri: string): TagId {.raises: [], tags: [].}
registers a custom tag URI with a TagLibrary. The URI will get the TagId nextCustomTagId, which will be incremented.   Source 
proc uri(tagLib: TagLibrary; id: TagId): string {.raises: [KeyError], tags: [].}
retrieve the URI a TagId maps to.   Source 
proc initFailsafeTagLibrary(): TagLibrary {.raises: [], tags: [].}
Contains only:
  • !
  • ?
  • !!str
  • !!map
  • !!seq
  Source 
proc initCoreTagLibrary(): TagLibrary {.raises: [], tags: [].}
Contains everything in initFailsafeTagLibrary plus:
  • !!null
  • !!bool
  • !!int
  • !!float
  Source 
proc initExtendedTagLibrary(): TagLibrary {.raises: [], tags: [].}
Contains everything from initCoreTagLibrary plus:
  • !!omap
  • !!pairs
  • !!set
  • !!binary
  • !!merge
  • !!timestamp
  • !!value
  • !!yaml
  Source 
proc `==`(left: YamlStreamEvent; right: YamlStreamEvent): bool {.raises: [], tags: [].}
compares all existing fields of the given items   Source 
proc `$`(event: YamlStreamEvent): string {.raises: [], tags: [].}
outputs a human-readable string describing the given event   Source 
proc startDocEvent(): YamlStreamEvent {.inline, raises: [], tags: [].}
  Source 
proc endDocEvent(): YamlStreamEvent {.inline, raises: [], tags: [].}
  Source 
proc startMapEvent(tag: TagId = yTagQuestionMark; anchor: AnchorId = yAnchorNone): YamlStreamEvent {.
    inline, raises: [], tags: [].}
  Source 
proc endMapEvent(): YamlStreamEvent {.inline, raises: [], tags: [].}
  Source 
proc startSeqEvent(tag: TagId = yTagQuestionMark; anchor: AnchorId = yAnchorNone): YamlStreamEvent {.
    inline, raises: [], tags: [].}
  Source 
proc endSeqEvent(): YamlStreamEvent {.inline, raises: [], tags: [].}
  Source 
proc scalarEvent(content: string = ""; tag: TagId = yTagQuestionMark;
                anchor: AnchorId = yAnchorNone): YamlStreamEvent {.inline, raises: [],
    tags: [].}
  Source 
proc aliasEvent(anchor: AnchorId): YamlStreamEvent {.inline, raises: [], tags: [].}
  Source 
proc constructJson(s: var YamlStream): seq[JsonNode] {.
    raises: [YamlConstructionError, YamlStreamError], tags: [RootEffect].}

Construct an in-memory JSON tree from a YAML event stream. The stream may not contain any tags apart from those in coreTagLibrary. Anchors and aliases will be resolved. Maps in the input must not contain non-scalars as keys. Each element of the result represents one document in the YAML stream.

Warning: The special float values [+-]Inf and NaN will be parsed into Nim's JSON structure without error. However, they cannot be rendered to a JSON character stream, because these values are not part of the JSON specification. Nim's JSON implementation currently does not check for these values and will output invalid JSON when rendering one of these values into a JSON character stream.

  Source 
proc loadToJson(s: Stream): seq[JsonNode] {.raises: [IOError, YamlParserError,
    YamlConstructionError, OutOfMemError], tags: [RootEffect].}
Uses YamlParser and constructJson to construct an in-memory JSON tree from a YAML character stream.   Source 
proc present(s: var YamlStream; target: Stream; tagLib: TagLibrary;
            style: PresentationStyle = psDefault; indentationStep: int = 2) {.raises: [
    YamlPresenterJsonError, YamlPresenterOutputError, YamlStreamError],
    tags: [RootEffect, WriteIOEffect].}
Convert s to a YAML character stream and write it to target.   Source 
proc transform(input: Stream; output: Stream; style: PresentationStyle;
              indentationStep: int = 2) {.raises: [IOError, YamlParserError,
    YamlPresenterJsonError, YamlPresenterOutputError, OutOfMemError],
                                      tags: [RootEffect, WriteIOEffect].}
Parser input as YAML character stream and then dump it to output while resolving non-specific tags to the ones in the YAML core tag library.   Source 
proc guessType(scalar: string): TypeHint {.raises: [], tags: [].}
Parse scalar string according to the RegEx table documented at TypeHint.   Source 
proc newYamlParser(tagLib: TagLibrary = initExtendedTagLibrary();
                  callback: WarningCallback = nil): YamlParser {.raises: [], tags: [].}
Creates a YAML parser. if callback is not nil, it will be called whenever the parser yields a warning.   Source 
proc getLineNumber(p: YamlParser): int {.raises: [], tags: [].}
Get the line number (1-based) of the recently yielded parser token. Useful for error reporting at later loading stages.   Source 
proc getColNumber(p: YamlParser): int {.raises: [], tags: [].}
Get the column number (1-based) of the recently yielded parser token. Useful for error reporting at later parsing stages.   Source 
proc getLineContent(p: YamlParser; marker: bool = true): string {.raises: [], tags: [].}
Get the content of the input line containing the recently yielded parser token. Useful for error reporting at later parsing stages. The line will be terminated by "\n". If marker is true, a second line will be returned containing a ^ at the position of the recent parser token.   Source 
proc parse(p: YamlParser; s: Stream): YamlStream {.raises: [],
    tags: [RootEffect, ReadIOEffect].}
Parse the given stream as YAML character stream.   Source 
proc initYamlStream(backend: iterator (): YamlStreamEvent): YamlStream {.raises: [],
    tags: [].}
Creates a new YamlStream that uses the given iterator as backend.   Source 
proc next(s: var YamlStream): YamlStreamEvent {.raises: [YamlStreamError],
    tags: [RootEffect].}
Get the next item of the stream. Requires finished(s) == true. If the backend yields an exception, that exception will be encapsulated into a YamlStreamError, which will be raised.   Source 
proc peek(s: var YamlStream): YamlStreamEvent {.raises: [YamlStreamError],
    tags: [RootEffect].}
Get the next item of the stream without advancing the stream. Requires finished(s) == true. Handles exceptions of the backend like next().   Source 
proc peek=(s: var YamlStream; value: YamlStreamEvent) {.raises: [], tags: [].}
Set the next item of the stream. Will replace a previously peeked item, if one exists.   Source 
proc finished(s: var YamlStream): bool {.raises: [YamlStreamError], tags: [RootEffect].}
true if no more items are available in the stream. Handles exceptions of the backend like next().   Source 
proc lazyLoadTag(uri: string): TagId {.inline, raises: [], tags: [].}
Internal function. Do not call explicitly.   Source 
proc safeTagUri(id: TagId): string {.raises: [], tags: [].}
Internal function. Do not call explicitly.   Source 
proc yamlTag[](T: typedesc[string]): TagId {.inline, raises: [].}
  Source 
proc constructObject(s: var YamlStream; c: ConstructionContext; result: var string) {.
    raises: [YamlConstructionError, YamlStreamError], tags: [RootEffect].}
  Source 
proc representObject(value: string; ts: TagStyle = tsNone; c: SerializationContext): RawYamlStream {.
    raises: [], tags: [].}
  Source 
proc yamlTag[](T: typedesc[int8]): TagId {.inline, raises: [].}
  Source 
proc yamlTag[](T: typedesc[int16]): TagId {.inline, raises: [].}
  Source 
proc yamlTag[](T: typedesc[int32]): TagId {.inline, raises: [].}
  Source 
proc yamlTag[](T: typedesc[int64]): TagId {.inline, raises: [].}
  Source 
proc constructObject[T](s: var YamlStream; c: ConstructionContext; result: var T) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc representObject[T](value: T; ts: TagStyle = tsNone; c: SerializationContext): RawYamlStream {.
    raises: [].}
  Source 
proc yamlTag[](T: typedesc[uint8]): TagId {.inline, raises: [].}
  Source 
proc yamlTag[](T: typedesc[uint16]): TagId {.inline, raises: [].}
  Source 
proc yamlTag[](T: typedesc[uint32]): TagId {.inline, raises: [].}
  Source 
proc yamlTag[](T: typedesc[uint64]): TagId {.inline, raises: [].}
  Source 
proc constructObject[T](s: var YamlStream; c: ConstructionContext; result: var T) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc representObject[T](value: T; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [].}
  Source 
proc yamlTag[](T: typedesc[float32]): TagId {.inline, raises: [].}
  Source 
proc yamlTag[](T: typedesc[float64]): TagId {.inline, raises: [].}
  Source 
proc constructObject[T](s: var YamlStream; c: ConstructionContext; result: var T) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc representObject[T](value: T; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [].}
  Source 
proc yamlTag[](T: typedesc[bool]): TagId {.inline, raises: [].}
  Source 
proc constructObject(s: var YamlStream; c: ConstructionContext; result: var bool) {.
    raises: [YamlConstructionError, YamlStreamError], tags: [RootEffect].}
  Source 
proc representObject(value: bool; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [], tags: [].}
  Source 
proc yamlTag[](T: typedesc[char]): TagId {.inline, raises: [].}
  Source 
proc constructObject(s: var YamlStream; c: ConstructionContext; result: var char) {.
    raises: [YamlConstructionError, YamlStreamError], tags: [RootEffect].}
  Source 
proc representObject(value: char; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [], tags: [].}
  Source 
proc yamlTag[I, ](T: typedesc[seq[I]]): TagId {.inline, raises: [].}
  Source 
proc constructObject[T](s: var YamlStream; c: ConstructionContext; result: var seq[T]) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc representObject[T](value: seq[T]; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [].}
  Source 
proc yamlTag[K, V, ](T: typedesc[Table[K, V]]): TagId {.inline, raises: [].}
  Source 
proc constructObject[K, V](s: var YamlStream; c: ConstructionContext;
                         result: var Table[K, V]) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc representObject[K, V](value: Table[K, V]; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [].}
  Source 
proc constructObject[O](s: var YamlStream; c: ConstructionContext; result: var ref O) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc constructObject[O](s: var YamlStream; c: ConstructionContext; result: var O) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc representObject[O](value: O; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [].}
  Source 
proc constructObject[O](s: var YamlStream; c: ConstructionContext; result: var O) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc representObject[O](value: O; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [].}
  Source 
proc yamlTag[O, ](T: typedesc[ref O]): TagId {.inline, raises: [].}
  Source 
proc constructObject[O](s: var YamlStream; c: ConstructionContext; result: var ref O) {.
    raises: [YamlConstructionError, YamlStreamError].}
  Source 
proc representObject[O](value: ref O; ts: TagStyle; c: SerializationContext): RawYamlStream {.
    raises: [].}
  Source 
proc construct[T](s: var YamlStream; target: var T) {.
    raises: [YamlConstructionError, YamlStreamError].}
Construct a Nim value from a YAML stream.   Source 
proc load[K](input: Stream; target: var K) {.raises: [YamlConstructionError, IOError,
    YamlParserError].}
Load a Nim value from a YAML character stream.   Source 
proc represent[T](value: T; ts: TagStyle = tsRootOnly; a: AnchorStyle = asTidy): YamlStream {.
    raises: [].}
Represent a Nim value as YamlStream.   Source 
proc dump[K](value: K; target: Stream; style: PresentationStyle = psDefault;
            tagStyle: TagStyle = tsRootOnly; anchorStyle: AnchorStyle = asTidy;
            indentationStep: int = 2) {.raises: [YamlPresenterJsonError,
    YamlPresenterOutputError].}
Dump a Nim value as YAML character stream.   Source

Iterators

iterator items(s: var YamlStream): YamlStreamEvent {.raises: [YamlStreamError],
    tags: [RootEffect].}
Iterate over all items of the stream. You may not use peek() on the stream while iterating.   Source

Macros

macro serializable(types: stmt): stmt
Macro for customizing serialization of user-defined types. Currently does not provide more features than just using the standard serialization procs. This will change in the future.   Source

Templates

template constructObject(s: var YamlStream; c: ConstructionContext; result: var int)
  Source 
template representObject(value: int; tagStyle: TagStyle; c: SerializationContext): RawYamlStream
  Source 
template constructObject(s: var YamlStream; c: ConstructionContext; result: var uint)
  Source 
template representObject(value: uint; ts: TagStyle; c: SerializationContext): RawYamlStream
  Source 
template constructObject(s: var YamlStream; c: ConstructionContext; result: var float)
  Source 
template representObject(value: float; tagStyle: TagStyle; c: SerializationContext): RawYamlStream
  Source 
template yamlTag[](T: typedesc[object | enum]): expr
  Source 
template yamlTag[](T: typedesc[tuple]): expr
  Source

Made with Nim. Generated: 2016-02-12 20:45:14 UTC