Index

Modules: json_serialization, json_serialization/format, json_serialization/lexer, json_serialization/parser, json_serialization/reader, json_serialization/reader_desc, json_serialization/reader_impl, json_serialization/types, json_serialization/writer.

API symbols

`$`:

• types: template `$`(s: JsonString): string

`==`:

• types: proc `==`(lhs, rhs: JsonValueRef): bool
• types: template `==`(lhs, rhs: JsonString): bool

assignLineNumber:

• reader_desc: proc assignLineNumber(ex: ref JsonReaderError; lex: JsonLexer)

automaticBuiltinSerialization:

• format: template automaticBuiltinSerialization(F: type DefaultFlavor; enable: static[bool])
• format: template automaticBuiltinSerialization(F: type DummyFlavor; enable: static[bool])

automaticPrimitivesSerialization:

• format: template automaticPrimitivesSerialization(F: type DefaultFlavor; enable: static[bool])
• format: template automaticPrimitivesSerialization(F: type DummyFlavor; enable: static[bool])

automaticSerialization:

• format: template automaticSerialization(F: type DefaultFlavor; T: distinct type; enable: static[bool])
• format: template automaticSerialization(F: type DummyFlavor; T: distinct type; enable: static[bool])

beginArray:

• writer: proc beginArray(w: var JsonWriter)

beginObject:

• writer: proc beginObject(w: var JsonWriter)
• writer: proc beginObject(w: var JsonWriter; O: type)

beginRecord:

• writer: template beginRecord(w: var JsonWriter)
• writer: template beginRecord(w: var JsonWriter; T: type)

checkError:

• parser: template checkError(r: var JsonReader)

col:

• lexer: proc col(lex: JsonLexer): int

configureJsonDeserialization:

• reader_impl: template configureJsonDeserialization(T: type[enum]; allowNumericRepr: static[bool] = false; stringNormalizer: static[proc (s: string): string] = strictNormalize)

configureJsonSerialization:

• writer: template configureJsonSerialization(Flavor: type; T: type[enum]; enumRep: static[EnumRepresentation])
• writer: template configureJsonSerialization(T: type[enum]; enumRep: static[EnumRepresentation])

createJsonFlavor:

• format: template createJsonFlavor(FlavorName: untyped; mimeTypeValue = "application/json"; automaticObjectSerialization = false; requireAllFields = true; omitOptionalFields = true; allowUnknownFields = true; skipNullFields = false; automaticPrimitivesSerialization = true)

CustomIntHandler:

• parser: type CustomIntHandler

customIntHandler:

• parser: proc customIntHandler(r: var JsonReader; handler: CustomIntHandler)

customIntValueIt:

• parser: template customIntValueIt(r: var JsonReader; body: untyped)

CustomNumberHandler:

• parser: type CustomNumberHandler

customNumberHandler:

• parser: proc customNumberHandler(r: var JsonReader; handler: CustomNumberHandler)

customNumberValueIt:

• parser: template customNumberValueIt(r: var JsonReader; body: untyped)

CustomStringHandler:

• parser: type CustomStringHandler

customStringHandler:

• parser: proc customStringHandler(r: var JsonReader; limit: int; handler: CustomStringHandler)

customStringValueIt:

• parser: template customStringValueIt(r: var JsonReader; body: untyped)
• parser: template customStringValueIt(r: var JsonReader; limit: untyped; body: untyped)

defaultJsonReaderConf:

• types: const defaultJsonReaderConf

defaultJsonReaderFlags:

• types: const defaultJsonReaderFlags

DummyFlavor:

• format: object DummyFlavor

endArray:

• writer: proc endArray(w: var JsonWriter)

endObject:

• writer: proc endObject(w: var JsonWriter)

endRecord:

• writer: template endRecord(w: var JsonWriter)

EnumAsNumber:

• format: EnumRepresentation.EnumAsNumber

EnumAsString:

• format: EnumRepresentation.EnumAsString

EnumAsStringifiedNumber:

• format: EnumRepresentation.EnumAsStringifiedNumber

EnumRepresentation:

• format: enum EnumRepresentation

errArrayElementsLimit:

• lexer: JsonErrorKind.errArrayElementsLimit

errBoolExpected:

• lexer: JsonErrorKind.errBoolExpected

errBracketLeExpected:

• lexer: JsonErrorKind.errBracketLeExpected

errBracketRiExpected:

• lexer: JsonErrorKind.errBracketRiExpected

errColonExpected:

• lexer: JsonErrorKind.errColonExpected

errCommaExpected:

• lexer: JsonErrorKind.errCommaExpected

errCommentExpected:

• lexer: JsonErrorKind.errCommentExpected

errCommentNotAllowed:

• lexer: JsonErrorKind.errCommentNotAllowed

errCurlyLeExpected:

• lexer: JsonErrorKind.errCurlyLeExpected

errCurlyRiExpected:

• lexer: JsonErrorKind.errCurlyRiExpected

errCustomBlobExpected:

• lexer: JsonErrorKind.errCustomBlobExpected

errCustomIntExpected:

• lexer: JsonErrorKind.errCustomIntExpected

errEmptyFraction:

• lexer: JsonErrorKind.errEmptyFraction

errEscapeControlChar:

• lexer: JsonErrorKind.errEscapeControlChar

errEscapeHex:

• lexer: JsonErrorKind.errEscapeHex

errExpDigitLimit:

• lexer: JsonErrorKind.errExpDigitLimit

errExponentTooLarge:

• lexer: JsonErrorKind.errExponentTooLarge

errFracDigitLimit:

• lexer: JsonErrorKind.errFracDigitLimit

errHexCharExpected:

• lexer: JsonErrorKind.errHexCharExpected

errIntDigitLimit:

• lexer: JsonErrorKind.errIntDigitLimit

errIntPosSign:

• lexer: JsonErrorKind.errIntPosSign

errInvalidBool:

• lexer: JsonErrorKind.errInvalidBool

errInvalidInt:

• lexer: JsonErrorKind.errInvalidInt

errInvalidNull:

• lexer: JsonErrorKind.errInvalidNull

errLeadingFraction:

• lexer: JsonErrorKind.errLeadingFraction

errLeadingZero:

• lexer: JsonErrorKind.errLeadingZero

errMissingFirstElement:

• lexer: JsonErrorKind.errMissingFirstElement

errNestedDepthLimit:

• lexer: JsonErrorKind.errNestedDepthLimit

errNone:

• lexer: JsonErrorKind.errNone

errNonPortableInt:

• lexer: JsonErrorKind.errNonPortableInt

errNullExpected:

• lexer: JsonErrorKind.errNullExpected

errNumberExpected:

• lexer: JsonErrorKind.errNumberExpected

errObjectMembersLimit:

• lexer: JsonErrorKind.errObjectMembersLimit

errOrphanSurrogate:

• lexer: JsonErrorKind.errOrphanSurrogate

errQuoteExpected:

• lexer: JsonErrorKind.errQuoteExpected

errRelaxedEscape:

• lexer: JsonErrorKind.errRelaxedEscape

errStringExpected:

• lexer: JsonErrorKind.errStringExpected

errStringLengthLimit:

• lexer: JsonErrorKind.errStringLengthLimit

errTrailingComma:

• lexer: JsonErrorKind.errTrailingComma

errU64Overflow:

• lexer: JsonErrorKind.errU64Overflow

errUnexpectedEof:

• lexer: JsonErrorKind.errUnexpectedEof

errUnknownChar:

• lexer: JsonErrorKind.errUnknownChar

errValueExpected:

• lexer: JsonErrorKind.errValueExpected

etBool:

• reader_desc: ExpectedTokenCategory.etBool

etBracketLe:

• reader_desc: ExpectedTokenCategory.etBracketLe

etBracketRi:

• reader_desc: ExpectedTokenCategory.etBracketRi

etColon:

• reader_desc: ExpectedTokenCategory.etColon

etComma:

• reader_desc: ExpectedTokenCategory.etComma

etCurrlyLe:

• reader_desc: ExpectedTokenCategory.etCurrlyLe

etCurrlyRi:

• reader_desc: ExpectedTokenCategory.etCurrlyRi

etEnumAny:

• reader_desc: ExpectedTokenCategory.etEnumAny

etEnumString:

• reader_desc: ExpectedTokenCategory.etEnumString

etInt:

• reader_desc: ExpectedTokenCategory.etInt

etNumber:

• reader_desc: ExpectedTokenCategory.etNumber

etString:

• reader_desc: ExpectedTokenCategory.etString

etValue:

• reader_desc: ExpectedTokenCategory.etValue

expectedFieldsBitmask:

• reader_impl: proc expectedFieldsBitmask(TT: type; fields: static int): auto

ExpectedTokenCategory:

• reader_desc: enum ExpectedTokenCategory

ExponentPart:

• parser: NumberPart.ExponentPart

ExpSignPart:

• parser: NumberPart.ExpSignPart

flavorAllowsUnknownFields:

• format: template flavorAllowsUnknownFields(T: type DefaultFlavor): bool
• format: template flavorAllowsUnknownFields(T: type DummyFlavor): bool

flavorEnumRep:

• format: template flavorEnumRep(T: type DefaultFlavor): EnumRepresentation
• format: template flavorEnumRep(T: type DefaultFlavor; rep: static[EnumRepresentation])
• format: template flavorEnumRep(T: type Json; rep: static[EnumRepresentation])

flavorOmitsOptionalFields:

• format: template flavorOmitsOptionalFields(T: type DefaultFlavor): bool
• format: template flavorOmitsOptionalFields(T: type DummyFlavor): bool

flavorRequiresAllFields:

• format: template flavorRequiresAllFields(T: type DefaultFlavor): bool
• format: template flavorRequiresAllFields(T: type DummyFlavor): bool

flavorSkipNullFields:

• format: template flavorSkipNullFields(T: type DefaultFlavor): bool
• format: template flavorSkipNullFields(T: type DummyFlavor): bool

flavorUsesAutomaticObjectSerialization:

• format: template flavorUsesAutomaticObjectSerialization(T: type DefaultFlavor): bool
• format: template flavorUsesAutomaticObjectSerialization(T: type DummyFlavor): bool

formatMsg:

• reader_desc: method formatMsg(err: ref GenericJsonReaderError; filename: string): string
• reader_desc: method formatMsg(err: ref IncompleteObjectError; filename: string): string
• reader_desc: method formatMsg(err: ref IntOverflowError; filename: string): string
• reader_desc: method formatMsg(err: ref JsonReaderError; filename: string): string
• reader_desc: method formatMsg(err: ref UnexpectedField; filename: string): string
• reader_desc: method formatMsg(err: ref UnexpectedTokenError; filename: string): string
• reader_desc: method formatMsg(err: ref UnexpectedValueError; filename: string): string

FractionPart:

• parser: NumberPart.FractionPart

generateJsonAutoSerializationAddon:

• format: template generateJsonAutoSerializationAddon(FLAVOR: typed)

GenericJsonReaderError:

• reader_desc: object GenericJsonReaderError

handleReadException:

• reader_desc: proc handleReadException(lex: JsonLexer; Record: type; fieldName: string; field: auto; err: ref CatchableError)
• reader_desc: template handleReadException(r: JsonReader; Record: type; fieldName: string; field: auto; err: ref CatchableError)

hasExponent:

• types: proc hasExponent[T](x: JsonNumber[T]): bool

IncompleteObjectError:

• reader_desc: object IncompleteObjectError

init:

• lexer: proc init(T: type JsonLexer; stream: InputStream; flags: JsonReaderFlags = defaultJsonReaderFlags; conf: JsonReaderConf = defaultJsonReaderConf): T:type
• reader_desc: proc init(T: type JsonReader; stream: InputStream; allowUnknownFields = false; requireAllFields = false): T:type
• reader_desc: proc init(T: type JsonReader; stream: InputStream; flags: JsonReaderFlags; conf: JsonReaderConf = defaultJsonReaderConf): T:type
• writer: proc init(W: type JsonWriter; stream: OutputStream; pretty = false; typeAnnotations = false): W:type

IntegerPart:

• parser: NumberPart.IntegerPart

IntOverflowError:

• reader_desc: object IntOverflowError

isErr:

• lexer: proc isErr(lex: JsonLexer): bool

isFieldExpected:

• reader_impl: proc isFieldExpected(T: type): bool

isFloat:

• types: proc isFloat(x: JsonNumber): bool

Json:

• format: object Json

JsonError:

• types: object JsonError

JsonErrorKind:

• lexer: enum JsonErrorKind

JsonLexer:

• lexer: object JsonLexer

JsonNumber:

• types: object JsonNumber

JsonObjectType:

• types: type JsonObjectType

JsonReader:

• reader_desc: object JsonReader

JsonReaderConf:

• types: object JsonReaderConf

JsonReaderError:

• reader_desc: object JsonReaderError

JsonReaderFlag:

• types: enum JsonReaderFlag

JsonReaderFlags:

• types: type JsonReaderFlags

JsonSign:

• types: enum JsonSign

JsonString:

• types: type JsonString

JsonValue:

• types: object JsonValue

JsonValueKind:

• types: enum JsonValueKind

JsonValueRef:

• types: type JsonValueRef

JsonVoid:

• types: object JsonVoid

JsonWriter:

• writer: object JsonWriter

maxPortableInt:

• types: const maxPortableInt

mimeType:

• format: template mimeType(T: type Json): string

minPortableInt:

• types: const minPortableInt

nonws:

• lexer: proc nonws(lex: var JsonLexer): char

NumberPart:

• parser: enum NumberPart

parseArray:

• parser: template parseArray(r: var JsonReader; body: untyped)
• parser: template parseArray(r: var JsonReader; idx: untyped; body: untyped)

parseArrayImpl:

• lexer: template parseArrayImpl(lex: JsonLexer; numElem: untyped; actionInitial: untyped; actionClosing: untyped; actionComma: untyped; actionValue: untyped; actionError: untyped)

parseAsString:

• parser: proc parseAsString(r: var JsonReader): JsonString
• parser: proc parseAsString(r: var JsonReader; val: var string)

parseBool:

• parser: proc parseBool(r: var JsonReader): bool

parseFloat:

• parser: proc parseFloat(r: var JsonReader; T: type SomeFloat): T:type

parseInt:

• parser: proc parseInt(r: var JsonReader; T: type SomeInteger; portable: bool = false): T:type

parseJsonNode:

• parser: proc parseJsonNode(r: var JsonReader): JsonNode

parseNull:

• parser: proc parseNull(r: var JsonReader)

parseNumber:

• parser: proc parseNumber(r: var JsonReader; val: var JsonNumber)
• parser: template parseNumber(r: var JsonReader; T: type): auto

parseObject:

• parser: template parseObject(r: var JsonReader; key: untyped; body: untyped)

parseObjectCustomKey:

• parser: template parseObjectCustomKey(r: var JsonReader; keyAction: untyped; body: untyped)

parseObjectImpl:

• lexer: template parseObjectImpl(lex: JsonLexer; skipNullFields: static[bool]; actionInitial: untyped; actionClosing: untyped; actionComma: untyped; actionKey: untyped; actionValue: untyped; actionError: untyped)

parseObjectSkipNullFields:

• parser: template parseObjectSkipNullFields(r: var JsonReader; key: untyped; body: untyped)

parseObjectWithoutSkip:

• parser: template parseObjectWithoutSkip(r: var JsonReader; key: untyped; body: untyped)

parseString:

• parser: proc parseString(r: var JsonReader): string
• parser: proc parseString(r: var JsonReader; limit: int): string

parseValue:

• parser: proc parseValue(r: var JsonReader; val: var JsonValueRef)
• parser: template parseValue(r: var JsonReader; T: type): auto

PreferredOutputType:

• writer: template PreferredOutputType(T`gensym0: type Json): type

raiseIncompleteObject:

• reader_desc: proc raiseIncompleteObject(lex: JsonLexer; objectType: cstring)
• reader_desc: template raiseIncompleteObject(r: JsonReader; objectType: cstring)

raiseIntOverflow:

• reader_desc: proc raiseIntOverflow(lex: JsonLexer; absIntVal: BiggestUInt; isNegative: bool)
• reader_desc: template raiseIntOverflow(r: JsonReader; absIntVal: BiggestUInt; isNegative: bool)

raiseUnexpectedField:

• reader_desc: proc raiseUnexpectedField(lex: JsonLexer; fieldName: string; deserializedType: cstring)
• reader_desc: template raiseUnexpectedField(r: JsonReader; fieldName: string; deserializedType: cstring)

raiseUnexpectedToken:

• reader_desc: proc raiseUnexpectedToken(lex: var JsonLexer; expected: ExpectedTokenCategory)
• reader_desc: template raiseUnexpectedToken(reader: JsonReader; expected: ExpectedTokenCategory)

raiseUnexpectedValue:

• reader_desc: proc raiseUnexpectedValue(lex: JsonLexer; msg: string)
• reader_desc: template raiseUnexpectedValue(r: JsonReader; msg: string)

readArray:

• reader_impl: iterator readArray(r: var JsonReader; ElemType: typedesc): ElemType:type

Reader:

• reader_desc: template Reader(T`gensym0: type Json; F`gensym0: distinct type = DefaultFlavor): type

ReaderType:

• reader_desc: template ReaderType(T`gensym0: type Json; F`gensym0: distinct type = DefaultFlavor): type

readObject:

• reader_impl: iterator readObject(r: var JsonReader; KeyType: type; ValueType: type): (KeyType:type, ValueType:type)

readObjectFields:

• reader_impl: iterator readObjectFields(r: var JsonReader): string
• reader_impl: iterator readObjectFields(r: var JsonReader; KeyType: type): KeyType:type

readRecordValue:

• reader_impl: proc readRecordValue[T](r: var JsonReader; value: var T)

readValue:

• reader_impl: proc readValue[T](r: var JsonReader; value: var T)

scanArray:

• lexer: proc scanArray[T](lex: var JsonLexer; val: var T)

scanBool:

• lexer: proc scanBool(lex: var JsonLexer): bool

scanNull:

• lexer: proc scanNull(lex: var JsonLexer)

scanNumber:

• lexer: proc scanNumber[T](lex: var JsonLexer; val: var T)

scanObject:

• lexer: proc scanObject[T](lex: var JsonLexer; val: var T)

scanString:

• lexer: proc scanString[T](lex: var JsonLexer; val: var T; limit: int)

scanValue:

• lexer: proc scanValue[T](lex: var JsonLexer; val: var T)

serializesAsTextInJson:

• writer: template serializesAsTextInJson(T: type[enum])

shouldWriteObjectField:

• writer: template shouldWriteObjectField[FieldType](field: FieldType): bool

SignPart:

• parser: NumberPart.SignPart

skipSingleJsValue:

• parser: proc skipSingleJsValue(lex: var JsonLexer)
• parser: template skipSingleJsValue(r: var JsonReader)

stepwiseArrayCreation:

• writer: iterator stepwiseArrayCreation[C](w: var JsonWriter; collection: C): auto

streamElement:

• writer: template streamElement(w: var JsonWriter; streamVar: untyped; body: untyped)

supports:

• format: template supports(_: type Json; T: type): bool

toFloat:

• parser: proc toFloat(r: var JsonReader; val: JsonNumber; T: type SomeFloat): T:type

toInt:

• parser: proc toInt(r: var JsonReader; val: JsonNumber; T: type SomeSignedInt; portable: bool): T:type
• parser: proc toInt(r: var JsonReader; val: JsonNumber; T: type SomeUnsignedInt; portable: bool): T:type
• types: proc toInt(sign: JsonSign): int

toJson:

• writer: proc toJson(v: auto; pretty = false; typeAnnotations = false; Flavor = DefaultFlavor): string

tokenStartCol:

• lexer: proc tokenStartCol(lex: JsonLexer): int

tokKind:

• lexer: proc tokKind(lex: var JsonLexer): JsonValueKind
• parser: proc tokKind(r: var JsonReader): JsonValueKind

totalExpectedFields:

• reader_impl: proc totalExpectedFields(T: type): int

typeAutoSerialize:

• format: proc typeAutoSerialize(F: type DefaultFlavor; TM: distinct type): bool
• format: proc typeAutoSerialize(F: type DummyFlavor; TM: distinct type): bool

typeClassOrMemberAutoSerialize:

• format: proc typeClassOrMemberAutoSerialize(F: type DefaultFlavor; TC: distinct type; TM: distinct type): bool
• format: proc typeClassOrMemberAutoSerialize(F: type DummyFlavor; TC: distinct type; TM: distinct type): bool

UnexpectedField:

• reader_desc: object UnexpectedField

UnexpectedTokenError:

• reader_desc: object UnexpectedTokenError

UnexpectedValueError:

• reader_desc: object UnexpectedValueError

valueType:

• types: template valueType[K, V](_: type OrderedTable[K, V]): untyped

writeArray:

• writer: proc writeArray[C: not void](w: var JsonWriter; values: C)
• writer: template writeArray[T: void](w: var JsonWriter; body: T)

writeField:

• writer: template writeField(w: var JsonWriter; name: string; value: auto)

writeFieldName:

• writer: template writeFieldName(w: var JsonWriter; name: string)

writeIterable:

• writer: proc writeIterable(w: var JsonWriter; collection: auto)

writeMember:

• writer: proc writeMember[V: not void](w: var JsonWriter; name: string; value: V)
• writer: template writeMember[T: void](w: var JsonWriter; name: string; body: T)

writeName:

• writer: proc writeName(w: var JsonWriter; name: string)

writeObject:

• writer: template writeObject[T: void](w: var JsonWriter; body: T)
• writer: template writeObject[T: void](w: var JsonWriter; O: type; body: T)

writeObjectField:

• writer: template writeObjectField[FieldType, RecordType](w: var JsonWriter; record: RecordType; fieldName: static string; field: FieldType)

Writer:

• writer: template Writer(T`gensym0: type Json; F`gensym0: distinct type = DefaultFlavor): type

writeRecordValue:

• writer: proc writeRecordValue(w: var JsonWriter; value: object | tuple)

WriterType:

• writer: template WriterType(T`gensym0: type Json; F`gensym0: distinct type = DefaultFlavor): type

writeValue:

• writer: proc writeValue(w: var JsonWriter; value: JsonNumber)
• writer: proc writeValue(w: var JsonWriter; value: JsonObjectType)
• writer: proc writeValue(w: var JsonWriter; value: JsonValue)
• writer: proc writeValue[V: not void](w: var JsonWriter; value: V)
• writer: template writeValue(w: var JsonWriter; value: enum)