Options
All
  • Public
  • Public/Protected
  • All
Menu

Class ReconWriter<I, V>

Factory for constructing Recon writers.

Type parameters

  • I

  • V

Hierarchy

Index

Methods

Methods

Abstract isAttr

  • isAttr(item: I): boolean

isBlockSafe

  • isBlockSafe(items: Cursor<I>): boolean

Abstract isBool

  • isBool(item: I): boolean

Abstract isExpression

  • isExpression(item: I): boolean

Abstract isExtant

  • isExtant(item: I): boolean

Abstract isField

  • isField(item: I): boolean

isIdent

  • isIdent(value: I | string): boolean

isMarkupSafe

  • isMarkupSafe(items: Cursor<I>): boolean

Abstract isNum

  • isNum(item: I): boolean

Abstract isRecord

  • isRecord(item: I): boolean

Abstract isSlot

  • isSlot(item: I): boolean

Abstract isText

  • isText(item: I): boolean

Abstract isValue

  • isValue(item: I): boolean

Abstract item

  • item(value: V): I

Abstract items

Abstract key

  • key(item: I): V

Abstract precedence

  • precedence(item: I): number

sizeOfAbsent

  • sizeOfAbsent(): number

sizeOfAttr

  • sizeOfAttr(key: V, value: V): number

sizeOfBlock

  • sizeOfBlock(item: I): number
  • sizeOfBlock(items: Cursor<I>, inBlock: boolean, inMarkup: boolean): number

Abstract sizeOfBlockItem

  • sizeOfBlockItem(item: I): number

Abstract sizeOfBlockValue

  • sizeOfBlockValue(value: V): number

sizeOfBool

  • sizeOfBool(value: boolean): number

sizeOfChildrenSelector

  • sizeOfChildrenSelector(then: V): number

sizeOfConditionalOperator

  • sizeOfConditionalOperator(ifTerm: I, thenTerm: I, elseTerm: I, precedence: number): number

sizeOfData

  • sizeOfData(length: number): number

sizeOfDescendantsSelector

  • sizeOfDescendantsSelector(then: V): number

sizeOfExtant

  • sizeOfExtant(): number

sizeOfFilterSelector

  • sizeOfFilterSelector(predicate: V, then: V): number

sizeOfGetAttrSelector

  • sizeOfGetAttrSelector(key: V, then: V): number

sizeOfGetItemSelector

  • sizeOfGetItemSelector(index: V, then: V): number

sizeOfGetSelector

  • sizeOfGetSelector(key: V, then: V): number

sizeOfIdentitySelector

  • sizeOfIdentitySelector(): number

sizeOfInfixOperator

  • sizeOfInfixOperator(lhs: I, operator: string, rhs: I, precedence: number): number

sizeOfInvokeOperator

  • sizeOfInvokeOperator(func: V, args: V): number

Abstract sizeOfItem

  • sizeOfItem(item: I): number

sizeOfKeysSelector

  • sizeOfKeysSelector(then: V): number

sizeOfLambdaFunc

  • sizeOfLambdaFunc(bindings: V, template: V): number

sizeOfLiteralSelector

  • sizeOfLiteralSelector(item: I, then: V): number

sizeOfMarkupText

  • sizeOfMarkupText(item: I | string): number

sizeOfNum

  • sizeOfNum(value: number): number

sizeOfPrefixOperator

  • sizeOfPrefixOperator(operator: string, rhs: I, precedence: number): number

sizeOfPrimary

  • sizeOfPrimary(value: V): number

sizeOfRecord

  • sizeOfRecord(item: I): number

sizeOfSlot

  • sizeOfSlot(key: V, value: V): number

sizeOfText

  • sizeOfText(value: string): number

Abstract sizeOfThen

  • sizeOfThen(then: V): number

sizeOfThenChildrenSelector

  • sizeOfThenChildrenSelector(then: V): number

sizeOfThenDescendantsSelector

  • sizeOfThenDescendantsSelector(then: V): number

sizeOfThenFilterSelector

  • sizeOfThenFilterSelector(predicate: V, then: V): number

sizeOfThenGetAttrSelector

  • sizeOfThenGetAttrSelector(key: V, then: V): number

sizeOfThenGetItemSelector

  • sizeOfThenGetItemSelector(index: V, then: V): number

sizeOfThenGetSelector

  • sizeOfThenGetSelector(key: V, then: V): number

sizeOfThenIdentitySelector

  • sizeOfThenIdentitySelector(): number

sizeOfThenKeysSelector

  • sizeOfThenKeysSelector(then: V): number

sizeOfThenLiteralSelector

  • sizeOfThenLiteralSelector(item: I, then: V): number

sizeOfThenValuesSelector

  • sizeOfThenValuesSelector(then: V): number

sizeOfUint32

  • sizeOfUint32(value: number): number

sizeOfUint64

  • sizeOfUint64(value: number): number

Abstract sizeOfValue

  • sizeOfValue(value: V): number

sizeOfValuesSelector

  • sizeOfValuesSelector(then: V): number

Abstract string

  • string(item: I): string

Abstract value

  • value(item: I): V

writeAbsent

writeAttr

writeBlock

Abstract writeBlockItem

Abstract writeBlockValue

writeBool

writeChildrenSelector

writeConditionalOperator

  • writeConditionalOperator(ifTerm: I, thenTerm: I, elseTerm: I, precedence: number, output: Output): Writer

writeData

  • writeData(value: Uint8Array | undefined, output: Output): Writer

writeDescendantsSelector

writeExtant

writeFilterSelector

  • writeFilterSelector(predicate: V, then: V, output: Output): Writer

writeGetAttrSelector

  • writeGetAttrSelector(key: V, then: V, output: Output): Writer

writeGetItemSelector

  • writeGetItemSelector(index: V, then: V, output: Output): Writer

writeGetSelector

writeIdentitySelector

writeInfixOperator

  • writeInfixOperator(lhs: I, operator: string, rhs: I, precedence: number, output: Output): Writer

writeInvokeOperator

  • writeInvokeOperator(func: V, args: V, output: Output): Writer

Abstract writeItem

writeKeysSelector

writeLambdaFunc

  • writeLambdaFunc(bindings: V, template: V, output: Output): Writer

writeLiteralSelector

  • writeLiteralSelector(item: I, then: V, output: Output): Writer

writeMarkupText

writeNum

writePrefixOperator

  • writePrefixOperator(operator: string, rhs: I, precedence: number, output: Output): Writer

writePrimary

writeRecord

writeSlot

writeText

Abstract writeThen

writeThenChildrenSelector

  • writeThenChildrenSelector(then: V, output: Output): Writer

writeThenDescendantsSelector

  • writeThenDescendantsSelector(then: V, output: Output): Writer

writeThenFilterSelector

  • writeThenFilterSelector(predicate: V, then: V, output: Output): Writer

writeThenGetAttrSelector

  • writeThenGetAttrSelector(key: V, then: V, output: Output): Writer

writeThenGetItemSelector

  • writeThenGetItemSelector(index: V, then: V, output: Output): Writer

writeThenGetSelector

  • writeThenGetSelector(key: V, then: V, output: Output): Writer

writeThenIdentitySelector

writeThenKeysSelector

writeThenLiteralSelector

  • writeThenLiteralSelector(item: I, then: V, output: Output): Writer

writeThenValuesSelector

writeUint32

writeUint64

Abstract writeValue

writeValuesSelector