Class SArray<ItemSchema, ItemType>

a schema node for an array of a single type

Type Parameters

  • ItemSchema extends SchemaChildNode

  • ItemType = NonNullable<ItemSchema["value"]>

Hierarchy

Properties

value?: ItemType[]

the value held by this schema node. used as a storage for interceptors to interact and read decoded value
it can also used as a means for storing default values for the encoder to utilize.
but besides those two scenarios, it should typically be left unassigned.
this also comes in handy when annotating types both for the encoder or decoder

name?: string

name of the node, used for object property key naming by parent SchemaRecordNode

doc?: string | true

an optional doc string for this schema node, that should be cleared when MINIFY is true
to achive that, you would want to write your doc strings as follows:

declare const [DEBUG, MINIFY, BUNDLE]: [boolean, boolean, boolean]
const my_schema_node: SPrimitive<number> {
type: "u4l",
doc: MINIFY || "a stupid description of this 32-bit unsinged little piece of endian."
}
type: "array"

a mandatory kind descriptior of the primitive kind

children: [item_schema: ItemSchema]

there must be only a single child element that specifies the schema of the kind of items held by this array

args: [index_start: number, index_end: number] | [len?: number]

there are two possible syntaxes, and the one that gets chosen is based on the length of this.args

  • if args.length == 1, then: args[0] must specify the length of the array when decoding
  • if args.length == 2, then: args[0] must specify the starting index, and args[1] must specify the ending index

Methods

  • manually set this schema's type to the provided type_name, and also register the new type_name to global type_registery if register = true.
    this is the only easy way to register type_names of sub-sub-classes of abstract SchemaNode.
    check out SHeadArray to see how it extends SArray, but registers its own type_name = "headarray" that's different from its parent class's type_name = "array"

    Type Parameters

    • NewTypeName extends string

    Parameters

    • type_name: NewTypeName
    • register: boolean = true

    Returns SArray<ItemSchema, ItemType> & {
        type: NewTypeName;
    }

  • Type Parameters

    • Name extends string

    Parameters

    • name: Name

    Returns SArray<ItemSchema, ItemType> & {
        name: Name;
    }

  • Parameters

    • Rest ...children: [item_schema: ItemSchema]

    Returns Require<SArray<ItemSchema, ItemType>, "children">

  • Parameters

    • value: ItemType[]

    Returns Require<SArray<ItemSchema, ItemType>, "value">

  • Parameters

    • Rest ...args: NonNullable<[index_start: number, index_end: number] | [len?: number]>

    Returns SArray<ItemSchema, ItemType>

  • Parameters

    • Rest ...args: NonNullable<[index_start: number, index_end: number] | [len?: number]>

    Returns SArray<ItemSchema, ItemType>

  • an abstract static method that creates an instance of this schema class, using a regular javascript object

    Parameters

    Returns SArray<SchemaNode<unknown, string>, {}>

  • describe how an instance of this schema node should be encoded into bytes

    Parameters

    • value: ItemType[]
    • Rest ...args: [index_start?: number, index_end?: number]

    Returns Uint8Array

  • describe bytes from a buffer should decode a value for this schema node

    Parameters

    • buf: Uint8Array
    • offset: number
    • Rest ...args: [index_start?: number, index_end?: number] | [len?: number]

    Returns Decoded<ItemType[], number>

  • decode one item

    Parameters

    • buf: Uint8Array
    • offset: number
    • Rest ...args: never[]

    Returns Decoded<ItemType, number>

Constructors

  • Type Parameters

    • ItemSchema extends SchemaChildNode<any, string, ItemSchema>

    • ItemType = NonNullable<ItemSchema["value"]>

    Parameters

    • Optional child: ItemSchema
    • Optional array_length: number

    Returns SArray<ItemSchema, ItemType>

Generated using TypeDoc