seatrecwire

package
v1.5.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 17, 2026 License: MIT Imports: 12 Imported by: 0

Documentation

Overview

Package seatrecwire is the seat, tokens and place-receipt table wire, generated by the schema compiler from schemas/seatrec/seatrec.schema: the seat environment (which sealed file a seat uses, and where), the tokens day file, the tokens bus roster, and the secrets place receipt (what was placed, by the sealed file). They are VARIABLE tables: each holds text or lists the code does not bound. Every other .go file here is generated: edit the .schema and run go generate ./pkg/seatrecwire, never the output. pkg/schemaread reads each strictly: binary wire, padded standard base64 of the wire or the JSON text form, each refused by name when damaged.

Index

Constants

View Source
const (
	TableFixedReasonPreviousForm         = "previous_form"
	TableFixedReasonMessageFormAsFile    = "message_form_as_file"
	TableFixedReasonNewerForm            = "newer_form"
	TableFixedReasonLayoutMalformed      = "layout_malformed"
	TableFixedReasonLayoutUnknown        = "layout_unknown"
	TableFixedReasonLayoutNewer          = "layout_newer"
	TableFixedReasonLayoutUnsupported    = "layout_unsupported"
	TableFixedReasonLayoutRecordTooLarge = "layout_record_too_large"
	TableFixedReasonPlanTooLarge         = "plan_too_large"
	TableFixedReasonBatchTooLarge        = "batch_too_large"
	TableFixedReasonNoLayout             = "no_layout"
	TableFixedReasonTextIllFormed        = "text_ill_formed"
	TableFixedReasonTruncated            = "truncated"
	TableFixedReasonReservedNotZero      = "reserved_not_zero"
)

THE FIXED LOAD'S REFUSAL NAMES — EXPORTED (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.3, mas-bandwidth/schema docs/SPEC-TABLES.md §3.4). Every refusal of the fixed load has a name, the framing-damage returns included, so an adopter's existing report.Reason == "layout_newer" comparisons keep compiling against these constants; the emitted <T>FixedLoad names every reason constant in place of a string literal.

TableFixedReasonLayoutUnknown is the Reason of a file whose header hash no entry of this build's lineage holds (mas-bandwidth/schema docs/SPEC-TABLES.md §21.3, algorithm §5.3 step 5). It says what the reader knows and not which way the file lies: a newer writer's layout, an older one nobody locked and a damaged hash byte read the same.

TableFixedReasonLayoutNewer ("ship the reader") is RESERVED (SPEC-TABLES §21.3) for a hash the lock lineage proves newer, which nothing on the wire or in the lock does today, so no Go fixed load answers it; it stays exported so an adopter's existing comparisons keep compiling.

View Source
const BuildVersion uint64 = 0xde220d8d9f8f3d83

BuildVersion is the unit's build version (mas-bandwidth/schema docs/SPEC-TABLES.md §20): the one digest a block carries and BlockOpen compares, and the fact §3.3's announcement carries before the first body so a peer's build is knowable.

View Source
const BusRosterLoadRetainBuilder = "BusRoster: retention requires a region round trip through the VARIABLE form"
View Source
const BusRosterSaveRetainMessages = "BusRoster: retention requires a region round trip through the VARIABLE form"
View Source
const DayFileLoadRetainBuilder = "DayFile: retention requires a region round trip through the VARIABLE form"
View Source
const DayFileSaveRetainMessages = "DayFile: retention requires a region round trip through the VARIABLE form"
View Source
const DayLineLoadRetainBuilder = "DayLine: retention requires a region round trip through the VARIABLE form"
View Source
const DayLineSaveRetainMessages = "DayLine: retention requires a region round trip through the VARIABLE form"
View Source
const ParticipantLoadRetainBuilder = "Participant: retention requires a region round trip through the VARIABLE form"
View Source
const ParticipantSaveRetainMessages = "Participant: retention requires a region round trip through the VARIABLE form"
View Source
const PlacedReceiptLoadRetainBuilder = "PlacedReceipt: retention requires a region round trip through the VARIABLE form"
View Source
const PlacedReceiptSaveRetainMessages = "PlacedReceipt: retention requires a region round trip through the VARIABLE form"
View Source
const ProtocolId uint64 = 0xe7507216082d094b

The unit's protocol id — the hash of its wire shape (SPEC §3.1). Two sides at the same id speak identical bits; there is no other versioning.

View Source
const SeatEnvironmentLoadRetainBuilder = "SeatEnvironment: retention requires a region round trip through the VARIABLE form"
View Source
const SeatEnvironmentSaveRetainMessages = "SeatEnvironment: retention requires a region round trip through the VARIABLE form"
View Source
const SeatLoginLoadRetainBuilder = "SeatLogin: retention requires a region round trip through the VARIABLE form"
View Source
const SeatLoginSaveRetainMessages = "SeatLogin: retention requires a region round trip through the VARIABLE form"
View Source
const SourceLabelLoadRetainBuilder = "SourceLabel: retention requires a region round trip through the VARIABLE form"
View Source
const SourceLabelSaveRetainMessages = "SourceLabel: retention requires a region round trip through the VARIABLE form"
View Source
const TableCookHeaderBytes int64 = 64

TableCookHeaderBytes is §7.1's header: 64 bytes of u64 words. The DATA part begins at align_up(64, alignment) — DERIVED and not a header field, because a fact a reader computes is a fact two writers cannot disagree about.

View Source
const TableCookMagic uint64 = 0x4b4f4f434d484353

TableCookMagic is the cook's magic (mas-bandwidth/schema docs/SPEC-TABLES.md §7.1), read before anything else: it is what establishes the byte order every other header word is written in, and it is also what separates a COOK from a BLOCK — the two accelerators carry the same build version and different magics, because a form's identity belongs in its magic rather than in a second digest.

The value is "SCHMCOOK" read as ASCII in the byte order a little-endian store produces, so a hex dump of a little-endian cook is legible.

View Source
const TableCookMaxAlign int64 = 64

TableCookMaxAlign is the ceiling on the header's alignment word: the same sixty-four a block's base takes (§19.1), past which the derived data offset would no longer be the 64 every unit this language can declare produces.

View Source
const TableDocNone = ""

THE SHARED EMPTY DOC (mas-bandwidth/schema docs/SPEC-TABLES.md §8.1): a declaration with no /// block carries a doc column naming this one definition, so absence costs a unit no string data and a printer concatenates doc columns with no nil test. Go gives a string no address identity, so what the rule is READ OFF here is the emitted text: the generated file defines the empty doc once and every unannotated row names that definition, rather than each row carrying an inline "" of its own.

View Source
const TableFixedForm uint8 = 3
View Source
const TableFixedHashAt = 8
View Source
const TableFixedHeaderBytes = 16
View Source
const TableMessageBatchMax = 256
View Source
const TableMessageEntriesHere = 50
View Source
const TableMessageRefBitsHere = 6

Variables

View Source
var BusRosterTableFields = []TableFieldInfo{
	{Name: "participants", Json: "participants", TypeName: "Participant", DeclaredTypeName: "Participant", Id: 0xefa00499695c8287, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(BusRoster{}.Participants)), ElemSize: uint32(unsafe.Sizeof(*new(ParticipantRow))), CountOffset: (uint32(unsafe.Offsetof(BusRoster{}.Participants))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 16, CookCountOffset: 8, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: ParticipantTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

BusRosterTableFields is BusRoster's per-field reflection data (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

View Source
var DayFileTableFields = []TableFieldInfo{
	{Name: "day", Json: "day", TypeName: "string", DeclaredTypeName: "string", Id: 0xca8d3918f4578f1d, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 10, Offset: uint32(unsafe.Offsetof(DayFile{}.Day)), ElemSize: uint32(unsafe.Sizeof(DayFile{}.Day)), CountOffset: uint32(unsafe.Offsetof(DayFile{}.DayLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 12, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "at", Json: "at", TypeName: "string", DeclaredTypeName: "string", Id: 0x89c4e07b545a968, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayFile{}.At)), ElemSize: uint32(unsafe.Sizeof(DayFile{}.At)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "build", Json: "build", TypeName: "string", DeclaredTypeName: "string", Id: 0x802517e298c70b03, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayFile{}.Build)), ElemSize: uint32(unsafe.Sizeof(DayFile{}.Build)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "turns", Json: "turns", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x7f189dd0bc4902cb, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayFile{}.Turns)), ElemSize: uint32(unsafe.Sizeof(DayFile{}.Turns)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(DayFile{}.TurnsPresent)),
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 40,
		HasRange: true, RangeMin: 0.0, RangeMax: 9.223372036854776e+18, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "sources", Json: "sources", TypeName: "SourceLabel", DeclaredTypeName: "SourceLabel", Id: 0x6fc4d9b9c935cff1, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(DayFile{}.Sources)), ElemSize: uint32(unsafe.Sizeof(*new(SourceLabelRow))), CountOffset: (uint32(unsafe.Offsetof(DayFile{}.Sources))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 48, CookElemSize: 8, CookCountOffset: 56, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: SourceLabelTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "rows", Json: "rows", TypeName: "DayLine", DeclaredTypeName: "DayLine", Id: 0xa3a7061ff10a8138, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(DayFile{}.Rows)), ElemSize: uint32(unsafe.Sizeof(*new(DayLineRow))), CountOffset: (uint32(unsafe.Offsetof(DayFile{}.Rows))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 64, CookElemSize: 144, CookCountOffset: 72, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: DayLineTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

DayFileTableFields is DayFile's per-field reflection data (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

View Source
var DayLineTableFields = []TableFieldInfo{
	{Name: "date", Json: "date", TypeName: "string", DeclaredTypeName: "string", Id: 0x855b516730a34339, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 10, Offset: uint32(unsafe.Offsetof(DayLine{}.Date)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.Date)), CountOffset: uint32(unsafe.Offsetof(DayLine{}.DateLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 12, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "model", Json: "model", TypeName: "string", DeclaredTypeName: "string", Id: 0x9de543933e6e703a, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.Model)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.Model)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "repo", Json: "repo", TypeName: "string", DeclaredTypeName: "string", Id: 0x4cac581fbfac663d, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.Repo)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.Repo)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "input", Json: "input", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x1ebbae8f5810b65b, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.Input)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.Input)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(DayLine{}.InputPresent)),
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 40,
		HasRange: true, RangeMin: 0.0, RangeMax: 9.223372036854776e+18, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "output", Json: "output", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x150f53f8651b4384, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.Output)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.Output)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(DayLine{}.OutputPresent)),
		CookOffset: 48, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 56,
		HasRange: true, RangeMin: 0.0, RangeMax: 9.223372036854776e+18, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "cache_write", Json: "cache_write", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x313c6440b18aae09, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.CacheWrite)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.CacheWrite)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(DayLine{}.CacheWritePresent)),
		CookOffset: 64, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 72,
		HasRange: true, RangeMin: 0.0, RangeMax: 9.223372036854776e+18, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "cache_read", Json: "cache_read", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x779748cd7970e246, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.CacheRead)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.CacheRead)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(DayLine{}.CacheReadPresent)),
		CookOffset: 80, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 88,
		HasRange: true, RangeMin: 0.0, RangeMax: 9.223372036854776e+18, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "reasoning", Json: "reasoning", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x938f9c45fb249647, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.Reasoning)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.Reasoning)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(DayLine{}.ReasoningPresent)),
		CookOffset: 96, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 104,
		HasRange: true, RangeMin: 0.0, RangeMax: 9.223372036854776e+18, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "rough", Json: "rough", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x30f50e469eeeb28e, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.Rough)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.Rough)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 112, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 9.223372036854776e+18, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "basis", Json: "basis", TypeName: "string", DeclaredTypeName: "string", Id: 0xd6e86e826dfb3bed, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DayLine{}.Basis)), ElemSize: uint32(unsafe.Sizeof(DayLine{}.Basis)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 120, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "sources", Json: "sources", TypeName: "SourceLabel", DeclaredTypeName: "SourceLabel", Id: 0x6fc4d9b9c935cff1, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(DayLine{}.Sources)), ElemSize: uint32(unsafe.Sizeof(*new(SourceLabelRow))), CountOffset: (uint32(unsafe.Offsetof(DayLine{}.Sources))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 128, CookElemSize: 8, CookCountOffset: 136, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: SourceLabelTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

DayLineTableFields is DayLine's per-field reflection data (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

View Source
var ErrValidation = errors.New("seatrecwire: wire validation failed")

ErrValidation is returned when a read rejects the wire: a wrong constant, nonzero reserved bits, or an interior null in a string (SPEC §4.3, §4.7).

View Source
var ParticipantTableFields = []TableFieldInfo{
	{Name: "name", Json: "name", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4bcadba8e631b86, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Participant{}.Name)), ElemSize: uint32(unsafe.Sizeof(Participant{}.Name)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "lane", Json: "lane", TypeName: "string", DeclaredTypeName: "string", Id: 0x460ddad9060af0f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Participant{}.Lane)), ElemSize: uint32(unsafe.Sizeof(Participant{}.Lane)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

ParticipantTableFields is Participant's per-field reflection data (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

View Source
var PlacedReceiptTableFields = []TableFieldInfo{
	{Name: "secret", Json: "secret", TypeName: "string", DeclaredTypeName: "string", Id: 0xab23f0eec020c951, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(PlacedReceipt{}.Secret)), ElemSize: uint32(unsafe.Sizeof(PlacedReceipt{}.Secret)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "path", Json: "path", TypeName: "string", DeclaredTypeName: "string", Id: 0x3c52d0debd70676, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(PlacedReceipt{}.Path)), ElemSize: uint32(unsafe.Sizeof(PlacedReceipt{}.Path)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "file", Json: "file", TypeName: "string", DeclaredTypeName: "string", Id: 0xaad01178f02a6a23, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(PlacedReceipt{}.File)), ElemSize: uint32(unsafe.Sizeof(PlacedReceipt{}.File)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "head", Json: "head", TypeName: "string", DeclaredTypeName: "string", Id: 0xa8f12cc5f9a0c03, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(PlacedReceipt{}.Head)), ElemSize: uint32(unsafe.Sizeof(PlacedReceipt{}.Head)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "blob", Json: "blob", TypeName: "string", DeclaredTypeName: "string", Id: 0xc573b39bc29148ca, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(PlacedReceipt{}.Blob)), ElemSize: uint32(unsafe.Sizeof(PlacedReceipt{}.Blob)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "stamp", Json: "stamp", TypeName: "string", DeclaredTypeName: "string", Id: 0xee7ba9ad45c64144, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(PlacedReceipt{}.Stamp)), ElemSize: uint32(unsafe.Sizeof(PlacedReceipt{}.Stamp)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

PlacedReceiptTableFields is PlacedReceipt's per-field reflection data (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

View Source
var SeatEnvironmentTableFields = []TableFieldInfo{
	{Name: "version", Json: "version", TypeName: "int32", DeclaredTypeName: "int32", Id: 0xbb62c62c9808ea37, Kind: 4, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatEnvironment{}.Version)), ElemSize: uint32(unsafe.Sizeof(SeatEnvironment{}.Version)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(SeatEnvironment{}.VersionPresent)),
		CookOffset: 0, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "forge_identity", Json: "forge_identity", TypeName: "string", DeclaredTypeName: "string", Id: 0x5f122daed6fcc133, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatEnvironment{}.ForgeIdentity)), ElemSize: uint32(unsafe.Sizeof(SeatEnvironment{}.ForgeIdentity)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "nova_sprint_redis", Json: "nova_sprint_redis", TypeName: "string", DeclaredTypeName: "string", Id: 0x2826e06f7b226d28, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatEnvironment{}.NovaSprintRedis)), ElemSize: uint32(unsafe.Sizeof(SeatEnvironment{}.NovaSprintRedis)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "nova_sprint_server", Json: "nova_sprint_server", TypeName: "string", DeclaredTypeName: "string", Id: 0xbe2f0f1d219ab446, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatEnvironment{}.NovaSprintServer)), ElemSize: uint32(unsafe.Sizeof(SeatEnvironment{}.NovaSprintServer)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "nova_bus_redis", Json: "nova_bus_redis", TypeName: "string", DeclaredTypeName: "string", Id: 0x8446977236f3ac26, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatEnvironment{}.NovaBusRedis)), ElemSize: uint32(unsafe.Sizeof(SeatEnvironment{}.NovaBusRedis)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "login", Json: "login", TypeName: "SeatLogin", DeclaredTypeName: "SeatLogin", Id: 0x3c75db6e18f29d2, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatEnvironment{}.Login)), ElemSize: uint32(unsafe.Sizeof(SeatEnvironment{}.Login)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x88a63964ecf1ddc5,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: SeatLoginTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

SeatEnvironmentTableFields is SeatEnvironment's per-field reflection data (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

View Source
var SeatLoginTableFields = []TableFieldInfo{
	{Name: "redis", Json: "redis", TypeName: "string", DeclaredTypeName: "string", Id: 0xa30c3ff3148ac374, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatLogin{}.Redis)), ElemSize: uint32(unsafe.Sizeof(SeatLogin{}.Redis)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "user", Json: "user", TypeName: "string", DeclaredTypeName: "string", Id: 0x7d6780e4032b48f2, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatLogin{}.User)), ElemSize: uint32(unsafe.Sizeof(SeatLogin{}.User)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "store", Json: "store", TypeName: "string", DeclaredTypeName: "string", Id: 0x44ee54ad76b0bd8e, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatLogin{}.Store)), ElemSize: uint32(unsafe.Sizeof(SeatLogin{}.Store)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "as_name", Json: "as", TypeName: "string", DeclaredTypeName: "string", Id: 0x8e5c9519cf8cfeb5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatLogin{}.AsName)), ElemSize: uint32(unsafe.Sizeof(SeatLogin{}.AsName)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "key", Json: "key", TypeName: "string", DeclaredTypeName: "string", Id: 0x3dc94a19365b10ec, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatLogin{}.Key)), ElemSize: uint32(unsafe.Sizeof(SeatLogin{}.Key)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "sops", Json: "sops", TypeName: "string", DeclaredTypeName: "string", Id: 0x5ff4de18f0844142, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatLogin{}.Sops)), ElemSize: uint32(unsafe.Sizeof(SeatLogin{}.Sops)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "secret", Json: "secret", TypeName: "string", DeclaredTypeName: "string", Id: 0xab23f0eec020c951, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SeatLogin{}.Secret)), ElemSize: uint32(unsafe.Sizeof(SeatLogin{}.Secret)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 48, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

SeatLoginTableFields is SeatLogin's per-field reflection data (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

View Source
var SourceLabelTableFields = []TableFieldInfo{
	{Name: "text", Json: "text", TypeName: "string", DeclaredTypeName: "string", Id: 0xfa04f4ef1995407e, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SourceLabel{}.Text)), ElemSize: uint32(unsafe.Sizeof(SourceLabel{}.Text)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

SourceLabelTableFields is SourceLabel's per-field reflection data (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

View Source
var TableCookByteOrder = tableCookNativeOrder()

TableCookByteOrder is THIS BUILD's byte order, as §7.1's order word records it. The byte order is settled AT COOK TIME for the target build, so a matching build version already means a matching order and Open never fixes anything up; a cook whose recorded order is not this build's is simply not this build's file.

Functions

func Announce

func Announce(buffer []byte) int64

func AnnounceMeasure

func AnnounceMeasure() int64

func AnnounceRead

func AnnounceRead(v *TableVocabulary, data []byte, report *TableReport) bool

func BusRosterCookFrom

func BusRosterCookFrom(value *BusRoster, buffer []byte, order TableByteOrder, context ...TableWriteContext) bool

func BusRosterCookMeasure

func BusRosterCookMeasure(value *BusRoster, context ...TableWriteContext) int64

func BusRosterCookMeasureReason

func BusRosterCookMeasureReason(value *BusRoster, context ...TableWriteContext) (int64, error)

func BusRosterFromJson

func BusRosterFromJson(builder *BusRosterBuilder, text []byte, report *TableReport) bool

func BusRosterLoadBody

func BusRosterLoadBody(r *TableReader, value *BusRoster) bool

func BusRosterLoadBodyRetain

func BusRosterLoadBodyRetain(r *TableRetainReader, value *BusRoster) bool

func BusRosterLoadBuilder

func BusRosterLoadBuilder(b *BusRosterBuilder, wire []byte, report *TableReport) bool

func BusRosterLoadMeasure

func BusRosterLoadMeasure(wire []byte) int64

func BusRosterLoadMeasureReason

func BusRosterLoadMeasureReason(wire []byte) (int64, error)

func BusRosterLoadMessageBody

func BusRosterLoadMessageBody(r *TableMessageReader, value *BusRoster) bool

func BusRosterLoadMessageBodyRetain

func BusRosterLoadMessageBodyRetain(r *TableRetainMessageReader, value *BusRoster) bool

func BusRosterMeasure

func BusRosterMeasure(value *BusRoster, context ...TableWriteContext) int64

func BusRosterMeasureBody

func BusRosterMeasureBody(value *BusRoster, ids *TableIds) int64

func BusRosterMeasureBodyRetain

func BusRosterMeasureBodyRetain(value *BusRoster, ids *TableRetainIds) int64

func BusRosterMeasureReason

func BusRosterMeasureReason(value *BusRoster, context ...TableWriteContext) (int64, error)

func BusRosterMeasureRetain

func BusRosterMeasureRetain(value *BusRoster, retain *TableRetain, allocator ...TableAllocator) int64

func BusRosterOpen

func BusRosterOpen(cook *BusRosterCook, base unsafe.Pointer, length int64) bool

BusRosterOpen is the bool convenience for the typed Open error on the handle.

func BusRosterParticipantsEach

func BusRosterParticipantsEach(holder *TableList[ParticipantRow], visit func(*ParticipantRow) bool, arena ...*TableArena) bool

func BusRosterParticipantsErase

func BusRosterParticipantsErase(arena *TableArena, holder *TableList[ParticipantRow], element *ParticipantRow) bool

func BusRosterReset

func BusRosterReset(value *BusRoster)

BusRosterReset restores BusRoster's declared defaults in place, reusing the storage the value already holds. The reader calls it before overlaying.

func BusRosterSave

func BusRosterSave(value *BusRoster, buffer []byte, context ...TableWriteContext) int64

func BusRosterSaveBody

func BusRosterSaveBody(w *TableWriter, value *BusRoster) bool

func BusRosterSaveBodyFields

func BusRosterSaveBodyFields(w *TableWriter, value *BusRoster) bool

func BusRosterSaveBodyFieldsRetain

func BusRosterSaveBodyFieldsRetain(w *TableRetainWriter, value *BusRoster) bool

func BusRosterSaveBodyRetain

func BusRosterSaveBodyRetain(w *TableRetainWriter, value *BusRoster) bool

func BusRosterSaveMessageBody

func BusRosterSaveMessageBody(w *TableMessageWriter, value *BusRoster) bool

func BusRosterSaveRetain

func BusRosterSaveRetain(value *BusRoster, retain *TableRetain, buffer []byte, report *TableReport, allocator ...TableAllocator) int64

func BusRosterSaveText

func BusRosterSaveText(value *BusRoster, context ...TableWriteContext) (string, error)

BusRosterSaveText returns the base64 of BusRoster's binary wire (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8): the whole file, form byte first, so the text keeps the form byte, the framing check and every versioning guarantee and is opaque. It takes the write context BusRosterSave takes.

func BusRosterToJson

func BusRosterToJson(value *BusRoster, buffer []byte, allocator ...TableAllocator) int64

func BusRosterToJsonMeasure

func BusRosterToJsonMeasure(value *BusRoster, allocator ...TableAllocator) int64

func DayFileCookFrom

func DayFileCookFrom(value *DayFile, buffer []byte, order TableByteOrder, context ...TableWriteContext) bool

func DayFileCookMeasure

func DayFileCookMeasure(value *DayFile, context ...TableWriteContext) int64

func DayFileCookMeasureReason

func DayFileCookMeasureReason(value *DayFile, context ...TableWriteContext) (int64, error)

func DayFileFromJson

func DayFileFromJson(builder *DayFileBuilder, text []byte, report *TableReport) bool

func DayFileLoadBody

func DayFileLoadBody(r *TableReader, value *DayFile) bool

func DayFileLoadBodyRetain

func DayFileLoadBodyRetain(r *TableRetainReader, value *DayFile) bool

func DayFileLoadBuilder

func DayFileLoadBuilder(b *DayFileBuilder, wire []byte, report *TableReport) bool

func DayFileLoadMeasure

func DayFileLoadMeasure(wire []byte) int64

func DayFileLoadMeasureReason

func DayFileLoadMeasureReason(wire []byte) (int64, error)

func DayFileLoadMessageBody

func DayFileLoadMessageBody(r *TableMessageReader, value *DayFile) bool

func DayFileLoadMessageBodyRetain

func DayFileLoadMessageBodyRetain(r *TableRetainMessageReader, value *DayFile) bool

func DayFileMeasure

func DayFileMeasure(value *DayFile, context ...TableWriteContext) int64

func DayFileMeasureBody

func DayFileMeasureBody(value *DayFile, ids *TableIds) int64

func DayFileMeasureBodyRetain

func DayFileMeasureBodyRetain(value *DayFile, ids *TableRetainIds) int64

func DayFileMeasureReason

func DayFileMeasureReason(value *DayFile, context ...TableWriteContext) (int64, error)

func DayFileMeasureRetain

func DayFileMeasureRetain(value *DayFile, retain *TableRetain, allocator ...TableAllocator) int64

func DayFileOpen

func DayFileOpen(cook *DayFileCook, base unsafe.Pointer, length int64) bool

DayFileOpen is the bool convenience for the typed Open error on the handle.

func DayFileReset

func DayFileReset(value *DayFile)

DayFileReset restores DayFile's declared defaults in place, reusing the storage the value already holds. The reader calls it before overlaying.

func DayFileRowsEach

func DayFileRowsEach(holder *TableList[DayLineRow], visit func(*DayLineRow) bool, arena ...*TableArena) bool

func DayFileRowsErase

func DayFileRowsErase(arena *TableArena, holder *TableList[DayLineRow], element *DayLineRow) bool

func DayFileSave

func DayFileSave(value *DayFile, buffer []byte, context ...TableWriteContext) int64

func DayFileSaveBody

func DayFileSaveBody(w *TableWriter, value *DayFile) bool

func DayFileSaveBodyFields

func DayFileSaveBodyFields(w *TableWriter, value *DayFile) bool

func DayFileSaveBodyFieldsRetain

func DayFileSaveBodyFieldsRetain(w *TableRetainWriter, value *DayFile) bool

func DayFileSaveBodyRetain

func DayFileSaveBodyRetain(w *TableRetainWriter, value *DayFile) bool

func DayFileSaveMessageBody

func DayFileSaveMessageBody(w *TableMessageWriter, value *DayFile) bool

func DayFileSaveRetain

func DayFileSaveRetain(value *DayFile, retain *TableRetain, buffer []byte, report *TableReport, allocator ...TableAllocator) int64

func DayFileSaveText

func DayFileSaveText(value *DayFile, context ...TableWriteContext) (string, error)

DayFileSaveText returns the base64 of DayFile's binary wire (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8): the whole file, form byte first, so the text keeps the form byte, the framing check and every versioning guarantee and is opaque. It takes the write context DayFileSave takes.

func DayFileSourcesEach

func DayFileSourcesEach(holder *TableList[SourceLabelRow], visit func(*SourceLabelRow) bool, arena ...*TableArena) bool

func DayFileSourcesErase

func DayFileSourcesErase(arena *TableArena, holder *TableList[SourceLabelRow], element *SourceLabelRow) bool

func DayFileToJson

func DayFileToJson(value *DayFile, buffer []byte, allocator ...TableAllocator) int64

func DayFileToJsonMeasure

func DayFileToJsonMeasure(value *DayFile, allocator ...TableAllocator) int64

func DayLineCookFrom

func DayLineCookFrom(value *DayLine, buffer []byte, order TableByteOrder, context ...TableWriteContext) bool

func DayLineCookMeasure

func DayLineCookMeasure(value *DayLine, context ...TableWriteContext) int64

func DayLineCookMeasureReason

func DayLineCookMeasureReason(value *DayLine, context ...TableWriteContext) (int64, error)

func DayLineFromJson

func DayLineFromJson(builder *DayLineBuilder, text []byte, report *TableReport) bool

func DayLineLoadBody

func DayLineLoadBody(r *TableReader, value *DayLine) bool

func DayLineLoadBodyRetain

func DayLineLoadBodyRetain(r *TableRetainReader, value *DayLine) bool

func DayLineLoadBuilder

func DayLineLoadBuilder(b *DayLineBuilder, wire []byte, report *TableReport) bool

func DayLineLoadMeasure

func DayLineLoadMeasure(wire []byte) int64

func DayLineLoadMeasureReason

func DayLineLoadMeasureReason(wire []byte) (int64, error)

func DayLineLoadMessageBody

func DayLineLoadMessageBody(r *TableMessageReader, value *DayLine) bool

func DayLineLoadMessageBodyRetain

func DayLineLoadMessageBodyRetain(r *TableRetainMessageReader, value *DayLine) bool

func DayLineMeasure

func DayLineMeasure(value *DayLine, context ...TableWriteContext) int64

func DayLineMeasureBody

func DayLineMeasureBody(value *DayLine, ids *TableIds) int64

func DayLineMeasureBodyRetain

func DayLineMeasureBodyRetain(value *DayLine, ids *TableRetainIds) int64

func DayLineMeasureReason

func DayLineMeasureReason(value *DayLine, context ...TableWriteContext) (int64, error)

func DayLineMeasureRetain

func DayLineMeasureRetain(value *DayLine, retain *TableRetain, allocator ...TableAllocator) int64

func DayLineOpen

func DayLineOpen(cook *DayLineCook, base unsafe.Pointer, length int64) bool

DayLineOpen is the bool convenience for the typed Open error on the handle.

func DayLineReset

func DayLineReset(value *DayLine)

DayLineReset restores DayLine's declared defaults in place, reusing the storage the value already holds. The reader calls it before overlaying.

func DayLineSave

func DayLineSave(value *DayLine, buffer []byte, context ...TableWriteContext) int64

func DayLineSaveBody

func DayLineSaveBody(w *TableWriter, value *DayLine) bool

func DayLineSaveBodyFields

func DayLineSaveBodyFields(w *TableWriter, value *DayLine) bool

func DayLineSaveBodyFieldsRetain

func DayLineSaveBodyFieldsRetain(w *TableRetainWriter, value *DayLine) bool

func DayLineSaveBodyRetain

func DayLineSaveBodyRetain(w *TableRetainWriter, value *DayLine) bool

func DayLineSaveMessageBody

func DayLineSaveMessageBody(w *TableMessageWriter, value *DayLine) bool

func DayLineSaveRetain

func DayLineSaveRetain(value *DayLine, retain *TableRetain, buffer []byte, report *TableReport, allocator ...TableAllocator) int64

func DayLineSaveText

func DayLineSaveText(value *DayLine, context ...TableWriteContext) (string, error)

DayLineSaveText returns the base64 of DayLine's binary wire (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8): the whole file, form byte first, so the text keeps the form byte, the framing check and every versioning guarantee and is opaque. It takes the write context DayLineSave takes.

func DayLineSourcesEach

func DayLineSourcesEach(holder *TableList[SourceLabelRow], visit func(*SourceLabelRow) bool, arena ...*TableArena) bool

func DayLineSourcesErase

func DayLineSourcesErase(arena *TableArena, holder *TableList[SourceLabelRow], element *SourceLabelRow) bool

func DayLineToJson

func DayLineToJson(value *DayLine, buffer []byte, allocator ...TableAllocator) int64

func DayLineToJsonMeasure

func DayLineToJsonMeasure(value *DayLine, allocator ...TableAllocator) int64

func ParticipantCookFrom

func ParticipantCookFrom(value *Participant, buffer []byte, order TableByteOrder, context ...TableWriteContext) bool

func ParticipantCookMeasure

func ParticipantCookMeasure(value *Participant, context ...TableWriteContext) int64

func ParticipantCookMeasureReason

func ParticipantCookMeasureReason(value *Participant, context ...TableWriteContext) (int64, error)

func ParticipantFromJson

func ParticipantFromJson(builder *ParticipantBuilder, text []byte, report *TableReport) bool

func ParticipantLoadBody

func ParticipantLoadBody(r *TableReader, value *Participant) bool

func ParticipantLoadBodyRetain

func ParticipantLoadBodyRetain(r *TableRetainReader, value *Participant) bool

func ParticipantLoadBuilder

func ParticipantLoadBuilder(b *ParticipantBuilder, wire []byte, report *TableReport) bool

func ParticipantLoadMeasure

func ParticipantLoadMeasure(wire []byte) int64

func ParticipantLoadMeasureReason

func ParticipantLoadMeasureReason(wire []byte) (int64, error)

func ParticipantLoadMessageBody

func ParticipantLoadMessageBody(r *TableMessageReader, value *Participant) bool

func ParticipantLoadMessageBodyRetain

func ParticipantLoadMessageBodyRetain(r *TableRetainMessageReader, value *Participant) bool

func ParticipantMeasure

func ParticipantMeasure(value *Participant, context ...TableWriteContext) int64

func ParticipantMeasureBody

func ParticipantMeasureBody(value *Participant, ids *TableIds) int64

func ParticipantMeasureBodyRetain

func ParticipantMeasureBodyRetain(value *Participant, ids *TableRetainIds) int64

func ParticipantMeasureReason

func ParticipantMeasureReason(value *Participant, context ...TableWriteContext) (int64, error)

func ParticipantMeasureRetain

func ParticipantMeasureRetain(value *Participant, retain *TableRetain, allocator ...TableAllocator) int64

func ParticipantOpen

func ParticipantOpen(cook *ParticipantCook, base unsafe.Pointer, length int64) bool

ParticipantOpen is the bool convenience for the typed Open error on the handle.

func ParticipantReset

func ParticipantReset(value *Participant)

ParticipantReset restores Participant's declared defaults in place, reusing the storage the value already holds. The reader calls it before overlaying.

func ParticipantSave

func ParticipantSave(value *Participant, buffer []byte, context ...TableWriteContext) int64

func ParticipantSaveBody

func ParticipantSaveBody(w *TableWriter, value *Participant) bool

func ParticipantSaveBodyFields

func ParticipantSaveBodyFields(w *TableWriter, value *Participant) bool

func ParticipantSaveBodyFieldsRetain

func ParticipantSaveBodyFieldsRetain(w *TableRetainWriter, value *Participant) bool

func ParticipantSaveBodyRetain

func ParticipantSaveBodyRetain(w *TableRetainWriter, value *Participant) bool

func ParticipantSaveMessageBody

func ParticipantSaveMessageBody(w *TableMessageWriter, value *Participant) bool

func ParticipantSaveRetain

func ParticipantSaveRetain(value *Participant, retain *TableRetain, buffer []byte, report *TableReport, allocator ...TableAllocator) int64

func ParticipantSaveText

func ParticipantSaveText(value *Participant, context ...TableWriteContext) (string, error)

ParticipantSaveText returns the base64 of Participant's binary wire (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8): the whole file, form byte first, so the text keeps the form byte, the framing check and every versioning guarantee and is opaque. It takes the write context ParticipantSave takes.

func ParticipantToJson

func ParticipantToJson(value *Participant, buffer []byte, allocator ...TableAllocator) int64

func ParticipantToJsonMeasure

func ParticipantToJsonMeasure(value *Participant, allocator ...TableAllocator) int64

func PlacedReceiptCookFrom

func PlacedReceiptCookFrom(value *PlacedReceipt, buffer []byte, order TableByteOrder, context ...TableWriteContext) bool

func PlacedReceiptCookMeasure

func PlacedReceiptCookMeasure(value *PlacedReceipt, context ...TableWriteContext) int64

func PlacedReceiptCookMeasureReason

func PlacedReceiptCookMeasureReason(value *PlacedReceipt, context ...TableWriteContext) (int64, error)

func PlacedReceiptFromJson

func PlacedReceiptFromJson(builder *PlacedReceiptBuilder, text []byte, report *TableReport) bool

func PlacedReceiptLoadBody

func PlacedReceiptLoadBody(r *TableReader, value *PlacedReceipt) bool

func PlacedReceiptLoadBodyRetain

func PlacedReceiptLoadBodyRetain(r *TableRetainReader, value *PlacedReceipt) bool

func PlacedReceiptLoadBuilder

func PlacedReceiptLoadBuilder(b *PlacedReceiptBuilder, wire []byte, report *TableReport) bool

func PlacedReceiptLoadMeasure

func PlacedReceiptLoadMeasure(wire []byte) int64

func PlacedReceiptLoadMeasureReason

func PlacedReceiptLoadMeasureReason(wire []byte) (int64, error)

func PlacedReceiptLoadMessageBody

func PlacedReceiptLoadMessageBody(r *TableMessageReader, value *PlacedReceipt) bool

func PlacedReceiptLoadMessageBodyRetain

func PlacedReceiptLoadMessageBodyRetain(r *TableRetainMessageReader, value *PlacedReceipt) bool

func PlacedReceiptMeasure

func PlacedReceiptMeasure(value *PlacedReceipt, context ...TableWriteContext) int64

func PlacedReceiptMeasureBody

func PlacedReceiptMeasureBody(value *PlacedReceipt, ids *TableIds) int64

func PlacedReceiptMeasureBodyRetain

func PlacedReceiptMeasureBodyRetain(value *PlacedReceipt, ids *TableRetainIds) int64

func PlacedReceiptMeasureReason

func PlacedReceiptMeasureReason(value *PlacedReceipt, context ...TableWriteContext) (int64, error)

func PlacedReceiptMeasureRetain

func PlacedReceiptMeasureRetain(value *PlacedReceipt, retain *TableRetain, allocator ...TableAllocator) int64

func PlacedReceiptOpen

func PlacedReceiptOpen(cook *PlacedReceiptCook, base unsafe.Pointer, length int64) bool

PlacedReceiptOpen is the bool convenience for the typed Open error on the handle.

func PlacedReceiptReset

func PlacedReceiptReset(value *PlacedReceipt)

PlacedReceiptReset restores PlacedReceipt's declared defaults in place, reusing the storage the value already holds. The reader calls it before overlaying.

func PlacedReceiptSave

func PlacedReceiptSave(value *PlacedReceipt, buffer []byte, context ...TableWriteContext) int64

func PlacedReceiptSaveBody

func PlacedReceiptSaveBody(w *TableWriter, value *PlacedReceipt) bool

func PlacedReceiptSaveBodyFields

func PlacedReceiptSaveBodyFields(w *TableWriter, value *PlacedReceipt) bool

func PlacedReceiptSaveBodyFieldsRetain

func PlacedReceiptSaveBodyFieldsRetain(w *TableRetainWriter, value *PlacedReceipt) bool

func PlacedReceiptSaveBodyRetain

func PlacedReceiptSaveBodyRetain(w *TableRetainWriter, value *PlacedReceipt) bool

func PlacedReceiptSaveMessageBody

func PlacedReceiptSaveMessageBody(w *TableMessageWriter, value *PlacedReceipt) bool

func PlacedReceiptSaveRetain

func PlacedReceiptSaveRetain(value *PlacedReceipt, retain *TableRetain, buffer []byte, report *TableReport, allocator ...TableAllocator) int64

func PlacedReceiptSaveText

func PlacedReceiptSaveText(value *PlacedReceipt, context ...TableWriteContext) (string, error)

PlacedReceiptSaveText returns the base64 of PlacedReceipt's binary wire (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8): the whole file, form byte first, so the text keeps the form byte, the framing check and every versioning guarantee and is opaque. It takes the write context PlacedReceiptSave takes.

func PlacedReceiptToJson

func PlacedReceiptToJson(value *PlacedReceipt, buffer []byte, allocator ...TableAllocator) int64

func PlacedReceiptToJsonMeasure

func PlacedReceiptToJsonMeasure(value *PlacedReceipt, allocator ...TableAllocator) int64

func SeatEnvironmentCookFrom

func SeatEnvironmentCookFrom(value *SeatEnvironment, buffer []byte, order TableByteOrder, context ...TableWriteContext) bool

func SeatEnvironmentCookMeasure

func SeatEnvironmentCookMeasure(value *SeatEnvironment, context ...TableWriteContext) int64

func SeatEnvironmentCookMeasureReason

func SeatEnvironmentCookMeasureReason(value *SeatEnvironment, context ...TableWriteContext) (int64, error)

func SeatEnvironmentFromJson

func SeatEnvironmentFromJson(builder *SeatEnvironmentBuilder, text []byte, report *TableReport) bool

func SeatEnvironmentLoadBody

func SeatEnvironmentLoadBody(r *TableReader, value *SeatEnvironment) bool

func SeatEnvironmentLoadBodyRetain

func SeatEnvironmentLoadBodyRetain(r *TableRetainReader, value *SeatEnvironment) bool

func SeatEnvironmentLoadBuilder

func SeatEnvironmentLoadBuilder(b *SeatEnvironmentBuilder, wire []byte, report *TableReport) bool

func SeatEnvironmentLoadMeasure

func SeatEnvironmentLoadMeasure(wire []byte) int64

func SeatEnvironmentLoadMeasureReason

func SeatEnvironmentLoadMeasureReason(wire []byte) (int64, error)

func SeatEnvironmentLoadMessageBody

func SeatEnvironmentLoadMessageBody(r *TableMessageReader, value *SeatEnvironment) bool

func SeatEnvironmentLoadMessageBodyRetain

func SeatEnvironmentLoadMessageBodyRetain(r *TableRetainMessageReader, value *SeatEnvironment) bool

func SeatEnvironmentMeasure

func SeatEnvironmentMeasure(value *SeatEnvironment, context ...TableWriteContext) int64

func SeatEnvironmentMeasureBody

func SeatEnvironmentMeasureBody(value *SeatEnvironment, ids *TableIds) int64

func SeatEnvironmentMeasureBodyRetain

func SeatEnvironmentMeasureBodyRetain(value *SeatEnvironment, ids *TableRetainIds) int64

func SeatEnvironmentMeasureReason

func SeatEnvironmentMeasureReason(value *SeatEnvironment, context ...TableWriteContext) (int64, error)

func SeatEnvironmentMeasureRetain

func SeatEnvironmentMeasureRetain(value *SeatEnvironment, retain *TableRetain, allocator ...TableAllocator) int64

func SeatEnvironmentOpen

func SeatEnvironmentOpen(cook *SeatEnvironmentCook, base unsafe.Pointer, length int64) bool

SeatEnvironmentOpen is the bool convenience for the typed Open error on the handle.

func SeatEnvironmentReset

func SeatEnvironmentReset(value *SeatEnvironment)

SeatEnvironmentReset restores SeatEnvironment's declared defaults in place, reusing the storage the value already holds. The reader calls it before overlaying.

func SeatEnvironmentSave

func SeatEnvironmentSave(value *SeatEnvironment, buffer []byte, context ...TableWriteContext) int64

func SeatEnvironmentSaveBody

func SeatEnvironmentSaveBody(w *TableWriter, value *SeatEnvironment) bool

func SeatEnvironmentSaveBodyFields

func SeatEnvironmentSaveBodyFields(w *TableWriter, value *SeatEnvironment) bool

func SeatEnvironmentSaveBodyFieldsRetain

func SeatEnvironmentSaveBodyFieldsRetain(w *TableRetainWriter, value *SeatEnvironment) bool

func SeatEnvironmentSaveBodyRetain

func SeatEnvironmentSaveBodyRetain(w *TableRetainWriter, value *SeatEnvironment) bool

func SeatEnvironmentSaveMessageBody

func SeatEnvironmentSaveMessageBody(w *TableMessageWriter, value *SeatEnvironment) bool

func SeatEnvironmentSaveRetain

func SeatEnvironmentSaveRetain(value *SeatEnvironment, retain *TableRetain, buffer []byte, report *TableReport, allocator ...TableAllocator) int64

func SeatEnvironmentSaveText

func SeatEnvironmentSaveText(value *SeatEnvironment, context ...TableWriteContext) (string, error)

SeatEnvironmentSaveText returns the base64 of SeatEnvironment's binary wire (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8): the whole file, form byte first, so the text keeps the form byte, the framing check and every versioning guarantee and is opaque. It takes the write context SeatEnvironmentSave takes.

func SeatEnvironmentToJson

func SeatEnvironmentToJson(value *SeatEnvironment, buffer []byte, allocator ...TableAllocator) int64

func SeatEnvironmentToJsonMeasure

func SeatEnvironmentToJsonMeasure(value *SeatEnvironment, allocator ...TableAllocator) int64

func SeatLoginCookFrom

func SeatLoginCookFrom(value *SeatLogin, buffer []byte, order TableByteOrder, context ...TableWriteContext) bool

func SeatLoginCookMeasure

func SeatLoginCookMeasure(value *SeatLogin, context ...TableWriteContext) int64

func SeatLoginCookMeasureReason

func SeatLoginCookMeasureReason(value *SeatLogin, context ...TableWriteContext) (int64, error)

func SeatLoginFromJson

func SeatLoginFromJson(builder *SeatLoginBuilder, text []byte, report *TableReport) bool

func SeatLoginLoadBody

func SeatLoginLoadBody(r *TableReader, value *SeatLogin) bool

func SeatLoginLoadBodyRetain

func SeatLoginLoadBodyRetain(r *TableRetainReader, value *SeatLogin) bool

func SeatLoginLoadBuilder

func SeatLoginLoadBuilder(b *SeatLoginBuilder, wire []byte, report *TableReport) bool

func SeatLoginLoadMeasure

func SeatLoginLoadMeasure(wire []byte) int64

func SeatLoginLoadMeasureReason

func SeatLoginLoadMeasureReason(wire []byte) (int64, error)

func SeatLoginLoadMessageBody

func SeatLoginLoadMessageBody(r *TableMessageReader, value *SeatLogin) bool

func SeatLoginLoadMessageBodyRetain

func SeatLoginLoadMessageBodyRetain(r *TableRetainMessageReader, value *SeatLogin) bool

func SeatLoginMeasure

func SeatLoginMeasure(value *SeatLogin, context ...TableWriteContext) int64

func SeatLoginMeasureBody

func SeatLoginMeasureBody(value *SeatLogin, ids *TableIds) int64

func SeatLoginMeasureBodyRetain

func SeatLoginMeasureBodyRetain(value *SeatLogin, ids *TableRetainIds) int64

func SeatLoginMeasureReason

func SeatLoginMeasureReason(value *SeatLogin, context ...TableWriteContext) (int64, error)

func SeatLoginMeasureRetain

func SeatLoginMeasureRetain(value *SeatLogin, retain *TableRetain, allocator ...TableAllocator) int64

func SeatLoginOpen

func SeatLoginOpen(cook *SeatLoginCook, base unsafe.Pointer, length int64) bool

SeatLoginOpen is the bool convenience for the typed Open error on the handle.

func SeatLoginReset

func SeatLoginReset(value *SeatLogin)

SeatLoginReset restores SeatLogin's declared defaults in place, reusing the storage the value already holds. The reader calls it before overlaying.

func SeatLoginSave

func SeatLoginSave(value *SeatLogin, buffer []byte, context ...TableWriteContext) int64

func SeatLoginSaveBody

func SeatLoginSaveBody(w *TableWriter, value *SeatLogin) bool

func SeatLoginSaveBodyFields

func SeatLoginSaveBodyFields(w *TableWriter, value *SeatLogin) bool

func SeatLoginSaveBodyFieldsRetain

func SeatLoginSaveBodyFieldsRetain(w *TableRetainWriter, value *SeatLogin) bool

func SeatLoginSaveBodyRetain

func SeatLoginSaveBodyRetain(w *TableRetainWriter, value *SeatLogin) bool

func SeatLoginSaveMessageBody

func SeatLoginSaveMessageBody(w *TableMessageWriter, value *SeatLogin) bool

func SeatLoginSaveRetain

func SeatLoginSaveRetain(value *SeatLogin, retain *TableRetain, buffer []byte, report *TableReport, allocator ...TableAllocator) int64

func SeatLoginSaveText

func SeatLoginSaveText(value *SeatLogin, context ...TableWriteContext) (string, error)

SeatLoginSaveText returns the base64 of SeatLogin's binary wire (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8): the whole file, form byte first, so the text keeps the form byte, the framing check and every versioning guarantee and is opaque. It takes the write context SeatLoginSave takes.

func SeatLoginToJson

func SeatLoginToJson(value *SeatLogin, buffer []byte, allocator ...TableAllocator) int64

func SeatLoginToJsonMeasure

func SeatLoginToJsonMeasure(value *SeatLogin, allocator ...TableAllocator) int64

func SourceLabelCookFrom

func SourceLabelCookFrom(value *SourceLabel, buffer []byte, order TableByteOrder, context ...TableWriteContext) bool

func SourceLabelCookMeasure

func SourceLabelCookMeasure(value *SourceLabel, context ...TableWriteContext) int64

func SourceLabelCookMeasureReason

func SourceLabelCookMeasureReason(value *SourceLabel, context ...TableWriteContext) (int64, error)

func SourceLabelFromJson

func SourceLabelFromJson(builder *SourceLabelBuilder, text []byte, report *TableReport) bool

func SourceLabelLoadBody

func SourceLabelLoadBody(r *TableReader, value *SourceLabel) bool

func SourceLabelLoadBodyRetain

func SourceLabelLoadBodyRetain(r *TableRetainReader, value *SourceLabel) bool

func SourceLabelLoadBuilder

func SourceLabelLoadBuilder(b *SourceLabelBuilder, wire []byte, report *TableReport) bool

func SourceLabelLoadMeasure

func SourceLabelLoadMeasure(wire []byte) int64

func SourceLabelLoadMeasureReason

func SourceLabelLoadMeasureReason(wire []byte) (int64, error)

func SourceLabelLoadMessageBody

func SourceLabelLoadMessageBody(r *TableMessageReader, value *SourceLabel) bool

func SourceLabelLoadMessageBodyRetain

func SourceLabelLoadMessageBodyRetain(r *TableRetainMessageReader, value *SourceLabel) bool

func SourceLabelMeasure

func SourceLabelMeasure(value *SourceLabel, context ...TableWriteContext) int64

func SourceLabelMeasureBody

func SourceLabelMeasureBody(value *SourceLabel, ids *TableIds) int64

func SourceLabelMeasureBodyRetain

func SourceLabelMeasureBodyRetain(value *SourceLabel, ids *TableRetainIds) int64

func SourceLabelMeasureReason

func SourceLabelMeasureReason(value *SourceLabel, context ...TableWriteContext) (int64, error)

func SourceLabelMeasureRetain

func SourceLabelMeasureRetain(value *SourceLabel, retain *TableRetain, allocator ...TableAllocator) int64

func SourceLabelOpen

func SourceLabelOpen(cook *SourceLabelCook, base unsafe.Pointer, length int64) bool

SourceLabelOpen is the bool convenience for the typed Open error on the handle.

func SourceLabelReset

func SourceLabelReset(value *SourceLabel)

SourceLabelReset restores SourceLabel's declared defaults in place, reusing the storage the value already holds. The reader calls it before overlaying.

func SourceLabelSave

func SourceLabelSave(value *SourceLabel, buffer []byte, context ...TableWriteContext) int64

func SourceLabelSaveBody

func SourceLabelSaveBody(w *TableWriter, value *SourceLabel) bool

func SourceLabelSaveBodyFields

func SourceLabelSaveBodyFields(w *TableWriter, value *SourceLabel) bool

func SourceLabelSaveBodyFieldsRetain

func SourceLabelSaveBodyFieldsRetain(w *TableRetainWriter, value *SourceLabel) bool

func SourceLabelSaveBodyRetain

func SourceLabelSaveBodyRetain(w *TableRetainWriter, value *SourceLabel) bool

func SourceLabelSaveMessageBody

func SourceLabelSaveMessageBody(w *TableMessageWriter, value *SourceLabel) bool

func SourceLabelSaveRetain

func SourceLabelSaveRetain(value *SourceLabel, retain *TableRetain, buffer []byte, report *TableReport, allocator ...TableAllocator) int64

func SourceLabelSaveText

func SourceLabelSaveText(value *SourceLabel, context ...TableWriteContext) (string, error)

SourceLabelSaveText returns the base64 of SourceLabel's binary wire (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8): the whole file, form byte first, so the text keeps the form byte, the framing check and every versioning guarantee and is opaque. It takes the write context SourceLabelSave takes.

func SourceLabelToJson

func SourceLabelToJson(value *SourceLabel, buffer []byte, allocator ...TableAllocator) int64

func SourceLabelToJsonMeasure

func SourceLabelToJsonMeasure(value *SourceLabel, allocator ...TableAllocator) int64

func TableBytesEmplace

func TableBytesEmplace(worker *TableWorker, slot *TableRef, length int64) []byte

func TableStringEmplace

func TableStringEmplace(worker *TableWorker, slot *TableRef, text []byte) []byte

Types

type BusRoster

type BusRoster = BusRosterRow

func BusRosterLoad

func BusRosterLoad(region, wire []byte, report *TableReport) *BusRoster

func BusRosterLoadRetain

func BusRosterLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *BusRoster

func BusRosterLoadText

func BusRosterLoadText(text string, report *TableReport) (*BusRoster, error)

BusRosterLoadText reads one BusRoster from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8) into a builder of its own and returns the locked root, as BusRosterReadStrict does: it is the STRICT read (§6.5) and refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant LoadBuilder answered, so a recovered value never comes back. It refuses by name: base64_damaged when the body does not decode, unknown_form when the decoded wire's form byte is not one this build carries, wire_damaged for framing damage, and the report's own reason (malformed, clamped, kind_mismatch, ...) otherwise. A nil report is allowed; a supplied one receives THIS read's report, so earlier counts in it never decide.

func BusRosterReadStrict

func BusRosterReadStrict(wire []byte) (*BusRoster, error)

BusRosterReadStrict is the STRICT read (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5): one call, its own builder, one typed reason.

type BusRosterBuilder

type BusRosterBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

func (*BusRosterBuilder) AsConst

func (b *BusRosterBuilder) AsConst() *BusRoster

func (*BusRosterBuilder) GetRoot

func (b *BusRosterBuilder) GetRoot() *BusRoster

func (*BusRosterBuilder) Init

func (b *BusRosterBuilder) Init(allocator ...TableAllocator) bool

func (*BusRosterBuilder) Lock

func (b *BusRosterBuilder) Lock() bool

func (*BusRosterBuilder) PackMeasure

func (b *BusRosterBuilder) PackMeasure() int64

func (*BusRosterBuilder) PackMeasureReason

func (b *BusRosterBuilder) PackMeasureReason() (int64, error)

func (*BusRosterBuilder) Region

func (b *BusRosterBuilder) Region() []byte

func (*BusRosterBuilder) Shutdown

func (b *BusRosterBuilder) Shutdown()

type BusRosterCook

type BusRosterCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

BusRosterCook is BusRoster's cook: a pointer and a length, and then the root where it lies. Opening one is a HEADER MATCH and no copy; a reference is one add (mas-bandwidth/schema docs/SPEC-TABLES.md §7).

`Cook` is a CLAIMED suffix (§11). C++ spells the same claimed verbs as free functions — BusRosterOpen, BusRosterAt — and so does Go, because Go has free functions; what is a MEMBER here is only what §11 leaves a language free to make one.

THE MEMORY IS THE CONSUMER'S. Nothing here allocates, nothing here copies and nothing here pins: the region must stay put and stay aligned for as long as this handle or anything reached through it is used.

func (*BusRosterCook) Open

func (cook *BusRosterCook) Open(base unsafe.Pointer, length int64) error

Open checks the header in SPEC §7 order, bytewise until base alignment is established. A successful match points at the region and allocates nothing.

func (BusRosterCook) RegionAlignment

func (c BusRosterCook) RegionAlignment() int64

§7.1's constants, so a consumer reading this file has the facts and not a description of them. They are METHODS because §11 leaves a language whose accessors are members free to spell them that way, and a package constant per table per fact would claim names §11 does not.

func (BusRosterCook) Root

func (c BusRosterCook) Root() *BusRosterRow

Root is the root record at the region's base. It is a POINTER and not a copy: a cooked graph is walked by adding deltas to slot addresses.

func (BusRosterCook) RootAlign

func (c BusRosterCook) RootAlign() int64

func (BusRosterCook) RootSize

func (c BusRosterCook) RootSize() int64

func (BusRosterCook) Type

func (c BusRosterCook) Type() *TableCookInfo

Type is BusRoster's cooked-record descriptor, the head of the graph a reflective walk follows (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type BusRosterRow

type BusRosterRow struct {
	Participants TableList[ParticipantRow]
}

BusRosterRow — a cooked record. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func BusRosterAt

func BusRosterAt(slot *int64, arena ...*TableArena) *BusRosterRow

BusRosterAt dereferences a reference, and it is the same call in a locked region and an opened cook because they are the same encoding (§6.3): the slot is eight bytes, SIGNED, self-relative from the SLOT'S OWN ADDRESS, so a deref needs no base pointer and no bounds test, and NULL IS A DELTA OF ZERO. Nothing about this call is the cook's: it is what a region reference is, and a cook is a region written verbatim.

It takes the SLOT and not its value, because a self-relative delta means nothing without the address it is relative to.

type DayFile

type DayFile = DayFileRow

func DayFileLoad

func DayFileLoad(region, wire []byte, report *TableReport) *DayFile

func DayFileLoadRetain

func DayFileLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *DayFile

func DayFileLoadText

func DayFileLoadText(text string, report *TableReport) (*DayFile, error)

DayFileLoadText reads one DayFile from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8) into a builder of its own and returns the locked root, as DayFileReadStrict does: it is the STRICT read (§6.5) and refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant LoadBuilder answered, so a recovered value never comes back. It refuses by name: base64_damaged when the body does not decode, unknown_form when the decoded wire's form byte is not one this build carries, wire_damaged for framing damage, and the report's own reason (malformed, clamped, kind_mismatch, ...) otherwise. A nil report is allowed; a supplied one receives THIS read's report, so earlier counts in it never decide.

func DayFileReadStrict

func DayFileReadStrict(wire []byte) (*DayFile, error)

DayFileReadStrict is the STRICT read (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5): one call, its own builder, one typed reason.

type DayFileBuilder

type DayFileBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

func (*DayFileBuilder) AsConst

func (b *DayFileBuilder) AsConst() *DayFile

func (*DayFileBuilder) GetRoot

func (b *DayFileBuilder) GetRoot() *DayFile

func (*DayFileBuilder) Init

func (b *DayFileBuilder) Init(allocator ...TableAllocator) bool

func (*DayFileBuilder) Lock

func (b *DayFileBuilder) Lock() bool

func (*DayFileBuilder) PackMeasure

func (b *DayFileBuilder) PackMeasure() int64

func (*DayFileBuilder) PackMeasureReason

func (b *DayFileBuilder) PackMeasureReason() (int64, error)

func (*DayFileBuilder) Region

func (b *DayFileBuilder) Region() []byte

func (*DayFileBuilder) Shutdown

func (b *DayFileBuilder) Shutdown()

type DayFileCook

type DayFileCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

DayFileCook is DayFile's cook: a pointer and a length, and then the root where it lies. Opening one is a HEADER MATCH and no copy; a reference is one add (mas-bandwidth/schema docs/SPEC-TABLES.md §7).

`Cook` is a CLAIMED suffix (§11). C++ spells the same claimed verbs as free functions — DayFileOpen, DayFileAt — and so does Go, because Go has free functions; what is a MEMBER here is only what §11 leaves a language free to make one.

THE MEMORY IS THE CONSUMER'S. Nothing here allocates, nothing here copies and nothing here pins: the region must stay put and stay aligned for as long as this handle or anything reached through it is used.

func (*DayFileCook) Open

func (cook *DayFileCook) Open(base unsafe.Pointer, length int64) error

Open checks the header in SPEC §7 order, bytewise until base alignment is established. A successful match points at the region and allocates nothing.

func (DayFileCook) RegionAlignment

func (c DayFileCook) RegionAlignment() int64

§7.1's constants, so a consumer reading this file has the facts and not a description of them. They are METHODS because §11 leaves a language whose accessors are members free to spell them that way, and a package constant per table per fact would claim names §11 does not.

func (DayFileCook) Root

func (c DayFileCook) Root() *DayFileRow

Root is the root record at the region's base. It is a POINTER and not a copy: a cooked graph is walked by adding deltas to slot addresses.

func (DayFileCook) RootAlign

func (c DayFileCook) RootAlign() int64

func (DayFileCook) RootSize

func (c DayFileCook) RootSize() int64

func (DayFileCook) Type

func (c DayFileCook) Type() *TableCookInfo

Type is DayFile's cooked-record descriptor, the head of the graph a reflective walk follows (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type DayFileRow

type DayFileRow struct {
	Day [11]byte // string(10): buffer, used length beside it

	DayLength    int32
	At           int64 // *: signed self-relative delta, zero is null (§6.3)
	Build        int64 // *: signed self-relative delta, zero is null (§6.3)
	Turns        int64
	TurnsPresent bool // ?: one byte, in Go's model as in C++

	Sources TableList[SourceLabelRow]
	Rows    TableList[DayLineRow]
	// contains filtered or unexported fields
}

DayFileRow — a cooked record. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func DayFileAt

func DayFileAt(slot *int64, arena ...*TableArena) *DayFileRow

DayFileAt dereferences a reference, and it is the same call in a locked region and an opened cook because they are the same encoding (§6.3): the slot is eight bytes, SIGNED, self-relative from the SLOT'S OWN ADDRESS, so a deref needs no base pointer and no bounds test, and NULL IS A DELTA OF ZERO. Nothing about this call is the cook's: it is what a region reference is, and a cook is a region written verbatim.

It takes the SLOT and not its value, because a self-relative delta means nothing without the address it is relative to.

type DayLine

type DayLine = DayLineRow

func DayLineLoad

func DayLineLoad(region, wire []byte, report *TableReport) *DayLine

func DayLineLoadRetain

func DayLineLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *DayLine

func DayLineLoadText

func DayLineLoadText(text string, report *TableReport) (*DayLine, error)

DayLineLoadText reads one DayLine from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8) into a builder of its own and returns the locked root, as DayLineReadStrict does: it is the STRICT read (§6.5) and refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant LoadBuilder answered, so a recovered value never comes back. It refuses by name: base64_damaged when the body does not decode, unknown_form when the decoded wire's form byte is not one this build carries, wire_damaged for framing damage, and the report's own reason (malformed, clamped, kind_mismatch, ...) otherwise. A nil report is allowed; a supplied one receives THIS read's report, so earlier counts in it never decide.

func DayLineReadStrict

func DayLineReadStrict(wire []byte) (*DayLine, error)

DayLineReadStrict is the STRICT read (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5): one call, its own builder, one typed reason.

type DayLineBuilder

type DayLineBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

func (*DayLineBuilder) AsConst

func (b *DayLineBuilder) AsConst() *DayLine

func (*DayLineBuilder) GetRoot

func (b *DayLineBuilder) GetRoot() *DayLine

func (*DayLineBuilder) Init

func (b *DayLineBuilder) Init(allocator ...TableAllocator) bool

func (*DayLineBuilder) Lock

func (b *DayLineBuilder) Lock() bool

func (*DayLineBuilder) PackMeasure

func (b *DayLineBuilder) PackMeasure() int64

func (*DayLineBuilder) PackMeasureReason

func (b *DayLineBuilder) PackMeasureReason() (int64, error)

func (*DayLineBuilder) Region

func (b *DayLineBuilder) Region() []byte

func (*DayLineBuilder) Shutdown

func (b *DayLineBuilder) Shutdown()

type DayLineCook

type DayLineCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

DayLineCook is DayLine's cook: a pointer and a length, and then the root where it lies. Opening one is a HEADER MATCH and no copy; a reference is one add (mas-bandwidth/schema docs/SPEC-TABLES.md §7).

`Cook` is a CLAIMED suffix (§11). C++ spells the same claimed verbs as free functions — DayLineOpen, DayLineAt — and so does Go, because Go has free functions; what is a MEMBER here is only what §11 leaves a language free to make one.

THE MEMORY IS THE CONSUMER'S. Nothing here allocates, nothing here copies and nothing here pins: the region must stay put and stay aligned for as long as this handle or anything reached through it is used.

func (*DayLineCook) Open

func (cook *DayLineCook) Open(base unsafe.Pointer, length int64) error

Open checks the header in SPEC §7 order, bytewise until base alignment is established. A successful match points at the region and allocates nothing.

func (DayLineCook) RegionAlignment

func (c DayLineCook) RegionAlignment() int64

§7.1's constants, so a consumer reading this file has the facts and not a description of them. They are METHODS because §11 leaves a language whose accessors are members free to spell them that way, and a package constant per table per fact would claim names §11 does not.

func (DayLineCook) Root

func (c DayLineCook) Root() *DayLineRow

Root is the root record at the region's base. It is a POINTER and not a copy: a cooked graph is walked by adding deltas to slot addresses.

func (DayLineCook) RootAlign

func (c DayLineCook) RootAlign() int64

func (DayLineCook) RootSize

func (c DayLineCook) RootSize() int64

func (DayLineCook) Type

func (c DayLineCook) Type() *TableCookInfo

Type is DayLine's cooked-record descriptor, the head of the graph a reflective walk follows (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type DayLineRow

type DayLineRow struct {
	Date [11]byte // string(10): buffer, used length beside it

	DateLength   int32
	Model        int64 // *: signed self-relative delta, zero is null (§6.3)
	Repo         int64 // *: signed self-relative delta, zero is null (§6.3)
	Input        int64
	InputPresent bool // ?: one byte, in Go's model as in C++

	Output        int64
	OutputPresent bool // ?: one byte, in Go's model as in C++

	CacheWrite        int64
	CacheWritePresent bool // ?: one byte, in Go's model as in C++

	CacheRead        int64
	CacheReadPresent bool // ?: one byte, in Go's model as in C++

	Reasoning        int64
	ReasoningPresent bool // ?: one byte, in Go's model as in C++

	Rough   int64
	Basis   int64 // *: signed self-relative delta, zero is null (§6.3)
	Sources TableList[SourceLabelRow]
	// contains filtered or unexported fields
}

DayLineRow — a cooked record. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func DayFileRowsAdd

func DayFileRowsAdd(worker *TableWorker, holder *TableList[DayLineRow]) *DayLineRow

func DayLineAt

func DayLineAt(slot *int64, arena ...*TableArena) *DayLineRow

DayLineAt dereferences a reference, and it is the same call in a locked region and an opened cook because they are the same encoding (§6.3): the slot is eight bytes, SIGNED, self-relative from the SLOT'S OWN ADDRESS, so a deref needs no base pointer and no bounds test, and NULL IS A DELTA OF ZERO. Nothing about this call is the cook's: it is what a region reference is, and a cook is a region written verbatim.

It takes the SLOT and not its value, because a self-relative delta means nothing without the address it is relative to.

type Participant

type Participant = ParticipantRow

func ParticipantLoad

func ParticipantLoad(region, wire []byte, report *TableReport) *Participant

func ParticipantLoadRetain

func ParticipantLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Participant

func ParticipantLoadText

func ParticipantLoadText(text string, report *TableReport) (*Participant, error)

ParticipantLoadText reads one Participant from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8) into a builder of its own and returns the locked root, as ParticipantReadStrict does: it is the STRICT read (§6.5) and refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant LoadBuilder answered, so a recovered value never comes back. It refuses by name: base64_damaged when the body does not decode, unknown_form when the decoded wire's form byte is not one this build carries, wire_damaged for framing damage, and the report's own reason (malformed, clamped, kind_mismatch, ...) otherwise. A nil report is allowed; a supplied one receives THIS read's report, so earlier counts in it never decide.

func ParticipantReadStrict

func ParticipantReadStrict(wire []byte) (*Participant, error)

ParticipantReadStrict is the STRICT read (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5): one call, its own builder, one typed reason.

type ParticipantBuilder

type ParticipantBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

func (*ParticipantBuilder) AsConst

func (b *ParticipantBuilder) AsConst() *Participant

func (*ParticipantBuilder) GetRoot

func (b *ParticipantBuilder) GetRoot() *Participant

func (*ParticipantBuilder) Init

func (b *ParticipantBuilder) Init(allocator ...TableAllocator) bool

func (*ParticipantBuilder) Lock

func (b *ParticipantBuilder) Lock() bool

func (*ParticipantBuilder) PackMeasure

func (b *ParticipantBuilder) PackMeasure() int64

func (*ParticipantBuilder) PackMeasureReason

func (b *ParticipantBuilder) PackMeasureReason() (int64, error)

func (*ParticipantBuilder) Region

func (b *ParticipantBuilder) Region() []byte

func (*ParticipantBuilder) Shutdown

func (b *ParticipantBuilder) Shutdown()

type ParticipantCook

type ParticipantCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

ParticipantCook is Participant's cook: a pointer and a length, and then the root where it lies. Opening one is a HEADER MATCH and no copy; a reference is one add (mas-bandwidth/schema docs/SPEC-TABLES.md §7).

`Cook` is a CLAIMED suffix (§11). C++ spells the same claimed verbs as free functions — ParticipantOpen, ParticipantAt — and so does Go, because Go has free functions; what is a MEMBER here is only what §11 leaves a language free to make one.

THE MEMORY IS THE CONSUMER'S. Nothing here allocates, nothing here copies and nothing here pins: the region must stay put and stay aligned for as long as this handle or anything reached through it is used.

func (*ParticipantCook) Open

func (cook *ParticipantCook) Open(base unsafe.Pointer, length int64) error

Open checks the header in SPEC §7 order, bytewise until base alignment is established. A successful match points at the region and allocates nothing.

func (ParticipantCook) RegionAlignment

func (c ParticipantCook) RegionAlignment() int64

§7.1's constants, so a consumer reading this file has the facts and not a description of them. They are METHODS because §11 leaves a language whose accessors are members free to spell them that way, and a package constant per table per fact would claim names §11 does not.

func (ParticipantCook) Root

func (c ParticipantCook) Root() *ParticipantRow

Root is the root record at the region's base. It is a POINTER and not a copy: a cooked graph is walked by adding deltas to slot addresses.

func (ParticipantCook) RootAlign

func (c ParticipantCook) RootAlign() int64

func (ParticipantCook) RootSize

func (c ParticipantCook) RootSize() int64

func (ParticipantCook) Type

func (c ParticipantCook) Type() *TableCookInfo

Type is Participant's cooked-record descriptor, the head of the graph a reflective walk follows (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type ParticipantRow

type ParticipantRow struct {
	Name int64 // *: signed self-relative delta, zero is null (§6.3)
	Lane int64 // *: signed self-relative delta, zero is null (§6.3)
}

ParticipantRow — a cooked record. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func BusRosterParticipantsAdd

func BusRosterParticipantsAdd(worker *TableWorker, holder *TableList[ParticipantRow]) *ParticipantRow

func ParticipantAt

func ParticipantAt(slot *int64, arena ...*TableArena) *ParticipantRow

ParticipantAt dereferences a reference, and it is the same call in a locked region and an opened cook because they are the same encoding (§6.3): the slot is eight bytes, SIGNED, self-relative from the SLOT'S OWN ADDRESS, so a deref needs no base pointer and no bounds test, and NULL IS A DELTA OF ZERO. Nothing about this call is the cook's: it is what a region reference is, and a cook is a region written verbatim.

It takes the SLOT and not its value, because a self-relative delta means nothing without the address it is relative to.

type PlacedReceipt

type PlacedReceipt = PlacedReceiptRow

func PlacedReceiptLoad

func PlacedReceiptLoad(region, wire []byte, report *TableReport) *PlacedReceipt

func PlacedReceiptLoadRetain

func PlacedReceiptLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *PlacedReceipt

func PlacedReceiptLoadText

func PlacedReceiptLoadText(text string, report *TableReport) (*PlacedReceipt, error)

PlacedReceiptLoadText reads one PlacedReceipt from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8) into a builder of its own and returns the locked root, as PlacedReceiptReadStrict does: it is the STRICT read (§6.5) and refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant LoadBuilder answered, so a recovered value never comes back. It refuses by name: base64_damaged when the body does not decode, unknown_form when the decoded wire's form byte is not one this build carries, wire_damaged for framing damage, and the report's own reason (malformed, clamped, kind_mismatch, ...) otherwise. A nil report is allowed; a supplied one receives THIS read's report, so earlier counts in it never decide.

func PlacedReceiptReadStrict

func PlacedReceiptReadStrict(wire []byte) (*PlacedReceipt, error)

PlacedReceiptReadStrict is the STRICT read (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5): one call, its own builder, one typed reason.

type PlacedReceiptBuilder

type PlacedReceiptBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

func (*PlacedReceiptBuilder) AsConst

func (b *PlacedReceiptBuilder) AsConst() *PlacedReceipt

func (*PlacedReceiptBuilder) GetRoot

func (b *PlacedReceiptBuilder) GetRoot() *PlacedReceipt

func (*PlacedReceiptBuilder) Init

func (b *PlacedReceiptBuilder) Init(allocator ...TableAllocator) bool

func (*PlacedReceiptBuilder) Lock

func (b *PlacedReceiptBuilder) Lock() bool

func (*PlacedReceiptBuilder) PackMeasure

func (b *PlacedReceiptBuilder) PackMeasure() int64

func (*PlacedReceiptBuilder) PackMeasureReason

func (b *PlacedReceiptBuilder) PackMeasureReason() (int64, error)

func (*PlacedReceiptBuilder) Region

func (b *PlacedReceiptBuilder) Region() []byte

func (*PlacedReceiptBuilder) Shutdown

func (b *PlacedReceiptBuilder) Shutdown()

type PlacedReceiptCook

type PlacedReceiptCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

PlacedReceiptCook is PlacedReceipt's cook: a pointer and a length, and then the root where it lies. Opening one is a HEADER MATCH and no copy; a reference is one add (mas-bandwidth/schema docs/SPEC-TABLES.md §7).

`Cook` is a CLAIMED suffix (§11). C++ spells the same claimed verbs as free functions — PlacedReceiptOpen, PlacedReceiptAt — and so does Go, because Go has free functions; what is a MEMBER here is only what §11 leaves a language free to make one.

THE MEMORY IS THE CONSUMER'S. Nothing here allocates, nothing here copies and nothing here pins: the region must stay put and stay aligned for as long as this handle or anything reached through it is used.

func (*PlacedReceiptCook) Open

func (cook *PlacedReceiptCook) Open(base unsafe.Pointer, length int64) error

Open checks the header in SPEC §7 order, bytewise until base alignment is established. A successful match points at the region and allocates nothing.

func (PlacedReceiptCook) RegionAlignment

func (c PlacedReceiptCook) RegionAlignment() int64

§7.1's constants, so a consumer reading this file has the facts and not a description of them. They are METHODS because §11 leaves a language whose accessors are members free to spell them that way, and a package constant per table per fact would claim names §11 does not.

func (PlacedReceiptCook) Root

Root is the root record at the region's base. It is a POINTER and not a copy: a cooked graph is walked by adding deltas to slot addresses.

func (PlacedReceiptCook) RootAlign

func (c PlacedReceiptCook) RootAlign() int64

func (PlacedReceiptCook) RootSize

func (c PlacedReceiptCook) RootSize() int64

func (PlacedReceiptCook) Type

func (c PlacedReceiptCook) Type() *TableCookInfo

Type is PlacedReceipt's cooked-record descriptor, the head of the graph a reflective walk follows (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type PlacedReceiptRow

type PlacedReceiptRow struct {
	Secret int64 // *: signed self-relative delta, zero is null (§6.3)
	Path   int64 // *: signed self-relative delta, zero is null (§6.3)
	File   int64 // *: signed self-relative delta, zero is null (§6.3)
	Head   int64 // *: signed self-relative delta, zero is null (§6.3)
	Blob   int64 // *: signed self-relative delta, zero is null (§6.3)
	Stamp  int64 // *: signed self-relative delta, zero is null (§6.3)
}

PlacedReceiptRow — a cooked record. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func PlacedReceiptAt

func PlacedReceiptAt(slot *int64, arena ...*TableArena) *PlacedReceiptRow

PlacedReceiptAt dereferences a reference, and it is the same call in a locked region and an opened cook because they are the same encoding (§6.3): the slot is eight bytes, SIGNED, self-relative from the SLOT'S OWN ADDRESS, so a deref needs no base pointer and no bounds test, and NULL IS A DELTA OF ZERO. Nothing about this call is the cook's: it is what a region reference is, and a cook is a region written verbatim.

It takes the SLOT and not its value, because a self-relative delta means nothing without the address it is relative to.

type SeatEnvironment

type SeatEnvironment = SeatEnvironmentRow

func SeatEnvironmentLoad

func SeatEnvironmentLoad(region, wire []byte, report *TableReport) *SeatEnvironment

func SeatEnvironmentLoadRetain

func SeatEnvironmentLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *SeatEnvironment

func SeatEnvironmentLoadText

func SeatEnvironmentLoadText(text string, report *TableReport) (*SeatEnvironment, error)

SeatEnvironmentLoadText reads one SeatEnvironment from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8) into a builder of its own and returns the locked root, as SeatEnvironmentReadStrict does: it is the STRICT read (§6.5) and refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant LoadBuilder answered, so a recovered value never comes back. It refuses by name: base64_damaged when the body does not decode, unknown_form when the decoded wire's form byte is not one this build carries, wire_damaged for framing damage, and the report's own reason (malformed, clamped, kind_mismatch, ...) otherwise. A nil report is allowed; a supplied one receives THIS read's report, so earlier counts in it never decide.

func SeatEnvironmentReadStrict

func SeatEnvironmentReadStrict(wire []byte) (*SeatEnvironment, error)

SeatEnvironmentReadStrict is the STRICT read (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5): one call, its own builder, one typed reason.

type SeatEnvironmentBuilder

type SeatEnvironmentBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

func (*SeatEnvironmentBuilder) AsConst

func (*SeatEnvironmentBuilder) GetRoot

func (*SeatEnvironmentBuilder) Init

func (b *SeatEnvironmentBuilder) Init(allocator ...TableAllocator) bool

func (*SeatEnvironmentBuilder) Lock

func (b *SeatEnvironmentBuilder) Lock() bool

func (*SeatEnvironmentBuilder) PackMeasure

func (b *SeatEnvironmentBuilder) PackMeasure() int64

func (*SeatEnvironmentBuilder) PackMeasureReason

func (b *SeatEnvironmentBuilder) PackMeasureReason() (int64, error)

func (*SeatEnvironmentBuilder) Region

func (b *SeatEnvironmentBuilder) Region() []byte

func (*SeatEnvironmentBuilder) Shutdown

func (b *SeatEnvironmentBuilder) Shutdown()

type SeatEnvironmentCook

type SeatEnvironmentCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

SeatEnvironmentCook is SeatEnvironment's cook: a pointer and a length, and then the root where it lies. Opening one is a HEADER MATCH and no copy; a reference is one add (mas-bandwidth/schema docs/SPEC-TABLES.md §7).

`Cook` is a CLAIMED suffix (§11). C++ spells the same claimed verbs as free functions — SeatEnvironmentOpen, SeatEnvironmentAt — and so does Go, because Go has free functions; what is a MEMBER here is only what §11 leaves a language free to make one.

THE MEMORY IS THE CONSUMER'S. Nothing here allocates, nothing here copies and nothing here pins: the region must stay put and stay aligned for as long as this handle or anything reached through it is used.

func (*SeatEnvironmentCook) Open

func (cook *SeatEnvironmentCook) Open(base unsafe.Pointer, length int64) error

Open checks the header in SPEC §7 order, bytewise until base alignment is established. A successful match points at the region and allocates nothing.

func (SeatEnvironmentCook) RegionAlignment

func (c SeatEnvironmentCook) RegionAlignment() int64

§7.1's constants, so a consumer reading this file has the facts and not a description of them. They are METHODS because §11 leaves a language whose accessors are members free to spell them that way, and a package constant per table per fact would claim names §11 does not.

func (SeatEnvironmentCook) Root

Root is the root record at the region's base. It is a POINTER and not a copy: a cooked graph is walked by adding deltas to slot addresses.

func (SeatEnvironmentCook) RootAlign

func (c SeatEnvironmentCook) RootAlign() int64

func (SeatEnvironmentCook) RootSize

func (c SeatEnvironmentCook) RootSize() int64

func (SeatEnvironmentCook) Type

Type is SeatEnvironment's cooked-record descriptor, the head of the graph a reflective walk follows (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type SeatEnvironmentRow

type SeatEnvironmentRow struct {
	Version        int32
	VersionPresent bool // ?: one byte, in Go's model as in C++

	ForgeIdentity    int64 // *: signed self-relative delta, zero is null (§6.3)
	NovaSprintRedis  int64 // *: signed self-relative delta, zero is null (§6.3)
	NovaSprintServer int64 // *: signed self-relative delta, zero is null (§6.3)
	NovaBusRedis     int64 // *: signed self-relative delta, zero is null (§6.3)
	Login            int64 // *SeatLogin: signed self-relative delta, zero is null (§6.3)
	// contains filtered or unexported fields
}

SeatEnvironmentRow — a cooked record. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func SeatEnvironmentAt

func SeatEnvironmentAt(slot *int64, arena ...*TableArena) *SeatEnvironmentRow

SeatEnvironmentAt dereferences a reference, and it is the same call in a locked region and an opened cook because they are the same encoding (§6.3): the slot is eight bytes, SIGNED, self-relative from the SLOT'S OWN ADDRESS, so a deref needs no base pointer and no bounds test, and NULL IS A DELTA OF ZERO. Nothing about this call is the cook's: it is what a region reference is, and a cook is a region written verbatim.

It takes the SLOT and not its value, because a self-relative delta means nothing without the address it is relative to.

type SeatLogin

type SeatLogin = SeatLoginRow

func SeatLoginEmplace

func SeatLoginEmplace(worker *TableWorker, slot *TableRef) *SeatLogin

func SeatLoginLoad

func SeatLoginLoad(region, wire []byte, report *TableReport) *SeatLogin

func SeatLoginLoadRetain

func SeatLoginLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *SeatLogin

func SeatLoginLoadText

func SeatLoginLoadText(text string, report *TableReport) (*SeatLogin, error)

SeatLoginLoadText reads one SeatLogin from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8) into a builder of its own and returns the locked root, as SeatLoginReadStrict does: it is the STRICT read (§6.5) and refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant LoadBuilder answered, so a recovered value never comes back. It refuses by name: base64_damaged when the body does not decode, unknown_form when the decoded wire's form byte is not one this build carries, wire_damaged for framing damage, and the report's own reason (malformed, clamped, kind_mismatch, ...) otherwise. A nil report is allowed; a supplied one receives THIS read's report, so earlier counts in it never decide.

func SeatLoginReadStrict

func SeatLoginReadStrict(wire []byte) (*SeatLogin, error)

SeatLoginReadStrict is the STRICT read (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5): one call, its own builder, one typed reason.

type SeatLoginBuilder

type SeatLoginBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

func (*SeatLoginBuilder) AsConst

func (b *SeatLoginBuilder) AsConst() *SeatLogin

func (*SeatLoginBuilder) GetRoot

func (b *SeatLoginBuilder) GetRoot() *SeatLogin

func (*SeatLoginBuilder) Init

func (b *SeatLoginBuilder) Init(allocator ...TableAllocator) bool

func (*SeatLoginBuilder) Lock

func (b *SeatLoginBuilder) Lock() bool

func (*SeatLoginBuilder) PackMeasure

func (b *SeatLoginBuilder) PackMeasure() int64

func (*SeatLoginBuilder) PackMeasureReason

func (b *SeatLoginBuilder) PackMeasureReason() (int64, error)

func (*SeatLoginBuilder) Region

func (b *SeatLoginBuilder) Region() []byte

func (*SeatLoginBuilder) Shutdown

func (b *SeatLoginBuilder) Shutdown()

type SeatLoginCook

type SeatLoginCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

SeatLoginCook is SeatLogin's cook: a pointer and a length, and then the root where it lies. Opening one is a HEADER MATCH and no copy; a reference is one add (mas-bandwidth/schema docs/SPEC-TABLES.md §7).

`Cook` is a CLAIMED suffix (§11). C++ spells the same claimed verbs as free functions — SeatLoginOpen, SeatLoginAt — and so does Go, because Go has free functions; what is a MEMBER here is only what §11 leaves a language free to make one.

THE MEMORY IS THE CONSUMER'S. Nothing here allocates, nothing here copies and nothing here pins: the region must stay put and stay aligned for as long as this handle or anything reached through it is used.

func (*SeatLoginCook) Open

func (cook *SeatLoginCook) Open(base unsafe.Pointer, length int64) error

Open checks the header in SPEC §7 order, bytewise until base alignment is established. A successful match points at the region and allocates nothing.

func (SeatLoginCook) RegionAlignment

func (c SeatLoginCook) RegionAlignment() int64

§7.1's constants, so a consumer reading this file has the facts and not a description of them. They are METHODS because §11 leaves a language whose accessors are members free to spell them that way, and a package constant per table per fact would claim names §11 does not.

func (SeatLoginCook) Root

func (c SeatLoginCook) Root() *SeatLoginRow

Root is the root record at the region's base. It is a POINTER and not a copy: a cooked graph is walked by adding deltas to slot addresses.

func (SeatLoginCook) RootAlign

func (c SeatLoginCook) RootAlign() int64

func (SeatLoginCook) RootSize

func (c SeatLoginCook) RootSize() int64

func (SeatLoginCook) Type

func (c SeatLoginCook) Type() *TableCookInfo

Type is SeatLogin's cooked-record descriptor, the head of the graph a reflective walk follows (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type SeatLoginRow

type SeatLoginRow struct {
	Redis  int64 // *: signed self-relative delta, zero is null (§6.3)
	User   int64 // *: signed self-relative delta, zero is null (§6.3)
	Store  int64 // *: signed self-relative delta, zero is null (§6.3)
	AsName int64 // *: signed self-relative delta, zero is null (§6.3)
	Key    int64 // *: signed self-relative delta, zero is null (§6.3)
	Sops   int64 // *: signed self-relative delta, zero is null (§6.3)
	Secret int64 // *: signed self-relative delta, zero is null (§6.3)
}

SeatLoginRow — a cooked record. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func SeatLoginAt

func SeatLoginAt(slot *int64, arena ...*TableArena) *SeatLoginRow

SeatLoginAt dereferences a reference, and it is the same call in a locked region and an opened cook because they are the same encoding (§6.3): the slot is eight bytes, SIGNED, self-relative from the SLOT'S OWN ADDRESS, so a deref needs no base pointer and no bounds test, and NULL IS A DELTA OF ZERO. Nothing about this call is the cook's: it is what a region reference is, and a cook is a region written verbatim.

It takes the SLOT and not its value, because a self-relative delta means nothing without the address it is relative to.

type SourceLabel

type SourceLabel = SourceLabelRow

func SourceLabelLoad

func SourceLabelLoad(region, wire []byte, report *TableReport) *SourceLabel

func SourceLabelLoadRetain

func SourceLabelLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *SourceLabel

func SourceLabelLoadText

func SourceLabelLoadText(text string, report *TableReport) (*SourceLabel, error)

SourceLabelLoadText reads one SourceLabel from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8) into a builder of its own and returns the locked root, as SourceLabelReadStrict does: it is the STRICT read (§6.5) and refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant LoadBuilder answered, so a recovered value never comes back. It refuses by name: base64_damaged when the body does not decode, unknown_form when the decoded wire's form byte is not one this build carries, wire_damaged for framing damage, and the report's own reason (malformed, clamped, kind_mismatch, ...) otherwise. A nil report is allowed; a supplied one receives THIS read's report, so earlier counts in it never decide.

func SourceLabelReadStrict

func SourceLabelReadStrict(wire []byte) (*SourceLabel, error)

SourceLabelReadStrict is the STRICT read (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5): one call, its own builder, one typed reason.

type SourceLabelBuilder

type SourceLabelBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

func (*SourceLabelBuilder) AsConst

func (b *SourceLabelBuilder) AsConst() *SourceLabel

func (*SourceLabelBuilder) GetRoot

func (b *SourceLabelBuilder) GetRoot() *SourceLabel

func (*SourceLabelBuilder) Init

func (b *SourceLabelBuilder) Init(allocator ...TableAllocator) bool

func (*SourceLabelBuilder) Lock

func (b *SourceLabelBuilder) Lock() bool

func (*SourceLabelBuilder) PackMeasure

func (b *SourceLabelBuilder) PackMeasure() int64

func (*SourceLabelBuilder) PackMeasureReason

func (b *SourceLabelBuilder) PackMeasureReason() (int64, error)

func (*SourceLabelBuilder) Region

func (b *SourceLabelBuilder) Region() []byte

func (*SourceLabelBuilder) Shutdown

func (b *SourceLabelBuilder) Shutdown()

type SourceLabelCook

type SourceLabelCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

SourceLabelCook is SourceLabel's cook: a pointer and a length, and then the root where it lies. Opening one is a HEADER MATCH and no copy; a reference is one add (mas-bandwidth/schema docs/SPEC-TABLES.md §7).

`Cook` is a CLAIMED suffix (§11). C++ spells the same claimed verbs as free functions — SourceLabelOpen, SourceLabelAt — and so does Go, because Go has free functions; what is a MEMBER here is only what §11 leaves a language free to make one.

THE MEMORY IS THE CONSUMER'S. Nothing here allocates, nothing here copies and nothing here pins: the region must stay put and stay aligned for as long as this handle or anything reached through it is used.

func (*SourceLabelCook) Open

func (cook *SourceLabelCook) Open(base unsafe.Pointer, length int64) error

Open checks the header in SPEC §7 order, bytewise until base alignment is established. A successful match points at the region and allocates nothing.

func (SourceLabelCook) RegionAlignment

func (c SourceLabelCook) RegionAlignment() int64

§7.1's constants, so a consumer reading this file has the facts and not a description of them. They are METHODS because §11 leaves a language whose accessors are members free to spell them that way, and a package constant per table per fact would claim names §11 does not.

func (SourceLabelCook) Root

func (c SourceLabelCook) Root() *SourceLabelRow

Root is the root record at the region's base. It is a POINTER and not a copy: a cooked graph is walked by adding deltas to slot addresses.

func (SourceLabelCook) RootAlign

func (c SourceLabelCook) RootAlign() int64

func (SourceLabelCook) RootSize

func (c SourceLabelCook) RootSize() int64

func (SourceLabelCook) Type

func (c SourceLabelCook) Type() *TableCookInfo

Type is SourceLabel's cooked-record descriptor, the head of the graph a reflective walk follows (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type SourceLabelRow

type SourceLabelRow struct {
	Text int64 // *: signed self-relative delta, zero is null (§6.3)
}

SourceLabelRow — a cooked record. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func DayFileSourcesAdd

func DayFileSourcesAdd(worker *TableWorker, holder *TableList[SourceLabelRow]) *SourceLabelRow

func DayLineSourcesAdd

func DayLineSourcesAdd(worker *TableWorker, holder *TableList[SourceLabelRow]) *SourceLabelRow

func SourceLabelAt

func SourceLabelAt(slot *int64, arena ...*TableArena) *SourceLabelRow

SourceLabelAt dereferences a reference, and it is the same call in a locked region and an opened cook because they are the same encoding (§6.3): the slot is eight bytes, SIGNED, self-relative from the SLOT'S OWN ADDRESS, so a deref needs no base pointer and no bounds test, and NULL IS A DELTA OF ZERO. Nothing about this call is the cook's: it is what a region reference is, and a cook is a region written verbatim.

It takes the SLOT and not its value, because a self-relative delta means nothing without the address it is relative to.

type TableAllocator

type TableAllocator struct {
	Alloc func(int64) []byte
	Free  func([]byte)
}

TableAllocator owns authoring and temporary writer storage. Both callbacks are required together; an empty pair uses Go-owned storage. Alloc supplies zeroed bytes aligned to tableRegionAlign and may return more than requested. Free always receives the original slice, with its original length and base. Load and LoadMeasure use caller buffers and never call this pair.

type TableArena

type TableArena struct {
	Allocator TableAllocator
	Locked    bool
	// contains filtered or unexported fields
}

func (*TableArena) At

func (a *TableArena) At(ref TableRef) unsafe.Pointer

func (*TableArena) Init

func (a *TableArena) Init(allocator ...TableAllocator) bool

func (*TableArena) Shutdown

func (a *TableArena) Shutdown()

type TableBitReader

type TableBitReader struct {
	Buffer []byte
	Offset int64
}

func (*TableBitReader) Align

func (r *TableBitReader) Align() bool

func (*TableBitReader) Get

func (r *TableBitReader) Get(n int64) (uint64, bool)

func (*TableBitReader) Skip

func (r *TableBitReader) Skip(n int64) bool

type TableBitWriter

type TableBitWriter struct {
	Buffer              []byte
	Bits                int64
	Measuring, Overflow bool
}

TableBitWriter uses the packet wire's low-bit-first order. Measuring walks the identical stream, including alignment, without touching a buffer.

func (*TableBitWriter) Align

func (w *TableBitWriter) Align()

func (*TableBitWriter) Put

func (w *TableBitWriter) Put(value uint64, n int64)

func (*TableBitWriter) Raw

func (w *TableBitWriter) Raw(data []byte)

type TableBlob

type TableBlob struct {
	Length uint32
	Zero   uint32
}

Blob ABI follows the established tool and C++ byte contract: u32 length, u32 zero. SPEC-TABLES §7.2 currently labels this u64; the big-endian fixtures distinguish them.

func TableBlobAt

func TableBlobAt(slot *TableRef, arena ...*TableArena) *TableBlob

type TableBuildVersionMismatch

type TableBuildVersionMismatch struct{ Peer, Own uint64 }

TableBuildVersionMismatch is the typed error a strict announcement refusal reports (mas-bandwidth/schema docs/SPEC-TABLES.md §3.3): the peer's build version and the reader's own, each a 64-bit number.

func (TableBuildVersionMismatch) Error

type TableByteOrder

type TableByteOrder uint8

TableByteOrder selects the target order, independently of the writing host.

const (
	TableByteOrderLittle TableByteOrder = 1
	TableByteOrderBig    TableByteOrder = 2
)

type TableBytesView

type TableBytesView struct {
	Data   []byte
	Length int64
}

TableBytesView borrows its backing region or arena. Keep that storage alive and do not free, reuse, or shut it down while using the view.

func TableBytesAt

func TableBytesAt(slot *TableRef, arena ...*TableArena) TableBytesView

type TableCookFieldInfo

type TableCookFieldInfo struct {
	Name          string
	Offset        int32 // the field's offset in the record this descriptor describes
	Size          int32 // its whole storage there, companions included
	ElemSize      int32 // one element's size, for an array; the field's own otherwise
	IsArray       bool
	ArrayBound    int32 // the DECLARED bound: a counted array's N, a string's or bytes' length
	IsPointer     bool  // an eight-byte SIGNED SELF-RELATIVE delta slot (§6.3)
	CountOffset   int32 // the count companion's offset, or -1 when the field has none
	PresentOffset int32 // an optional's presence bool, or -1
	Storage       TableCookStorage
	// Record is the record this field NAMES, behind a function so the table
	// stays constructible in any order — Go refuses an initialisation cycle
	// among package-level variables, and the DESCRIPTOR graph is cyclic by
	// design: a record's field column can name its own record. A cooked REGION
	// is never cyclic; schema cook refuses one by name (§3.1).
	// nil when the field is a scalar. Following it is how a walker DESCENDS: a
	// pointer's target, a by-value nesting, and an array's element are all
	// reached through this one column.
	Record func() *TableCookInfo
}

TableCookFieldInfo is one record's field as DATA — the mechanism behind a reflective read of a cooked region, and what a gate walks a whole graph with. A field carries the facts a region actually has: where it sits, how big it is, whether it is a POINTER EDGE, the bound its COUNT COMPANION is checked against, and the record it names.

type TableCookInfo

type TableCookInfo struct {
	Name      string
	Size      int32
	Align     int32
	NumFields int32
	Fields    []TableCookFieldInfo
}

TableCookInfo is one cooked record's layout as DATA.

type TableCookStorage

type TableCookStorage uint8

TableCookStorage is what a cooked SLOT holds, which is not always what the WIRE carries: an ENUM slot holds the ORDINAL at the enum's own derived storage width (mas-bandwidth/schema docs/SPEC-TABLES.md §7.2), where the wire rides the variant-name hash. A walker reads a slot with the width ElemSize gives and the signedness this names.

Its members are FLAT package-level constants, which is what Go already does with every enum a schema declares (SPEC.md §6.1's Go column) — so all eight spellings are claimed in mas-bandwidth/schema internal/tablenames, exactly as a declared enum's variants are claimed by the checker. C# spells the same vocabulary as one scoped enum and claims one name; the port does not get to have it both ways, and the flat form is the one a Go consumer expects to write.

const (
	TableCookStorageRecord    TableCookStorage = iota // a nested record, or an array of them: descend through it
	TableCookStorageReference                         // an eight-byte SIGNED SELF-RELATIVE delta slot (§6.3)
	TableCookStorageBool
	TableCookStorageSigned
	TableCookStorageUnsigned // an unsigned integer, an enum ordinal, a bits(N), a flags mask
	TableCookStorageFloat
	TableCookStorageString // char[N + 1] with an int32 used length beside it
	TableCookStorageBytes  // uint8[N] with an int32 used length beside it
)

type TableExtentCarve

type TableExtentCarve struct {
	Base      unsafe.Pointer
	At, Limit int64
	Worker    *TableWorker
	Refused   bool
}

func (*TableExtentCarve) Alloc

func (c *TableExtentCarve) Alloc(n, align int64) unsafe.Pointer

type TableFieldInfo

type TableFieldInfo struct {
	CookOffset, CookElemSize, CookCountOffset, CookPresentOffset uint32
	List, Map                                                    bool // unbounded by-value containers
	ElemAlign                                                    uint32
	Name                                                         string // schema field name, e.g. "health"
	Json                                                         string // the TEXT form's key: the json = "key" attribute, else Name (§16.3)
	TypeName                                                     string // schema element type, e.g. "float32", "Grade"
	DeclaredTypeName                                             string // complete schema spelling including arrays, bounds and pointers
	Id                                                           uint64 // table-wire field id (name hash; the was alias's hash after a rename)
	Pointer                                                      bool
	TargetId                                                     uint64
	Kind                                                         uint8 // table-wire kind; for arrays/strings/bytes, the ELEMENT kind
	IsArray                                                      bool  // fixed or counted array (bytes included)
	Counted                                                      bool  // a <Name>Count/<Name>Length int32 companion exists
	Optional                                                     bool  // a ?T field: a <Name>Present bool decides whether it rides

	ArrayBound    int32  // array capacity / string max length; 0 for plain scalars
	Offset        uint32 // unsafe.Offsetof the storage member
	ElemSize      uint32 // unsafe.Sizeof the member (element size for arrays)
	CountOffset   uint32 // unsafe.Offsetof the count/length companion, or 0xffffffff
	PresentOffset uint32 // unsafe.Offsetof the Present companion, or 0xffffffff

	FracBits         uint8 // fixed-point binary scale
	WideRange        bool
	WideMin, WideMax [2]uint64 // exact two-complement raw bounds, low lane first
	HasRange         bool      // a declared [min, max] (int or float)
	RangeMin         float64   // NOTE: int64 ranges beyond 2^53 lose precision here
	RangeMax         float64

	// EnumMax bounds the vocabulary: enums, the highest valid value (None = 0
	// is always valid); unions, the arm count (tag range [0, EnumMax]); a
	// FLAGS field, the highest declared BIT INDEX; else -1.
	EnumMax int64
	// EnumName is the vocabulary's names, indexed the way EnumMax bounds: an
	// enum's value -> name, a union's tag -> arm name, a FLAGS field's bit
	// index -> variant name. nil for every other kind.
	EnumName func(value uint64) string
	// VariantId is the TABLE-WIRE id of one variant (mas-bandwidth/schema docs/SPEC-TABLES.md §5): for
	// an enum, the hash of the variant's name; for a union, the hash of the
	// arm's name. Hash zero is an ordinary id; ordinal zero is None. nil
	// for every other kind — a FLAGS field's variants have no per-variant wire
	// id (§4), so a nil here beside a non-nil EnumName is what says "flags".
	VariantId func(value uint64) uint64

	// an ENUM-KEYED array (mas-bandwidth/schema docs/SPEC-TABLES.md §2.4, §8): the array has one slot
	// per variant of KeyTypeName, indexed by the variant's value, and its
	// slots ride under variant ids rather than positions. KeyName and KeyId
	// are the key's vocabulary — walk [0, ArrayBound) to print slots by name.
	// All three are nil/"" on every other field.
	KeyTypeName string
	KeyName     func(value uint64) string
	KeyId       func(value uint64) uint64

	// Arms is a union field's shape: the tag and the arms indexed by it, behind
	// a function so a descriptor graph needs no initialization order. nil for
	// every other kind.
	Arms func() *TableUnionInfo

	Guard string // branch guard, e.g. "at_rest" or "!at_rest"; "" if unguarded

	// Table is the nested table's descriptor, or nil. Held as a factory rather
	// than a value so a descriptor graph needs no initialization order: Go
	// refuses an initialization cycle across package-level variables, and a
	// table may name one declared later.
	Table func() *TableTypeInfo

	// what a PERSON wrote about the field (mas-bandwidth/schema docs/SPEC-TABLES.md §8.1): the ///
	// block above it, verbatim (SPEC §4.1). It is TableDocNone when there is
	// none, never nil. Its tags (SPEC §4.2) follow in declared order, and an
	// untagged field is 0 beside a nil list. Static package data, allocating
	// nothing.
	Doc     string
	NumTags int32
	Tags    []string
}

TableFieldInfo is one field's descriptor.

type TableFixedDst

type TableFixedDst struct {
	Dst, Stride, Aux   uint32
	Counted, Arg, Meta uint8
}

type TableFixedEntry

type TableFixedEntry struct {
	Src, Dst, Size, Aux, Guard uint32
	// Arg IS THE GUARD'S ORDINAL AT FULL WIDTH (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md
	// §4.1: arg : u64, "no byte lane anywhere"): a union past 255 arms or an
	// enum past 65535 variants holds its ordinal whole in this lane, and the
	// compare is made against the 64-bit tag load, never a truncation of it.
	Arg uint64
	// Guard2 / Arg2 / ArgW2 ARE THE OUTER TAG AN ARM INSIDE AN ARM ALSO ANSWERS
	// TO (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §4.1): the entry runs only when BOTH tags
	// hold their ordinal. ArgW2 of zero is "no outer tag", so a plan that never
	// nests a union leaves the lane unset and the read is unchanged.
	Guard2 uint32
	Arg2   uint64
	// GuardIndex / GuardCount ARE THE GUARD CHAIN (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md
	// §4.1): offset+count into a pool of (guard, arg, argw) links, OUTERMOST
	// FIRST. GuardIndex is a BYTE OFFSET from the plan's own base, where the pool
	// is laid behind the entries the way the ordinal remap tables are, so the
	// plan stays one slice and the read loop one signature. Every guarded entry
	// carries its whole chain; the two lanes above stay its innermost two, the
	// special case, so the loop walks the pool only for a chain past two. The
	// only bound on a chain is the layout's 64 (tableFixedMaxDepth).
	GuardIndex, GuardCount               uint32
	Op, ArgW, DstSize, Sign, Meta, ArgW2 uint8
}

Arg is the guard's arm ordinal: tableFixedRun compares src[Guard] against it. Meta is a text entry's flavour (tableFixedTextUtf8/Wide/Bytes). They shared one lane until reference-fix 12; compiling a string under a union arm overwrote the guard with the flavour and the read skipped the string. tableFixedEntryBytes is the FILE layout entry (id+kind+size+children), not this in-memory plan row — Meta does not ride the wire. ArgW IS THE GUARD'S WIDTH IN BYTES (§5.2 THE GUARD'S WIDTH): a union tag is one, two, four or eight bytes, clamped 1..8, and 0 reads as 1. The guard is tested at that FULL width and never at its first byte — a foreign two-byte tag 0x0101 is not arm 1. Arg is the arm ordinal and carries NO BYTE LANE (§5.8 row 5): a 256-arm union's ordinal does not fit a byte.

type TableFixedGuardLink struct {
	Guard uint32
	Arg   uint64
	ArgW  uint8
}

TableFixedGuardLink is ONE LINK of a guard chain (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §4.1): the offset of the tag it reads, the ordinal the tag must hold, and the width it is compared at. A chain is a CONJUNCTION — every link must hold.

type TableFixedKnownLayout

type TableFixedKnownLayout struct {
	Hash        uint64
	Layout      []byte
	LayoutBytes int
	Record      int64
}

TableFixedKnownLayout is one locked layout: the wire hash a file is matched on, the layout bytes verbatim with its byte length BESIDE the pointer, and the RECORD SIZE taken from the lock and never from the file. The members are §5.9 #19's: hash, layout, layout_bytes, record_bytes, in that order.

type TableIds

type TableIds struct {
	Numbering *TableNumbering
	Values    [tableIdCapacity]uint64

	Count    int
	Overflow bool
	// contains filtered or unexported fields
}

TableIds interns the writer's ids in first-use order. Bucket links are one-based so its zero value is ready to use, including for hash zero.

func (*TableIds) Ref

func (ids *TableIds) Ref(id uint64) uint64

func (*TableIds) RefAt

func (ids *TableIds) RefAt(ordinal int, id uint64) uint64

RefAt is Ref for a compile-time-constant id. The ordinal is that id's index in TableWireIds. A hit is one load and one compare; first-use order is still append order. Truncate clears the ordinal in O(popped) so a speculative intern does not leak into the next walk. An ordinal outside the slot range falls back to Ref; it does not index slot.

func (*TableIds) Truncate

func (ids *TableIds) Truncate(mark int)

Truncate removes speculative ids when a measured field elides, or before writing the payload whose size was just measured under the same vocabulary.

type TableList

type TableList[T any] struct {
	Ref   int64
	Count int32
	// contains filtered or unexported fields
}

func (*TableList[T]) At

func (l *TableList[T]) At(index int32, arena ...*TableArena) *T

func (*TableList[T]) Clear

func (l *TableList[T]) Clear()

type TableMap

type TableMap[T any] struct {
	Ref   int64
	Count int32
	// contains filtered or unexported fields
}

func (*TableMap[T]) At

func (m *TableMap[T]) At(index int32, arena ...*TableArena) *T

func (*TableMap[T]) Clear

func (m *TableMap[T]) Clear()

type TableMapIndex

type TableMapIndex struct {
	// contains filtered or unexported fields
}

type TableMessageEntry

type TableMessageEntry struct {
	Id             uint64
	Shape, Element TableMessageShape
}

type TableMessageReader

type TableMessageReader struct {
	Nodes      TableNodeMap
	Bits       TableBitReader
	Vocabulary *TableVocabulary
	Report     TableReport
	IndexBits  int64
}

type TableMessageShape

type TableMessageShape struct {
	Kind, Packing uint8
	Bits          int64
	Base          [2]uint64
	Min, Max      int64
	QMin, QDelta  float32
	QCount        uint32
}

type TableMessageWriter

type TableMessageWriter struct {
	TableBitWriter
	IndexBits int64
	Clamped   int32
	Numbering *TableNumbering
	// contains filtered or unexported fields
}

type TableMissingRequired

type TableMissingRequired struct{ Fields string }

TableMissingRequired is the typed error a strict read reports for a record that lacks a | required field (mas-bandwidth/schema docs/SPEC-TABLES.md §2.3): Fields names the missing fields, comma-separated in declaration order, at whatever depth of the record they were missing, and Error() is the report's own reason.

func (TableMissingRequired) Error

func (m TableMissingRequired) Error() string

type TableNodeDirEntry

type TableNodeDirEntry struct{ Offset, TypeId uint64 }

type TableNodeMap

type TableNodeMap struct {
	Carve   TableExtentCarve
	Base    unsafe.Pointer
	Entries []TableNodeDirEntry
	Good    bool
	Arena   bool
}

func (TableNodeMap) Resolve

func (m TableNodeMap) Resolve(slot *TableRef, index, target uint64, r *TableReport)

type TableNumbering

type TableNumbering struct {
	// contains filtered or unexported fields
}

The root and arena keep the source storage live while pointer-free backing allocations hold the index and entries. Temporary storage is released by caller.

func (*TableNumbering) Index

func (n *TableNumbering) Index(slot *TableRef) (uint64, bool)

func (*TableNumbering) Release

func (n *TableNumbering) Release()

type TableOpenVerdict

type TableOpenVerdict uint8

TableOpenVerdict distinguishes an unsupported form from framing damage.

const (
	TableOpenOk TableOpenVerdict = iota
	TableOpenRefused
	TableOpenDamaged
	TableOpenBodyStopped
)

type TableReader

type TableReader struct {
	Nodes  TableNodeMap
	Buffer []byte
	Offset int64
	Report *TableReport
	Ids    []byte
	Nested bool
}

TableReader holds one bounded body and a view of the file's id trailer. Sub-readers share the trailer and report, but cannot consume sibling bytes.

func (*TableReader) Body

func (r *TableReader) Body() (TableReader, bool)

func (TableReader) EndsEarly

func (r TableReader) EndsEarly() bool

EndsEarly only recognizes an otherwise walkable body's early terminator. Other damage is decoded normally, preserving the prefix already read.

func (*TableReader) Get8

func (r *TableReader) Get8() uint8

func (*TableReader) Get16

func (r *TableReader) Get16() uint16

func (*TableReader) Get32

func (r *TableReader) Get32() uint32

func (*TableReader) Get64

func (r *TableReader) Get64() uint64

func (*TableReader) Has

func (r *TableReader) Has(n int64) bool

func (*TableReader) Leb

func (r *TableReader) Leb() (uint64, bool)

A rejected integer leaves the cursor unchanged. Its spelling must be minimal and fit in 64 bits, including the tenth byte's single value bit.

func (*TableReader) Resolve

func (r *TableReader) Resolve(ref uint64) (uint64, bool)

func (*TableReader) Room

func (r *TableReader) Room(n uint64) bool

func (*TableReader) Signed

func (r *TableReader) Signed(kind uint8) int64

func (*TableReader) Skip

func (r *TableReader) Skip(kind uint8) bool

func (*TableReader) Sub

func (r *TableReader) Sub(n int64) TableReader

func (*TableReader) Take

func (r *TableReader) Take(sub TableReader)

func (*TableReader) Unsigned

func (r *TableReader) Unsigned(kind uint8) uint64

type TableRef

type TableRef = int64

type TableRefuseReason

type TableRefuseReason uint8

TableRefuseReason is the typed error shared by file and accelerator failures. A successful call returns nil; a failure returns its first failing clause.

const (
	TableRefuseOk TableRefuseReason = iota
	TableRefuseNotACook
	TableRefuseForeignOrder
	TableRefuseWrongBuildVersion
	TableRefuseReservedNotZero
	TableRefuseBadAlignment
	TableRefuseTruncated
	TableRefuseUnalignedBase
	TableRefuseBadLayout
	TableRefuseUnknownForm
	TableRefuseCountOverLength
	TableRefuseCountOverExtentCap
	TableRefuseBlobOverSizeCap
	TableRefuseDataCycle
	TableRefuseInvalidValue
	TableRefuseAllocationFailed
	TableRefuseWireDamaged
	TableRefuseMalformed
	TableRefuseClamped
	TableRefuseKindMismatch
	TableRefuseBase64Damaged
)

func (TableRefuseReason) Error

func (r TableRefuseReason) Error() string

type TableReport

type TableReport struct {
	Retained, RetainLost int32
	Verdict              TableOpenVerdict // unsupported form is distinct from damage
	Reason               string           // why the form was refused; empty for a file read
	Widened              int32            // a compatible wider kind preserved the value
	Unknown              int32            // unknown field ids skipped (newer data)
	KindMismatch         int32            // known id, changed type — skipped, never misdecoded
	Clamped              int32            // out-of-range values clamped to declared bounds
	// Duplicate counts repeated text keys. Fixed-class wire fields do not raise it.
	// A body carrying an id twice is legal input
	// whose last occurrence wins, silently. A wire read always leaves it zero.
	Duplicate int32
	// MissingRequired counts required fields (mas-bandwidth/schema docs/SPEC-TABLES.md §2.3) the
	// record did not carry: a record an older writer produced before the field
	// became required. The refusal names the field in Reason.
	MissingRequired int32
	Malformed       bool // framing damage; decode stopped, partial result kept
	// BuildVersionPeer and BuildVersionOwn are the two build versions a strict
	// announcement refusal carries (mas-bandwidth/schema docs/SPEC-TABLES.md §3.3): the peer's
	// announcement and this unit's own. They are zero on every other read.
	BuildVersionPeer uint64
	BuildVersionOwn  uint64
	// LayoutHash is THE FILE'S hash, and it is set by ONE refusal:
	// layout_newer reports it "AND NOTHING ELSE" (§5.3). layout_unsupported
	// reports it too — the operator's other answer, a layout this build served
	// and has retired.
	LayoutHash uint64
}

TableReport is the table-wire read report — the permissive contract's ledger. Silence (all zero) means the data matched this reader's schema exactly. Err (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5) is the STRICT read's typed reason for malformed, clamped, kind-mismatched, unknown form, wire-damaged and build-version-mismatched. Unknown, Widened and Retained alone are not one.

func (*TableReport) Err

func (r *TableReport) Err() error

Err is the report's typed error (mas-bandwidth/schema docs/SPEC-TABLES.md §6.5, mas-bandwidth/schema docs/VERSIONING.md The read report). A strict read refuses malformed, clamped, kind-mismatched, unknown form, wire-damaged, build-version-mismatched and missing-required (§2.3, naming the field), each as one typed reason. Unknown, Widened and Retained alone leave it nil, as does a clean read.

type TableRetain

type TableRetain struct {
	Bytes []byte
	Ids   []TableRetainId
	Used  int64
	Count int
	// contains filtered or unexported fields
}

type TableRetainId

type TableRetainId struct {
	Id   uint64
	Slot int
}

type TableRetainIds

type TableRetainIds struct {
	Numbering      *TableNumbering
	Retain         *TableRetain
	Path           tableRetainPath
	Count          int
	Overflow, Lost bool
	// contains filtered or unexported fields
}

func (*TableRetainIds) Ref

func (i *TableRetainIds) Ref(id uint64) uint64

func (*TableRetainIds) RefAt

func (i *TableRetainIds) RefAt(ordinal int, id uint64) uint64

func (*TableRetainIds) Truncate

func (i *TableRetainIds) Truncate(mark int)

type TableRetainMessageReader

type TableRetainMessageReader struct {
	Retain *TableRetain
	Path   tableRetainPath
	// contains filtered or unexported fields
}

type TableRetainReader

type TableRetainReader struct {
	Retain *TableRetain
	Path   tableRetainPath
	// contains filtered or unexported fields
}

func (*TableRetainReader) Body

func (*TableRetainReader) Take

func (r *TableRetainReader) Take(sub TableRetainReader)

type TableRetainWriter

type TableRetainWriter struct {
	Buffer    []byte
	Offset    int64
	Overflow  bool
	Measuring bool
	Ids       *TableRetainIds
}

func (*TableRetainWriter) Advance

func (w *TableRetainWriter) Advance(n int64) bool

func (*TableRetainWriter) Header

func (w *TableRetainWriter) Header(ref uint64, kind uint8)

Header writes a field's reference and kind. A reference below 128 is one LEB byte, so the pair is one two-byte store. Larger references still go through PutLeb then Put8. Bytes match that two-call spelling; a pair that does not fit now leaves the buffer alone, and Save answers -1.

func (*TableRetainWriter) Id

func (w *TableRetainWriter) Id(id uint64)

func (*TableRetainWriter) IdAt

func (w *TableRetainWriter) IdAt(ordinal int, id uint64)

func (*TableRetainWriter) Put8

func (w *TableRetainWriter) Put8(v uint8)

func (*TableRetainWriter) Put16

func (w *TableRetainWriter) Put16(v uint16)

func (*TableRetainWriter) Put32

func (w *TableRetainWriter) Put32(v uint32)

func (*TableRetainWriter) Put64

func (w *TableRetainWriter) Put64(v uint64)

func (*TableRetainWriter) Put128

func (w *TableRetainWriter) Put128(lo, hi uint64)

Put128 writes two little-endian lanes, low first, under one Advance.

func (*TableRetainWriter) PutLeb

func (w *TableRetainWriter) PutLeb(v uint64)

func (*TableRetainWriter) Raw

func (w *TableRetainWriter) Raw(data []byte)

func (*TableRetainWriter) Trailer

func (w *TableRetainWriter) Trailer()

type TableStringView

type TableStringView struct {
	Data   []byte
	Length int64
}

TableStringView has the same borrowed lifetime as TableBytesView.

func TableStringAt

func TableStringAt(slot *TableRef, arena ...*TableArena) TableStringView

type TableTimestampError

type TableTimestampError struct {
	Field string
	Time  time.Time
}

TableTimestampError is the refusal of a time.Time that no count names: its nanoseconds since the Unix epoch do not fit an int64, which is Time.UnixNano's own domain, the years 1678 through 2262 (mas-bandwidth/schema docs/SPEC-TABLES.md §2.11).

func (TableTimestampError) Error

func (e TableTimestampError) Error() string

type TableTypeInfo

type TableTypeInfo struct {
	SaveBodyRetain        func(*TableRetainWriter, unsafe.Pointer) bool
	LoadBodyRetain        func(TableRetainReader, unsafe.Pointer) bool
	LoadMessageBodyRetain func(TableRetainMessageReader, unsafe.Pointer) (TableRetainMessageReader, bool)
	CookSize, CookAlign   uint32
	Name                  string // schema type name
	Size                  uint32 // unsafe.Sizeof the storage struct
	Id                    uint64
	Variable              bool
	NodeType              func(uint64) *TableTypeInfo
	SaveBody              func(*TableWriter, unsafe.Pointer) bool
	LoadBody              func(TableReader, unsafe.Pointer) bool
	SaveMessageBody       func(*TableMessageWriter, unsafe.Pointer) bool
	LoadMessageBody       func(TableMessageReader, unsafe.Pointer) (TableMessageReader, bool)
	NumFields             int32
	Fields                []TableFieldInfo
	// Reset puts one instance back at its declared defaults, in place. A
	// generic walker that fills a value has to be able to establish the
	// defaults an absent field takes, and it holds no type to spell — this is
	// the one thing the descriptors could not express without it.
	Reset func(storage unsafe.Pointer)

	// the declaration's own doc and tags, on the same terms as a field's
	// (mas-bandwidth/schema docs/SPEC-TABLES.md §8.1, SPEC §4.1, §4.2)
	Doc     string
	NumTags int32
	Tags    []string
}

TableTypeInfo is one type's descriptor.

var BusRosterTableInfo TableTypeInfo

BusRosterTableInfo is BusRoster's reflection descriptor (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

var DayFileTableInfo TableTypeInfo

DayFileTableInfo is DayFile's reflection descriptor (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

var DayLineTableInfo TableTypeInfo

DayLineTableInfo is DayLine's reflection descriptor (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

var ParticipantTableInfo TableTypeInfo

ParticipantTableInfo is Participant's reflection descriptor (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

var PlacedReceiptTableInfo TableTypeInfo

PlacedReceiptTableInfo is PlacedReceipt's reflection descriptor (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

var SeatEnvironmentTableInfo TableTypeInfo

SeatEnvironmentTableInfo is SeatEnvironment's reflection descriptor (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

var SeatLoginTableInfo TableTypeInfo

SeatLoginTableInfo is SeatLogin's reflection descriptor (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

var SourceLabelTableInfo TableTypeInfo

SourceLabelTableInfo is SourceLabel's reflection descriptor (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

func BusRosterTableType

func BusRosterTableType() *TableTypeInfo

BusRosterTableType returns BusRoster's reflection descriptor.

func DayFileTableType

func DayFileTableType() *TableTypeInfo

DayFileTableType returns DayFile's reflection descriptor.

func DayLineTableType

func DayLineTableType() *TableTypeInfo

DayLineTableType returns DayLine's reflection descriptor.

func ParticipantTableType

func ParticipantTableType() *TableTypeInfo

ParticipantTableType returns Participant's reflection descriptor.

func PlacedReceiptTableType

func PlacedReceiptTableType() *TableTypeInfo

PlacedReceiptTableType returns PlacedReceipt's reflection descriptor.

func SeatEnvironmentTableType

func SeatEnvironmentTableType() *TableTypeInfo

SeatEnvironmentTableType returns SeatEnvironment's reflection descriptor.

func SeatLoginTableType

func SeatLoginTableType() *TableTypeInfo

SeatLoginTableType returns SeatLogin's reflection descriptor.

func SourceLabelTableType

func SourceLabelTableType() *TableTypeInfo

SourceLabelTableType returns SourceLabel's reflection descriptor.

type TableUnionArmInfo

type TableUnionArmInfo struct {
	Field  TableFieldInfo               // arm shape; offsets are relative to union storage
	Void   bool                         // a selected payload-free arm
	Reset  func(storage unsafe.Pointer) // establish selected payload defaults
	Offset uint32                       // unsafe.Offsetof the arm's payload within the union storage
	Table  func() *TableTypeInfo        // the arm payload's descriptor
}

TableUnionArmInfo is one arm of a union field: where its payload sits inside the union's storage and what its payload looks like. The arm's NAME and its table-wire id come from the field's EnumName/VariantId functions at the same tag, so nothing is spelled twice (mas-bandwidth/schema docs/SPEC-TABLES.md §8).

type TableUnionInfo

type TableUnionInfo struct {
	CookTagSize uint32
	TagOffset   uint32 // unsafe.Offsetof the tag within the union storage
	TagSize     uint32 // unsafe.Sizeof the tag
	Arms        []TableUnionArmInfo
}

TableUnionInfo is a union field's shape: the tag, and the arms indexed by it. Arms run [0, EnumMax]; index 0 is the EMPTY arm and carries no payload.

type TableVocabulary

type TableVocabulary struct {
	Entries            []TableMessageEntry
	Count, RefBits     int64
	BuildVersion       uint64
	Announced, Refused bool
	MaxBytes           int64
	Strict             bool
}

Storage belongs to the caller and is resolved once for one connection direction.

func (*TableVocabulary) Entry

func (v *TableVocabulary) Entry(ref uint64) (TableMessageEntry, bool)

func (*TableVocabulary) Init

func (v *TableVocabulary) Init(storage []TableMessageEntry)

func (*TableVocabulary) Name

func (v *TableVocabulary) Name(ref uint64) (uint64, bool)

type TableWorker

type TableWorker struct {
	Arena *TableArena
	// contains filtered or unexported fields
}

func (*TableWorker) Alloc

func (w *TableWorker) Alloc(n int64) (unsafe.Pointer, TableRef)

func (*TableWorker) AllocBytes

func (w *TableWorker) AllocBytes(length int64) ([]byte, TableRef)

func (*TableWorker) AllocString

func (w *TableWorker) AllocString(length int64) ([]byte, TableRef)

type TableWriteContext

type TableWriteContext interface {
	// contains filtered or unexported methods
}

TableWriteContext selects allocation independently from reference addressing. Pass a TableAllocator for a loaded/locked region, or *TableArena for authoring references and that arena's allocation pair. Omit it for Go-owned temporaries.

type TableWriter

type TableWriter struct {
	Buffer    []byte
	Offset    int64
	Overflow  bool
	Measuring bool
	Ids       *TableIds
}

TableWriter writes into the caller's buffer, or counts exactly the same bytes in Measuring mode. Offset and every length are checked before use.

func (*TableWriter) Advance

func (w *TableWriter) Advance(n int64) bool

func (*TableWriter) Header

func (w *TableWriter) Header(ref uint64, kind uint8)

Header writes a field's reference and kind. A reference below 128 is one LEB byte, so the pair is one two-byte store. Larger references still go through PutLeb then Put8. Bytes match that two-call spelling; a pair that does not fit now leaves the buffer alone, and Save answers -1.

func (*TableWriter) Id

func (w *TableWriter) Id(id uint64)

func (*TableWriter) IdAt

func (w *TableWriter) IdAt(ordinal int, id uint64)

func (*TableWriter) Put8

func (w *TableWriter) Put8(v uint8)

func (*TableWriter) Put16

func (w *TableWriter) Put16(v uint16)

func (*TableWriter) Put32

func (w *TableWriter) Put32(v uint32)

func (*TableWriter) Put64

func (w *TableWriter) Put64(v uint64)

func (*TableWriter) Put128

func (w *TableWriter) Put128(lo, hi uint64)

Put128 writes two little-endian lanes, low first, under one Advance.

func (*TableWriter) PutLeb

func (w *TableWriter) PutLeb(v uint64)

func (*TableWriter) Raw

func (w *TableWriter) Raw(data []byte)

func (*TableWriter) Trailer

func (w *TableWriter) Trailer()

type UnitViewInfo

type UnitViewInfo struct {
	Package                                                          string
	ProtocolId                                                       uint64
	NumTypes, NumTables, NumEnums, NumFlags, NumUnions, NumConstants int32
	Types, Tables                                                    []ViewType
	Enums, Flags, Unions                                             []ViewVocabulary
	Constants                                                        []ViewConstant
}

func UnitView

func UnitView() *UnitViewInfo

type ViewConstant

type ViewConstant struct {
	Name, File, TypeName string
	IsFloat              bool
	IntValue             int64
	FloatValue           float64
	Doc                  string
	NumTags              int32
	Tags                 []string
}

UnitView returns this build's registry. Treat its descriptors and slices as immutable; lookups allocate nothing. Packet-only types gain no table codec. A packet dependency can use different storage from its table Row; its descriptor follows that storage, so every offset remains valid for the value.

type ViewType

type ViewType struct {
	Name, File string
	Table      bool
	Type       *TableTypeInfo
	Doc        string
	NumTags    int32
	Tags       []string
}

type ViewVariant

type ViewVariant struct {
	Value       uint64
	Name        string
	Id          uint64
	PayloadName string
	Payload     func() *TableTypeInfo
	Field       func() *TableFieldInfo
	Doc         string
	NumTags     int32
	Tags        []string
}

type ViewVocabulary

type ViewVocabulary struct {
	Name, File               string
	Max                      int64
	StorageBits, NumVariants int32
	PayloadOffset            uint32
	Variants                 []ViewVariant
	Doc                      string
	NumTags                  int32
	Tags                     []string
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL