decidewire

package
v1.5.2 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 decidewire is the decide area's table wire, generated by the schema compiler from schemas/decide/decide.schema: the decide record lines (Decision, Outcome, Act, RecordLine), the attempt decision (a Decision), the decision's answers, usage and card line (Answer, Usage, Decided), the schema asked (DecideSchema, Question), the import's export and its log line (ImportExport, ImportLogLine), the answers file (FixedTable), the examples file (Example), the score's log export (LogExport) and the Jev request and response (JevRequest, JevResponse), the raw card cost (RawUsage, RawRecord, RawTokens) and the card contract frame (Frame), the gate, first-read, judgment and score structs (Failure, Bars, GateBars, Chosen, Cluster). Usage, Bars, GateBars and RawTokens are FIXED tables; every other table holds text or a list the code does not bound and is VARIABLE. Every other .go file here is generated: edit the .schema and run go generate ./pkg/decidewire, never the output. pkg/schemaread reads it strictly: binary wire or padded standard base64 of the wire, 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 ActLoadRetainBuilder = "Act: retention requires a region round trip through the VARIABLE form"
View Source 
const ActSaveRetainMessages = "Act: retention requires a region round trip through the VARIABLE form"
View Source 
const AnswerLoadRetainBuilder = "Answer: retention requires a region round trip through the VARIABLE form"
View Source 
const AnswerSaveRetainMessages = "Answer: retention requires a region round trip through the VARIABLE form"
View Source 
const BarsBlockMaxBytes int64 = 64

BarsBlockMaxBytes is the storage a PRODUCER of this block allocates, sized from the declared maxima (mas-bandwidth/schema docs/SPEC-TABLES.md §19.1). A Go consumer does not allocate a block — the bytes are handed to it — but it caps by this: a playback buffer, a recording, a scratch copy all size from the generated constant rather than from a number a person wrote down beside it.

View Source 
const BarsLoadRetain = "Bars: retention requires a variable root and its region directory"
View Source 
const BarsLoadRetainBuilder = "Bars: retention requires a region round trip through the VARIABLE form"
View Source 
const BarsLoadRetainMessages = "Bars: retention requires a region round trip through the VARIABLE form"
View Source 
const BarsMeasureRetain = "Bars: retention requires a variable root and its region directory"
View Source 
const BarsSaveRetain = "Bars: retention requires a variable root and its region directory"
View Source 
const BarsSaveRetainMessages = "Bars: retention requires a region round trip through the VARIABLE form"
View Source 
const BuildVersion uint64 = 0x430e16b8606c9494

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 ChosenLoadRetainBuilder = "Chosen: retention requires a region round trip through the VARIABLE form"
View Source 
const ChosenSaveRetainMessages = "Chosen: retention requires a region round trip through the VARIABLE form"
View Source 
const ClusterCardLoadRetainBuilder = "ClusterCard: retention requires a region round trip through the VARIABLE form"
View Source 
const ClusterCardSaveRetainMessages = "ClusterCard: retention requires a region round trip through the VARIABLE form"
View Source 
const ClusterLoadRetainBuilder = "Cluster: retention requires a region round trip through the VARIABLE form"
View Source 
const ClusterSaveRetainMessages = "Cluster: retention requires a region round trip through the VARIABLE form"
View Source 
const CriterionLoadRetainBuilder = "Criterion: retention requires a region round trip through the VARIABLE form"
View Source 
const CriterionSaveRetainMessages = "Criterion: retention requires a region round trip through the VARIABLE form"
View Source 
const DecideSchemaLoadRetainBuilder = "DecideSchema: retention requires a region round trip through the VARIABLE form"
View Source 
const DecideSchemaSaveRetainMessages = "DecideSchema: retention requires a region round trip through the VARIABLE form"
View Source 
const DecidedLoadRetainBuilder = "Decided: retention requires a region round trip through the VARIABLE form"
View Source 
const DecidedSaveRetainMessages = "Decided: retention requires a region round trip through the VARIABLE form"
View Source 
const DecisionLoadRetainBuilder = "Decision: retention requires a region round trip through the VARIABLE form"
View Source 
const DecisionSaveRetainMessages = "Decision: retention requires a region round trip through the VARIABLE form"
View Source 
const ExampleLoadRetainBuilder = "Example: retention requires a region round trip through the VARIABLE form"
View Source 
const ExampleSaveRetainMessages = "Example: retention requires a region round trip through the VARIABLE form"
View Source 
const FailureLoadRetainBuilder = "Failure: retention requires a region round trip through the VARIABLE form"
View Source 
const FailureSaveRetainMessages = "Failure: retention requires a region round trip through the VARIABLE form"
View Source 
const FixedAnswerLoadRetainBuilder = "FixedAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const FixedAnswerSaveRetainMessages = "FixedAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const FixedTableLoadRetainBuilder = "FixedTable: retention requires a region round trip through the VARIABLE form"
View Source 
const FixedTableSaveRetainMessages = "FixedTable: retention requires a region round trip through the VARIABLE form"
View Source 
const FrameLoadRetainBuilder = "Frame: retention requires a region round trip through the VARIABLE form"
View Source 
const FrameSaveRetainMessages = "Frame: retention requires a region round trip through the VARIABLE form"
View Source 
const GateBarsBlockMaxBytes int64 = 64

GateBarsBlockMaxBytes is the storage a PRODUCER of this block allocates, sized from the declared maxima (mas-bandwidth/schema docs/SPEC-TABLES.md §19.1). A Go consumer does not allocate a block — the bytes are handed to it — but it caps by this: a playback buffer, a recording, a scratch copy all size from the generated constant rather than from a number a person wrote down beside it.

View Source 
const GateBarsLoadRetain = "GateBars: retention requires a variable root and its region directory"
View Source 
const GateBarsLoadRetainBuilder = "GateBars: retention requires a region round trip through the VARIABLE form"
View Source 
const GateBarsLoadRetainMessages = "GateBars: retention requires a region round trip through the VARIABLE form"
View Source 
const GateBarsMeasureRetain = "GateBars: retention requires a variable root and its region directory"
View Source 
const GateBarsSaveRetain = "GateBars: retention requires a variable root and its region directory"
View Source 
const GateBarsSaveRetainMessages = "GateBars: retention requires a region round trip through the VARIABLE form"
View Source 
const GateLineLoadRetainBuilder = "GateLine: retention requires a region round trip through the VARIABLE form"
View Source 
const GateLineSaveRetainMessages = "GateLine: retention requires a region round trip through the VARIABLE form"
View Source 
const ImportExportLoadRetainBuilder = "ImportExport: retention requires a region round trip through the VARIABLE form"
View Source 
const ImportExportSaveRetainMessages = "ImportExport: retention requires a region round trip through the VARIABLE form"
View Source 
const ImportLogLineLoadRetainBuilder = "ImportLogLine: retention requires a region round trip through the VARIABLE form"
View Source 
const ImportLogLineSaveRetainMessages = "ImportLogLine: retention requires a region round trip through the VARIABLE form"
View Source 
const InputLoadRetainBuilder = "Input: retention requires a region round trip through the VARIABLE form"
View Source 
const InputSaveRetainMessages = "Input: retention requires a region round trip through the VARIABLE form"
View Source 
const JevAnswerLoadRetainBuilder = "JevAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const JevAnswerSaveRetainMessages = "JevAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const JevRequestLoadRetainBuilder = "JevRequest: retention requires a region round trip through the VARIABLE form"
View Source 
const JevRequestSaveRetainMessages = "JevRequest: retention requires a region round trip through the VARIABLE form"
View Source 
const JevResponseLoadRetainBuilder = "JevResponse: retention requires a region round trip through the VARIABLE form"
View Source 
const JevResponseSaveRetainMessages = "JevResponse: retention requires a region round trip through the VARIABLE form"
View Source 
const JudgmentIdLoadRetainBuilder = "JudgmentId: retention requires a region round trip through the VARIABLE form"
View Source 
const JudgmentIdSaveRetainMessages = "JudgmentId: retention requires a region round trip through the VARIABLE form"
View Source 
const LogExportLoadRetainBuilder = "LogExport: retention requires a region round trip through the VARIABLE form"
View Source 
const LogExportSaveRetainMessages = "LogExport: retention requires a region round trip through the VARIABLE form"
View Source 
const LogLineLoadRetainBuilder = "LogLine: retention requires a region round trip through the VARIABLE form"
View Source 
const LogLineSaveRetainMessages = "LogLine: retention requires a region round trip through the VARIABLE form"
View Source 
const NamedAnswerLoadRetainBuilder = "NamedAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const NamedAnswerSaveRetainMessages = "NamedAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const NamedFixedAnswerLoadRetainBuilder = "NamedFixedAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const NamedFixedAnswerSaveRetainMessages = "NamedFixedAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const NamedJevAnswerLoadRetainBuilder = "NamedJevAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const NamedJevAnswerSaveRetainMessages = "NamedJevAnswer: retention requires a region round trip through the VARIABLE form"
View Source 
const NamedQuestionLoadRetainBuilder = "NamedQuestion: retention requires a region round trip through the VARIABLE form"
View Source 
const NamedQuestionSaveRetainMessages = "NamedQuestion: retention requires a region round trip through the VARIABLE form"
View Source 
const OptionPLoadRetainBuilder = "OptionP: retention requires a region round trip through the VARIABLE form"
View Source 
const OptionPSaveRetainMessages = "OptionP: retention requires a region round trip through the VARIABLE form"
View Source 
const OutcomeLoadRetainBuilder = "Outcome: retention requires a region round trip through the VARIABLE form"
View Source 
const OutcomeSaveRetainMessages = "Outcome: retention requires a region round trip through the VARIABLE form"
View Source 
const ProtocolId uint64 = 0x43d04f03b7c3856d

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 QuestionLoadRetainBuilder = "Question: retention requires a region round trip through the VARIABLE form"
View Source 
const QuestionSaveRetainMessages = "Question: retention requires a region round trip through the VARIABLE form"
View Source 
const RawRecordLoadRetainBuilder = "RawRecord: retention requires a region round trip through the VARIABLE form"
View Source 
const RawRecordSaveRetainMessages = "RawRecord: retention requires a region round trip through the VARIABLE form"
View Source 
const RawTokensBlockMaxBytes int64 = 128

RawTokensBlockMaxBytes is the storage a PRODUCER of this block allocates, sized from the declared maxima (mas-bandwidth/schema docs/SPEC-TABLES.md §19.1). A Go consumer does not allocate a block — the bytes are handed to it — but it caps by this: a playback buffer, a recording, a scratch copy all size from the generated constant rather than from a number a person wrote down beside it.

View Source 
const RawTokensLoadRetain = "RawTokens: retention requires a variable root and its region directory"
View Source 
const RawTokensLoadRetainBuilder = "RawTokens: retention requires a region round trip through the VARIABLE form"
View Source 
const RawTokensLoadRetainMessages = "RawTokens: retention requires a region round trip through the VARIABLE form"
View Source 
const RawTokensMeasureRetain = "RawTokens: retention requires a variable root and its region directory"
View Source 
const RawTokensSaveRetain = "RawTokens: retention requires a variable root and its region directory"
View Source 
const RawTokensSaveRetainMessages = "RawTokens: retention requires a region round trip through the VARIABLE form"
View Source 
const RawUsageLoadRetainBuilder = "RawUsage: retention requires a region round trip through the VARIABLE form"
View Source 
const RawUsageSaveRetainMessages = "RawUsage: retention requires a region round trip through the VARIABLE form"
View Source 
const RecordLineLoadRetainBuilder = "RecordLine: retention requires a region round trip through the VARIABLE form"
View Source 
const RecordLineSaveRetainMessages = "RecordLine: retention requires a region round trip through the VARIABLE form"
View Source 
const SetEntryLoadRetainBuilder = "SetEntry: retention requires a region round trip through the VARIABLE form"
View Source 
const SetEntrySaveRetainMessages = "SetEntry: retention requires a region round trip through the VARIABLE form"
View Source 
const StagePathLoadRetainBuilder = "StagePath: retention requires a region round trip through the VARIABLE form"
View Source 
const StagePathSaveRetainMessages = "StagePath: retention requires a region round trip through the VARIABLE form"
View Source 
const TableBlockMagic uint64 = 0x4b4c42414d484353

TableBlockMagic identifies a schema block and carries the byte-order check with it (mas-bandwidth/schema docs/SPEC-TABLES.md §19.1). It is stored in the producer's NATIVE order; a consumer that reads back the byte-swapped value has found a foreign byte order, and one that reads back anything else has not found a block at all.

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 = 149
View Source 
const TableMessageRefBitsHere = 8
View Source 
const UsageBlockMaxBytes int64 = 64

UsageBlockMaxBytes is the storage a PRODUCER of this block allocates, sized from the declared maxima (mas-bandwidth/schema docs/SPEC-TABLES.md §19.1). A Go consumer does not allocate a block — the bytes are handed to it — but it caps by this: a playback buffer, a recording, a scratch copy all size from the generated constant rather than from a number a person wrote down beside it.

View Source 
const UsageLoadRetain = "Usage: retention requires a variable root and its region directory"
View Source 
const UsageLoadRetainBuilder = "Usage: retention requires a region round trip through the VARIABLE form"
View Source 
const UsageLoadRetainMessages = "Usage: retention requires a region round trip through the VARIABLE form"
View Source 
const UsageMeasureRetain = "Usage: retention requires a variable root and its region directory"
View Source 
const UsageSaveRetain = "Usage: retention requires a variable root and its region directory"
View Source 
const UsageSaveRetainMessages = "Usage: retention requires a region round trip through the VARIABLE form"

Variables

View Source 
var ActTableFields = []TableFieldInfo{
	{Name: "id", Json: "id", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b72e07b55c3ac0, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Act{}.Id)), ElemSize: uint32(unsafe.Sizeof(Act{}.Id)), 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: "step", Json: "step", TypeName: "string", DeclaredTypeName: "string", Id: 0xaf0b4e191da20cef, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Act{}.Step)), ElemSize: uint32(unsafe.Sizeof(Act{}.Step)), 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: "op", Json: "op", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b05607b556600a, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Act{}.Op)), ElemSize: uint32(unsafe.Sizeof(Act{}.Op)), 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: "at", Json: "at", TypeName: "string", DeclaredTypeName: "string", Id: 0x89c4e07b545a968, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Act{}.At)), ElemSize: uint32(unsafe.Sizeof(Act{}.At)), 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},
}

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

View Source 
var AnswerTableFields = []TableFieldInfo{
	{Name: "kind", Json: "kind", TypeName: "AnswerType", DeclaredTypeName: "AnswerType", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Answer{}.Kind)), ElemSize: uint32(unsafe.Sizeof(Answer{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 2,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameAnswerType(AnswerType(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := AnswerType(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "value", Json: "value", TypeName: "string", DeclaredTypeName: "string", Id: 0x7ce4fd9430e80cea, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Answer{}.Value)), ElemSize: uint32(unsafe.Sizeof(Answer{}.Value)), 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: "p", Json: "p", TypeName: "OptionP", DeclaredTypeName: "OptionP", Id: 0xaf63ed4c8602096f, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(Answer{}.P)), ElemSize: uint32(unsafe.Sizeof(*new(OptionPRow))), CountOffset: (uint32(unsafe.Offsetof(Answer{}.P))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 16, CookCountOffset: 24, 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: OptionPTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "confidence", Json: "confidence", TypeName: "float64", DeclaredTypeName: "float64", Id: 0x547d54feea4643b1, Kind: 11, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Answer{}.Confidence)), ElemSize: uint32(unsafe.Sizeof(Answer{}.Confidence)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "method", Json: "method", TypeName: "string", DeclaredTypeName: "string", Id: 0x230c05e5fb0433b0, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Answer{}.Method)), ElemSize: uint32(unsafe.Sizeof(Answer{}.Method)), 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},
}

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

View Source 
var BarsTableFields = []TableFieldInfo{
	{Name: "bounce", Json: "bounce", TypeName: "float64", DeclaredTypeName: "float64", Id: 0x5307024caeff199d, Kind: 11, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Bars{}.Bounce)), ElemSize: uint32(unsafe.Sizeof(Bars{}.Bounce)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "review", Json: "review", TypeName: "float64", DeclaredTypeName: "float64", Id: 0xe9718950b3dd3a1, Kind: 11, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Bars{}.Review)), ElemSize: uint32(unsafe.Sizeof(Bars{}.Review)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var ChosenTableFields = []TableFieldInfo{
	{Name: "verb", Json: "verb", TypeName: "string", DeclaredTypeName: "string", Id: 0x673ebb0102773a20, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Chosen{}.Verb)), ElemSize: uint32(unsafe.Sizeof(Chosen{}.Verb)), 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: "p", Json: "p", TypeName: "float64", DeclaredTypeName: "float64", Id: 0xaf63ed4c8602096f, Kind: 11, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Chosen{}.P)), ElemSize: uint32(unsafe.Sizeof(Chosen{}.P)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "fix", Json: "fix", TypeName: "string", DeclaredTypeName: "string", Id: 0xdc9e7e18fec93bb8, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Chosen{}.Fix)), ElemSize: uint32(unsafe.Sizeof(Chosen{}.Fix)), 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: "reason", Json: "reason", TypeName: "string", DeclaredTypeName: "string", Id: 0x65e8d7f3474f2639, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Chosen{}.Reason)), ElemSize: uint32(unsafe.Sizeof(Chosen{}.Reason)), 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: "act", Json: "act", TypeName: "string", DeclaredTypeName: "string", Id: 0xe723b5190545606b, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Chosen{}.Act)), ElemSize: uint32(unsafe.Sizeof(Chosen{}.Act)), 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: "why", Json: "why", TypeName: "string", DeclaredTypeName: "string", Id: 0x5ec5ea1948914a79, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Chosen{}.Why)), ElemSize: uint32(unsafe.Sizeof(Chosen{}.Why)), 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},
}

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

View Source 
var ClusterCardTableFields = []TableFieldInfo{
	{Name: "card", Json: "card", TypeName: "string", DeclaredTypeName: "string", Id: 0xb5614e90e87b455f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ClusterCard{}.Card)), ElemSize: uint32(unsafe.Sizeof(ClusterCard{}.Card)), 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},
}

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

View Source 
var ClusterTableFields = []TableFieldInfo{
	{Name: "class_name", Json: "class_name", TypeName: "string", DeclaredTypeName: "string", Id: 0x66c0c01d224cae83, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Cluster{}.ClassName)), ElemSize: uint32(unsafe.Sizeof(Cluster{}.ClassName)), 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: "count", Json: "count", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xb1e5e28e4479a274, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Cluster{}.Count)), ElemSize: uint32(unsafe.Sizeof(Cluster{}.Count)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "cards", Json: "cards", TypeName: "ClusterCard", DeclaredTypeName: "ClusterCard", Id: 0xaf9dac3b097689c4, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(Cluster{}.Cards)), ElemSize: uint32(unsafe.Sizeof(*new(ClusterCardRow))), CountOffset: (uint32(unsafe.Offsetof(Cluster{}.Cards))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 24, 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: ClusterCardTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var CriterionTableFields = []TableFieldInfo{
	{Name: "option", Json: "option", TypeName: "string", DeclaredTypeName: "string", Id: 0x3c119c726692754, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Criterion{}.Option)), ElemSize: uint32(unsafe.Sizeof(Criterion{}.Option)), 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: "meaning", Json: "meaning", TypeName: "string", DeclaredTypeName: "string", Id: 0x853103f906a5b644, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Criterion{}.Meaning)), ElemSize: uint32(unsafe.Sizeof(Criterion{}.Meaning)), 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},
}

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

View Source 
var DecideSchemaTableFields = []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(DecideSchema{}.Name)), ElemSize: uint32(unsafe.Sizeof(DecideSchema{}.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: "questions", Json: "questions", TypeName: "NamedQuestion", DeclaredTypeName: "NamedQuestion", Id: 0x8706e8e4197ffb42, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(DecideSchema{}.Questions)), ElemSize: uint32(unsafe.Sizeof(*new(NamedQuestionRow))), CountOffset: (uint32(unsafe.Offsetof(DecideSchema{}.Questions))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 40, CookCountOffset: 16, 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: NamedQuestionTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var DecidedTableFields = []TableFieldInfo{
	{Name: "value", Json: "value", TypeName: "string", DeclaredTypeName: "string", Id: 0x7ce4fd9430e80cea, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decided{}.Value)), ElemSize: uint32(unsafe.Sizeof(Decided{}.Value)), 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: "p", Json: "p", TypeName: "float64", DeclaredTypeName: "float64", Id: 0xaf63ed4c8602096f, Kind: 11, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decided{}.P)), ElemSize: uint32(unsafe.Sizeof(Decided{}.P)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "op", Json: "op", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b05607b556600a, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decided{}.Op)), ElemSize: uint32(unsafe.Sizeof(Decided{}.Op)), 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},
}

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

View Source 
var DecisionTableFields = []TableFieldInfo{
	{Name: "id", Json: "id", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b72e07b55c3ac0, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decision{}.Id)), ElemSize: uint32(unsafe.Sizeof(Decision{}.Id)), 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: "decision_name", Json: "decision_name", TypeName: "string", DeclaredTypeName: "string", Id: 0x32e49f100f8dbef, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decision{}.DecisionName)), ElemSize: uint32(unsafe.Sizeof(Decision{}.DecisionName)), 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: "schema", Json: "schema", TypeName: "string", DeclaredTypeName: "string", Id: 0x758d17ff764667b6, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decision{}.Schema)), ElemSize: uint32(unsafe.Sizeof(Decision{}.Schema)), 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: "backend", Json: "backend", TypeName: "string", DeclaredTypeName: "string", Id: 0x54b55bf4c402eb8f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decision{}.Backend)), ElemSize: uint32(unsafe.Sizeof(Decision{}.Backend)), 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: "at", Json: "at", TypeName: "string", DeclaredTypeName: "string", Id: 0x89c4e07b545a968, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decision{}.At)), ElemSize: uint32(unsafe.Sizeof(Decision{}.At)), 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: "inputs", Json: "inputs", TypeName: "Input", DeclaredTypeName: "Input", Id: 0x499fc592a46585f8, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(Decision{}.Inputs)), ElemSize: uint32(unsafe.Sizeof(*new(InputRow))), CountOffset: (uint32(unsafe.Offsetof(Decision{}.Inputs))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 16, CookCountOffset: 48, 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: InputTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "state", Json: "state", TypeName: "string", DeclaredTypeName: "string", Id: 0xee63aaad45b1b116, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decision{}.State)), ElemSize: uint32(unsafe.Sizeof(Decision{}.State)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 56, 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: "answers", Json: "answers", TypeName: "NamedAnswer", DeclaredTypeName: "NamedAnswer", Id: 0xd7316b9dd9f8d444, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(Decision{}.Answers)), ElemSize: uint32(unsafe.Sizeof(*new(NamedAnswerRow))), CountOffset: (uint32(unsafe.Offsetof(Decision{}.Answers))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 64, CookElemSize: 56, 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: NamedAnswerTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "usage", Json: "usage", TypeName: "Usage", DeclaredTypeName: "Usage", Id: 0x1e1702714db75ac8, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Decision{}.Usage)), ElemSize: uint32(unsafe.Sizeof(Decision{}.Usage)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 80, CookElemSize: 16, CookCountOffset: 4294967295, 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: UsageTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var ErrValidation = errors.New("decidewire: 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 ExampleTableFields = []TableFieldInfo{
	{Name: "card", Json: "card", TypeName: "string", DeclaredTypeName: "string", Id: 0xb5614e90e87b455f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Example{}.Card)), ElemSize: uint32(unsafe.Sizeof(Example{}.Card)), 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: "heading", Json: "heading", TypeName: "string", DeclaredTypeName: "string", Id: 0xb128829190ca0f75, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Example{}.Heading)), ElemSize: uint32(unsafe.Sizeof(Example{}.Heading)), 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: "paths", Json: "paths", TypeName: "string", DeclaredTypeName: "string", Id: 0x3f1193a7be5f3a7f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Example{}.Paths)), ElemSize: uint32(unsafe.Sizeof(Example{}.Paths)), 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: "kind", Json: "kind", TypeName: "string", DeclaredTypeName: "string", Id: 0xef9c96d721673243, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Example{}.Kind)), ElemSize: uint32(unsafe.Sizeof(Example{}.Kind)), 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: "label", Json: "label", TypeName: "ExampleLabel", DeclaredTypeName: "ExampleLabel", Id: 0x39f7fcec8fcb623d, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Example{}.Label)), ElemSize: uint32(unsafe.Sizeof(Example{}.Label)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 3,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameExampleLabel(ExampleLabel(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := ExampleLabel(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var FailureTableFields = []TableFieldInfo{
	{Name: "pkg", Json: "pkg", TypeName: "string", DeclaredTypeName: "string", Id: 0x77a85f195659c591, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Failure{}.Pkg)), ElemSize: uint32(unsafe.Sizeof(Failure{}.Pkg)), 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: "test", Json: "test", TypeName: "string", DeclaredTypeName: "string", Id: 0xf9e6e6ef197c2b25, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Failure{}.Test)), ElemSize: uint32(unsafe.Sizeof(Failure{}.Test)), 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: "lines", Json: "lines", TypeName: "GateLine", DeclaredTypeName: "GateLine", Id: 0x5ce3f9a9f1d5001c, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(Failure{}.Lines)), ElemSize: uint32(unsafe.Sizeof(*new(GateLineRow))), CountOffset: (uint32(unsafe.Offsetof(Failure{}.Lines))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 24, 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: GateLineTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var FixedAnswerTableFields = []TableFieldInfo{
	{Name: "choice", Json: "choice", TypeName: "string", DeclaredTypeName: "string", Id: 0xc842078c742a24f6, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FixedAnswer{}.Choice)), ElemSize: uint32(unsafe.Sizeof(FixedAnswer{}.Choice)), 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: "p", Json: "p", TypeName: "OptionP", DeclaredTypeName: "OptionP", Id: 0xaf63ed4c8602096f, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(FixedAnswer{}.P)), ElemSize: uint32(unsafe.Sizeof(*new(OptionPRow))), CountOffset: (uint32(unsafe.Offsetof(FixedAnswer{}.P))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 16, CookCountOffset: 16, 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: OptionPTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "noul", Json: "noul", TypeName: "float64", DeclaredTypeName: "float64", Id: 0x3bfc10bad15ad663, Kind: 11, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FixedAnswer{}.Noul)), ElemSize: uint32(unsafe.Sizeof(FixedAnswer{}.Noul)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(FixedAnswer{}.NoulPresent)),
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 32,
		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},
}

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

View Source 
var FixedTableTableFields = []TableFieldInfo{
	{Name: "answers", Json: "answers", TypeName: "NamedFixedAnswer", DeclaredTypeName: "NamedFixedAnswer", Id: 0xd7316b9dd9f8d444, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(FixedTable{}.Answers)), ElemSize: uint32(unsafe.Sizeof(*new(NamedFixedAnswerRow))), CountOffset: (uint32(unsafe.Offsetof(FixedTable{}.Answers))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 48, 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: NamedFixedAnswerTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var FrameTableFields = []TableFieldInfo{
	{Name: "kind", Json: "kind", TypeName: "FrameKind", DeclaredTypeName: "FrameKind", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Kind)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 2,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameFrameKind(FrameKind(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := FrameKind(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "card", Json: "card", TypeName: "string", DeclaredTypeName: "string", Id: 0xb5614e90e87b455f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Card)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Card)), 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: "attempt", Json: "attempt", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x63e618bd2b303dee, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Attempt)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Attempt)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "tier", Json: "tier", TypeName: "string", DeclaredTypeName: "string", Id: 0x1e6f84ef2eb65989, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Tier)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Tier)), 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: "model", Json: "model", TypeName: "string", DeclaredTypeName: "string", Id: 0x9de543933e6e703a, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Model)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Model)), 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: "repo", Json: "repo", TypeName: "string", DeclaredTypeName: "string", Id: 0x4cac581fbfac663d, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Repo)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Repo)), 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: "base_ref", Json: "base_ref", TypeName: "string", DeclaredTypeName: "string", Id: 0xd46f4a3ebed65022, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.BaseRef)), ElemSize: uint32(unsafe.Sizeof(Frame{}.BaseRef)), 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},
	{Name: "stage_sha", Json: "stage_sha", TypeName: "string", DeclaredTypeName: "string", Id: 0xb33a2f3256e250fc, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.StageSha)), ElemSize: uint32(unsafe.Sizeof(Frame{}.StageSha)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 56, 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: "branch", Json: "branch", TypeName: "string", DeclaredTypeName: "string", Id: 0x919ec0f651278ba5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Branch)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Branch)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 64, 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: "prev_head", Json: "prev_head", TypeName: "string", DeclaredTypeName: "string", Id: 0xd6320ebd358f520b, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.PrevHead)), ElemSize: uint32(unsafe.Sizeof(Frame{}.PrevHead)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 72, 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: "prev_attempt", Json: "prev_attempt", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x230c65ac8defd086, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.PrevAttempt)), ElemSize: uint32(unsafe.Sizeof(Frame{}.PrevAttempt)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 80, CookElemSize: 8, CookCountOffset: 4294967295, 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: "why", Json: "why", TypeName: "string", DeclaredTypeName: "string", Id: 0x5ec5ea1948914a79, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Why)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Why)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 88, 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: "finding", Json: "finding", TypeName: "string", DeclaredTypeName: "string", Id: 0x35ceaba76a4aabe6, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Finding)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Finding)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 96, 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: "fix", Json: "fix", TypeName: "string", DeclaredTypeName: "string", Id: 0xdc9e7e18fec93bb8, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Fix)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Fix)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 104, 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: "review_base", Json: "review_base", TypeName: "string", DeclaredTypeName: "string", Id: 0xc1c0fb9c397f45d7, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.ReviewBase)), ElemSize: uint32(unsafe.Sizeof(Frame{}.ReviewBase)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 112, 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: "stage", Json: "stage", TypeName: "StagePath", DeclaredTypeName: "StagePath", Id: 0xee9dbaad45e3448d, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(Frame{}.Stage)), ElemSize: uint32(unsafe.Sizeof(*new(StagePathRow))), CountOffset: (uint32(unsafe.Offsetof(Frame{}.Stage))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 120, CookElemSize: 8, CookCountOffset: 128, 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: StagePathTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "recipes", Json: "recipes", TypeName: "string", DeclaredTypeName: "string", Id: 0x338684c18cd2eeb4, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.Recipes)), ElemSize: uint32(unsafe.Sizeof(Frame{}.Recipes)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 136, 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: "decide_bounce", Json: "decide_bounce", TypeName: "string", DeclaredTypeName: "string", Id: 0x364f8f1334dc227a, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.DecideBounce)), ElemSize: uint32(unsafe.Sizeof(Frame{}.DecideBounce)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 144, 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: "decide_review", Json: "decide_review", TypeName: "string", DeclaredTypeName: "string", Id: 0xb17ac487d29d6e42, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.DecideReview)), ElemSize: uint32(unsafe.Sizeof(Frame{}.DecideReview)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 152, 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: "decide_gate_flaky", Json: "decide_gate_flaky", TypeName: "string", DeclaredTypeName: "string", Id: 0x51b5e2696d2d0b97, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.DecideGateFlaky)), ElemSize: uint32(unsafe.Sizeof(Frame{}.DecideGateFlaky)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 160, 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: "decide_gate_preexisting", Json: "decide_gate_preexisting", TypeName: "string", DeclaredTypeName: "string", Id: 0x2b7d15b2bf924552, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Frame{}.DecideGatePreexisting)), ElemSize: uint32(unsafe.Sizeof(Frame{}.DecideGatePreexisting)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 168, 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},
}

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

View Source 
var GateBarsTableFields = []TableFieldInfo{
	{Name: "flaky", Json: "flaky", TypeName: "float64", DeclaredTypeName: "float64", Id: 0x177aa3a985d4593e, Kind: 11, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(GateBars{}.Flaky)), ElemSize: uint32(unsafe.Sizeof(GateBars{}.Flaky)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "pre_existing", Json: "pre_existing", TypeName: "float64", DeclaredTypeName: "float64", Id: 0x343fb63c1a0792a6, Kind: 11, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(GateBars{}.PreExisting)), ElemSize: uint32(unsafe.Sizeof(GateBars{}.PreExisting)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var GateLineTableFields = []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(GateLine{}.Text)), ElemSize: uint32(unsafe.Sizeof(GateLine{}.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},
}

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

View Source 
var ImportExportTableFields = []TableFieldInfo{
	{Name: "lines", Json: "lines", TypeName: "ImportLogLine", DeclaredTypeName: "ImportLogLine", Id: 0x5ce3f9a9f1d5001c, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(ImportExport{}.Lines)), ElemSize: uint32(unsafe.Sizeof(*new(ImportLogLineRow))), CountOffset: (uint32(unsafe.Offsetof(ImportExport{}.Lines))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 24, 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: ImportLogLineTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var ImportLogLineTableFields = []TableFieldInfo{
	{Name: "verb", Json: "verb", TypeName: "string", DeclaredTypeName: "string", Id: 0x673ebb0102773a20, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ImportLogLine{}.Verb)), ElemSize: uint32(unsafe.Sizeof(ImportLogLine{}.Verb)), 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: "answers", Json: "answers", TypeName: "JudgmentId", DeclaredTypeName: "JudgmentId", Id: 0xd7316b9dd9f8d444, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(ImportLogLine{}.Answers)), ElemSize: uint32(unsafe.Sizeof(*new(JudgmentIdRow))), CountOffset: (uint32(unsafe.Offsetof(ImportLogLine{}.Answers))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 16, 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: JudgmentIdTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var InputTableFields = []TableFieldInfo{
	{Name: "key", Json: "key", TypeName: "string", DeclaredTypeName: "string", Id: 0x3dc94a19365b10ec, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Input{}.Key)), ElemSize: uint32(unsafe.Sizeof(Input{}.Key)), 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: "value", Json: "value", TypeName: "string", DeclaredTypeName: "string", Id: 0x7ce4fd9430e80cea, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Input{}.Value)), ElemSize: uint32(unsafe.Sizeof(Input{}.Value)), 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},
}

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

View Source 
var JevAnswerTableFields = []TableFieldInfo{
	{Name: "kind", Json: "kind", TypeName: "string", DeclaredTypeName: "string", Id: 0xef9c96d721673243, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(JevAnswer{}.Kind)), ElemSize: uint32(unsafe.Sizeof(JevAnswer{}.Kind)), 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: "choice", Json: "choice", TypeName: "string", DeclaredTypeName: "string", Id: 0xc842078c742a24f6, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(JevAnswer{}.Choice)), ElemSize: uint32(unsafe.Sizeof(JevAnswer{}.Choice)), 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: "probabilities", Json: "probabilities", TypeName: "OptionP", DeclaredTypeName: "OptionP", Id: 0x5d9078ce94bba6a8, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(JevAnswer{}.Probabilities)), ElemSize: uint32(unsafe.Sizeof(*new(OptionPRow))), CountOffset: (uint32(unsafe.Offsetof(JevAnswer{}.Probabilities))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 16, CookCountOffset: 24, 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: OptionPTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "confidence", Json: "confidence", TypeName: "float64", DeclaredTypeName: "float64", Id: 0x547d54feea4643b1, Kind: 11, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(JevAnswer{}.Confidence)), ElemSize: uint32(unsafe.Sizeof(JevAnswer{}.Confidence)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(JevAnswer{}.ConfidencePresent)),
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 40,
		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: "noul", Json: "noul", TypeName: "float64", DeclaredTypeName: "float64", Id: 0x3bfc10bad15ad663, Kind: 11, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(JevAnswer{}.Noul)), ElemSize: uint32(unsafe.Sizeof(JevAnswer{}.Noul)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(JevAnswer{}.NoulPresent)),
		CookOffset: 48, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 56,
		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},
}

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

View Source 
var JevRequestTableFields = []TableFieldInfo{
	{Name: "state", Json: "state", TypeName: "string", DeclaredTypeName: "string", Id: 0xee63aaad45b1b116, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(JevRequest{}.State)), ElemSize: uint32(unsafe.Sizeof(JevRequest{}.State)), 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: "model", Json: "model", TypeName: "string", DeclaredTypeName: "string", Id: 0x9de543933e6e703a, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(JevRequest{}.Model)), ElemSize: uint32(unsafe.Sizeof(JevRequest{}.Model)), 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: "questions", Json: "questions", TypeName: "NamedQuestion", DeclaredTypeName: "NamedQuestion", Id: 0x8706e8e4197ffb42, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(JevRequest{}.Questions)), ElemSize: uint32(unsafe.Sizeof(*new(NamedQuestionRow))), CountOffset: (uint32(unsafe.Offsetof(JevRequest{}.Questions))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 40, CookCountOffset: 24, 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: NamedQuestionTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var JevResponseTableFields = []TableFieldInfo{
	{Name: "answers", Json: "answers", TypeName: "NamedJevAnswer", DeclaredTypeName: "NamedJevAnswer", Id: 0xd7316b9dd9f8d444, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(JevResponse{}.Answers)), ElemSize: uint32(unsafe.Sizeof(*new(NamedJevAnswerRow))), CountOffset: (uint32(unsafe.Offsetof(JevResponse{}.Answers))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 72, 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: NamedJevAnswerTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "usage", Json: "usage", TypeName: "Usage", DeclaredTypeName: "Usage", Id: 0x1e1702714db75ac8, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(JevResponse{}.Usage)), ElemSize: uint32(unsafe.Sizeof(JevResponse{}.Usage)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 16, CookCountOffset: 4294967295, 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: UsageTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var JudgmentIdTableFields = []TableFieldInfo{
	{Name: "id", Json: "id", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b72e07b55c3ac0, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(JudgmentId{}.Id)), ElemSize: uint32(unsafe.Sizeof(JudgmentId{}.Id)), 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},
}

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

View Source 
var LogExportTableFields = []TableFieldInfo{
	{Name: "lines", Json: "lines", TypeName: "LogLine", DeclaredTypeName: "LogLine", Id: 0x5ce3f9a9f1d5001c, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(LogExport{}.Lines)), ElemSize: uint32(unsafe.Sizeof(*new(LogLineRow))), CountOffset: (uint32(unsafe.Offsetof(LogExport{}.Lines))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 56, 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: LogLineTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var LogLineTableFields = []TableFieldInfo{
	{Name: "card", Json: "card", TypeName: "string", DeclaredTypeName: "string", Id: 0xb5614e90e87b455f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LogLine{}.Card)), ElemSize: uint32(unsafe.Sizeof(LogLine{}.Card)), 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: "primary", Json: "primary", TypeName: "string", DeclaredTypeName: "string", Id: 0xbf31137ff783e939, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LogLine{}.Primary)), ElemSize: uint32(unsafe.Sizeof(LogLine{}.Primary)), 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: "table_name", Json: "table_name", TypeName: "string", DeclaredTypeName: "string", Id: 0x6bcb6e85b78cf363, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LogLine{}.TableName)), ElemSize: uint32(unsafe.Sizeof(LogLine{}.TableName)), 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: "to", Json: "to", TypeName: "string", DeclaredTypeName: "string", Id: 0x8c83907b56ac0a4, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LogLine{}.To)), ElemSize: uint32(unsafe.Sizeof(LogLine{}.To)), 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: "removed", Json: "removed", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x10154dbd4fbc697b, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LogLine{}.Removed)), ElemSize: uint32(unsafe.Sizeof(LogLine{}.Removed)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 1, CookCountOffset: 4294967295, 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: "set", Json: "set", TypeName: "SetEntry", DeclaredTypeName: "SetEntry", Id: 0x823b87195ce20e23, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(LogLine{}.Set)), ElemSize: uint32(unsafe.Sizeof(*new(SetEntryRow))), CountOffset: (uint32(unsafe.Offsetof(LogLine{}.Set))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 16, CookCountOffset: 48, 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: SetEntryTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var NamedAnswerTableFields = []TableFieldInfo{
	{Name: "question", Json: "question", TypeName: "string", DeclaredTypeName: "string", Id: 0x9c2ca99b4d2722c5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NamedAnswer{}.Question)), ElemSize: uint32(unsafe.Sizeof(NamedAnswer{}.Question)), 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: "answer", Json: "answer", TypeName: "Answer", DeclaredTypeName: "Answer", Id: 0x67cf8608037190df, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NamedAnswer{}.Answer)), ElemSize: uint32(unsafe.Sizeof(NamedAnswer{}.Answer)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 48, CookCountOffset: 4294967295, 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: AnswerTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var NamedFixedAnswerTableFields = []TableFieldInfo{
	{Name: "question", Json: "question", TypeName: "string", DeclaredTypeName: "string", Id: 0x9c2ca99b4d2722c5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NamedFixedAnswer{}.Question)), ElemSize: uint32(unsafe.Sizeof(NamedFixedAnswer{}.Question)), 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: "answer", Json: "answer", TypeName: "FixedAnswer", DeclaredTypeName: "FixedAnswer", Id: 0x67cf8608037190df, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NamedFixedAnswer{}.Answer)), ElemSize: uint32(unsafe.Sizeof(NamedFixedAnswer{}.Answer)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 40, CookCountOffset: 4294967295, 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: FixedAnswerTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var NamedJevAnswerTableFields = []TableFieldInfo{
	{Name: "question", Json: "question", TypeName: "string", DeclaredTypeName: "string", Id: 0x9c2ca99b4d2722c5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NamedJevAnswer{}.Question)), ElemSize: uint32(unsafe.Sizeof(NamedJevAnswer{}.Question)), 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: "answer", Json: "answer", TypeName: "JevAnswer", DeclaredTypeName: "JevAnswer", Id: 0x67cf8608037190df, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NamedJevAnswer{}.Answer)), ElemSize: uint32(unsafe.Sizeof(NamedJevAnswer{}.Answer)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 64, CookCountOffset: 4294967295, 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: JevAnswerTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var NamedQuestionTableFields = []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(NamedQuestion{}.Name)), ElemSize: uint32(unsafe.Sizeof(NamedQuestion{}.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: "question", Json: "question", TypeName: "Question", DeclaredTypeName: "Question", Id: 0x9c2ca99b4d2722c5, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NamedQuestion{}.Question)), ElemSize: uint32(unsafe.Sizeof(NamedQuestion{}.Question)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 32, CookCountOffset: 4294967295, 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: QuestionTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var OptionPTableFields = []TableFieldInfo{
	{Name: "option", Json: "option", TypeName: "string", DeclaredTypeName: "string", Id: 0x3c119c726692754, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(OptionP{}.Option)), ElemSize: uint32(unsafe.Sizeof(OptionP{}.Option)), 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: "p", Json: "p", TypeName: "float64", DeclaredTypeName: "float64", Id: 0xaf63ed4c8602096f, Kind: 11, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(OptionP{}.P)), ElemSize: uint32(unsafe.Sizeof(OptionP{}.P)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var OutcomeTableFields = []TableFieldInfo{
	{Name: "id", Json: "id", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b72e07b55c3ac0, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Outcome{}.Id)), ElemSize: uint32(unsafe.Sizeof(Outcome{}.Id)), 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: "label", Json: "label", TypeName: "string", DeclaredTypeName: "string", Id: 0x39f7fcec8fcb623d, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Outcome{}.Label)), ElemSize: uint32(unsafe.Sizeof(Outcome{}.Label)), 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: "note", Json: "note", TypeName: "string", DeclaredTypeName: "string", Id: 0x3bf8fbbad1587cdd, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Outcome{}.Note)), ElemSize: uint32(unsafe.Sizeof(Outcome{}.Note)), 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: "at", Json: "at", TypeName: "string", DeclaredTypeName: "string", Id: 0x89c4e07b545a968, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Outcome{}.At)), ElemSize: uint32(unsafe.Sizeof(Outcome{}.At)), 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},
}

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

View Source 
var QuestionTableFields = []TableFieldInfo{
	{Name: "kind", Json: "kind", TypeName: "AnswerType", DeclaredTypeName: "AnswerType", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Question{}.Kind)), ElemSize: uint32(unsafe.Sizeof(Question{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 2,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameAnswerType(AnswerType(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := AnswerType(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "instructions", Json: "instructions", TypeName: "string", DeclaredTypeName: "string", Id: 0x10d72192d432fac4, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Question{}.Instructions)), ElemSize: uint32(unsafe.Sizeof(Question{}.Instructions)), 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: "criteria", Json: "criteria", TypeName: "Criterion", DeclaredTypeName: "Criterion", Id: 0xce9b64eababf7afc, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(Question{}.Criteria)), ElemSize: uint32(unsafe.Sizeof(*new(CriterionRow))), CountOffset: (uint32(unsafe.Offsetof(Question{}.Criteria))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 16, CookCountOffset: 24, 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: CriterionTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var RawRecordTableFields = []TableFieldInfo{
	{Name: "harness", Json: "harness", TypeName: "string", DeclaredTypeName: "string", Id: 0x211fcbbafe5331ab, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawRecord{}.Harness)), ElemSize: uint32(unsafe.Sizeof(RawRecord{}.Harness)), 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: "execution", Json: "execution", TypeName: "string", DeclaredTypeName: "string", Id: 0x40c5f8104d76cc15, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawRecord{}.Execution)), ElemSize: uint32(unsafe.Sizeof(RawRecord{}.Execution)), 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: "source_schema", Json: "source_schema", TypeName: "string", DeclaredTypeName: "string", Id: 0xd3c21d222f73316, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawRecord{}.SourceSchema)), ElemSize: uint32(unsafe.Sizeof(RawRecord{}.SourceSchema)), 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: "producer_version", Json: "producer_version", TypeName: "string", DeclaredTypeName: "string", Id: 0x5b096403aeadb34, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawRecord{}.ProducerVersion)), ElemSize: uint32(unsafe.Sizeof(RawRecord{}.ProducerVersion)), 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: "billing", Json: "billing", TypeName: "Billing", DeclaredTypeName: "Billing", Id: 0x4005570295afd25c, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawRecord{}.Billing)), ElemSize: uint32(unsafe.Sizeof(RawRecord{}.Billing)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 3,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameBilling(Billing(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := Billing(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "tokens", Json: "tokens", TypeName: "RawTokens", DeclaredTypeName: "RawTokens", Id: 0x93fab8f021712b13, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawRecord{}.Tokens)), ElemSize: uint32(unsafe.Sizeof(RawRecord{}.Tokens)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 96, CookCountOffset: 4294967295, 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: RawTokensTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var RawTokensTableFields = []TableFieldInfo{
	{Name: "input_tokens", Json: "input_tokens", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xb5158be5a9bbd92e, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawTokens{}.InputTokens)), ElemSize: uint32(unsafe.Sizeof(RawTokens{}.InputTokens)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(RawTokens{}.InputTokensPresent)),
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 8,
		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_tokens", Json: "output_tokens", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x72e601d58ddec77f, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawTokens{}.OutputTokens)), ElemSize: uint32(unsafe.Sizeof(RawTokens{}.OutputTokens)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(RawTokens{}.OutputTokensPresent)),
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 24,
		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: "cached_tokens", Json: "cached_tokens", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xc161e80ef0ed9236, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawTokens{}.CachedTokens)), ElemSize: uint32(unsafe.Sizeof(RawTokens{}.CachedTokens)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(RawTokens{}.CachedTokensPresent)),
		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: "cache_write_tokens", Json: "cache_write_tokens", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xd4452d66eea0a56c, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawTokens{}.CacheWriteTokens)), ElemSize: uint32(unsafe.Sizeof(RawTokens{}.CacheWriteTokens)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(RawTokens{}.CacheWriteTokensPresent)),
		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_read_tokens", Json: "cache_read_tokens", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x5e9ce08dbd7c5ed1, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawTokens{}.CacheReadTokens)), ElemSize: uint32(unsafe.Sizeof(RawTokens{}.CacheReadTokens)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(RawTokens{}.CacheReadTokensPresent)),
		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: "reasoning_tokens", Json: "reasoning_tokens", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x50b4c773e5abe4a, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawTokens{}.ReasoningTokens)), ElemSize: uint32(unsafe.Sizeof(RawTokens{}.ReasoningTokens)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(RawTokens{}.ReasoningTokensPresent)),
		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},
}

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

View Source 
var RawUsageTableFields = []TableFieldInfo{
	{Name: "version", Json: "version", TypeName: "uint32", DeclaredTypeName: "uint32", Id: 0xbb62c62c9808ea37, Kind: 8, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RawUsage{}.Version)), ElemSize: uint32(unsafe.Sizeof(RawUsage{}.Version)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 4.294967295e+09, 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: "records", Json: "records", TypeName: "RawRecord", DeclaredTypeName: "RawRecord", Id: 0xa281d6f1b14296ed, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(RawUsage{}.Records)), ElemSize: uint32(unsafe.Sizeof(*new(RawRecordRow))), CountOffset: (uint32(unsafe.Offsetof(RawUsage{}.Records))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 136, CookCountOffset: 16, 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: RawRecordTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var RecordLineTableFields = []TableFieldInfo{
	{Name: "kind", Json: "kind", TypeName: "LineKind", DeclaredTypeName: "LineKind", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RecordLine{}.Kind)), ElemSize: uint32(unsafe.Sizeof(RecordLine{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 3,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameLineKind(LineKind(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := LineKind(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "as_decision", Json: "as_decision", TypeName: "Decision", DeclaredTypeName: "Decision", Id: 0xeed7b073beff6dac, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RecordLine{}.AsDecision)), ElemSize: uint32(unsafe.Sizeof(RecordLine{}.AsDecision)), 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: 0xef92ffa038c78883,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: DecisionTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "as_outcome", Json: "as_outcome", TypeName: "Outcome", DeclaredTypeName: "Outcome", Id: 0x6eefa86635f24b32, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RecordLine{}.AsOutcome)), ElemSize: uint32(unsafe.Sizeof(RecordLine{}.AsOutcome)), 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: 0xeea0f53b4dbb2fb3,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: OutcomeTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "as_act", Json: "as_act", TypeName: "Act", DeclaredTypeName: "Act", Id: 0xaa8d7a514275e6a2, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(RecordLine{}.AsAct)), ElemSize: uint32(unsafe.Sizeof(RecordLine{}.AsAct)), 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: 0xf9c5d519a01990cb,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: ActTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source 
var SetEntryTableFields = []TableFieldInfo{
	{Name: "key", Json: "key", TypeName: "string", DeclaredTypeName: "string", Id: 0x3dc94a19365b10ec, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SetEntry{}.Key)), ElemSize: uint32(unsafe.Sizeof(SetEntry{}.Key)), 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: "value", Json: "value", TypeName: "string", DeclaredTypeName: "string", Id: 0x7ce4fd9430e80cea, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(SetEntry{}.Value)), ElemSize: uint32(unsafe.Sizeof(SetEntry{}.Value)), 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},
}

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

View Source 
var StagePathTableFields = []TableFieldInfo{
	{Name: "path", Json: "path", TypeName: "string", DeclaredTypeName: "string", Id: 0x3c52d0debd70676, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(StagePath{}.Path)), ElemSize: uint32(unsafe.Sizeof(StagePath{}.Path)), 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},
}

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

View Source 
var TableBlockByteOrder = tableBlockNativeOrder()

TableBlockByteOrder is THIS BUILD's byte order, as the prologue carries it (mas-bandwidth/schema docs/SPEC-TABLES.md §20.3): 1 little, 2 big. A block written by a build of the other order is REFUSED by BlockOpen — a fix-up path is a named obligation, not something a consumer improvises row by row.

Go has no portable compile-time byte-order constant, so it is read off the machine once, at package initialisation, and never on a per-block path.

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.

View Source 
var UsageTableFields = []TableFieldInfo{
	{Name: "input_tokens", Json: "input_tokens", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xb5158be5a9bbd92e, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Usage{}.InputTokens)), ElemSize: uint32(unsafe.Sizeof(Usage{}.InputTokens)), 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: 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_tokens", Json: "output_tokens", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x72e601d58ddec77f, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Usage{}.OutputTokens)), ElemSize: uint32(unsafe.Sizeof(Usage{}.OutputTokens)), 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: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

Functions

func ActCookFrom 

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

func ActCookMeasure 

func ActCookMeasure(value *Act, context ...TableWriteContext) int64

func ActCookMeasureReason 

func ActCookMeasureReason(value *Act, context ...TableWriteContext) (int64, error)

func ActFromJson 

func ActFromJson(builder *ActBuilder, text []byte, report *TableReport) bool

func ActLoadBody 

func ActLoadBody(r *TableReader, value *Act) bool

func ActLoadBodyRetain 

func ActLoadBodyRetain(r *TableRetainReader, value *Act) bool

func ActLoadBuilder 

func ActLoadBuilder(b *ActBuilder, wire []byte, report *TableReport) bool

func ActLoadMeasure 

func ActLoadMeasure(wire []byte) int64

func ActLoadMeasureReason 

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

func ActLoadMessageBody 

func ActLoadMessageBody(r *TableMessageReader, value *Act) bool

func ActLoadMessageBodyRetain 

func ActLoadMessageBodyRetain(r *TableRetainMessageReader, value *Act) bool

func ActMeasure 

func ActMeasure(value *Act, context ...TableWriteContext) int64

func ActMeasureBody 

func ActMeasureBody(value *Act, ids *TableIds) int64

func ActMeasureBodyRetain 

func ActMeasureBodyRetain(value *Act, ids *TableRetainIds) int64

func ActMeasureReason 

func ActMeasureReason(value *Act, context ...TableWriteContext) (int64, error)

func ActMeasureRetain 

func ActMeasureRetain(value *Act, retain *TableRetain, allocator ...TableAllocator) int64

func ActOpen 

func ActOpen(cook *ActCook, base unsafe.Pointer, length int64) bool

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

func ActReset 

func ActReset(value *Act)

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

func ActSave 

func ActSave(value *Act, buffer []byte, context ...TableWriteContext) int64

func ActSaveBody 

func ActSaveBody(w *TableWriter, value *Act) bool

func ActSaveBodyFields 

func ActSaveBodyFields(w *TableWriter, value *Act) bool

func ActSaveBodyFieldsRetain 

func ActSaveBodyFieldsRetain(w *TableRetainWriter, value *Act) bool

func ActSaveBodyRetain 

func ActSaveBodyRetain(w *TableRetainWriter, value *Act) bool

func ActSaveMessageBody 

func ActSaveMessageBody(w *TableMessageWriter, value *Act) bool

func ActSaveRetain 

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

func ActSaveText 

func ActSaveText(value *Act, context ...TableWriteContext) (string, error)

ActSaveText returns the base64 of Act'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 ActSave takes.

func ActToJson 

func ActToJson(value *Act, buffer []byte, allocator ...TableAllocator) int64

func ActToJsonMeasure 

func ActToJsonMeasure(value *Act, allocator ...TableAllocator) int64

func Announce 

func Announce(buffer []byte) int64

func AnnounceMeasure 

func AnnounceMeasure() int64

func AnnounceRead 

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

func AnswerCookFrom 

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

func AnswerCookMeasure 

func AnswerCookMeasure(value *Answer, context ...TableWriteContext) int64

func AnswerCookMeasureReason 

func AnswerCookMeasureReason(value *Answer, context ...TableWriteContext) (int64, error)

func AnswerFromJson 

func AnswerFromJson(builder *AnswerBuilder, text []byte, report *TableReport) bool

func AnswerLoadBody 

func AnswerLoadBody(r *TableReader, value *Answer) bool

func AnswerLoadBodyRetain 

func AnswerLoadBodyRetain(r *TableRetainReader, value *Answer) bool

func AnswerLoadBuilder 

func AnswerLoadBuilder(b *AnswerBuilder, wire []byte, report *TableReport) bool

func AnswerLoadMeasure 

func AnswerLoadMeasure(wire []byte) int64

func AnswerLoadMeasureReason 

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

func AnswerLoadMessageBody 

func AnswerLoadMessageBody(r *TableMessageReader, value *Answer) bool

func AnswerLoadMessageBodyRetain 

func AnswerLoadMessageBodyRetain(r *TableRetainMessageReader, value *Answer) bool

func AnswerMeasure 

func AnswerMeasure(value *Answer, context ...TableWriteContext) int64

func AnswerMeasureBody 

func AnswerMeasureBody(value *Answer, ids *TableIds) int64

func AnswerMeasureBodyRetain 

func AnswerMeasureBodyRetain(value *Answer, ids *TableRetainIds) int64

func AnswerMeasureReason 

func AnswerMeasureReason(value *Answer, context ...TableWriteContext) (int64, error)

func AnswerMeasureRetain 

func AnswerMeasureRetain(value *Answer, retain *TableRetain, allocator ...TableAllocator) int64

func AnswerOpen 

func AnswerOpen(cook *AnswerCook, base unsafe.Pointer, length int64) bool

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

func AnswerPEach 

func AnswerPEach(holder *TableList[OptionPRow], visit func(*OptionPRow) bool, arena ...*TableArena) bool

func AnswerPErase 

func AnswerPErase(arena *TableArena, holder *TableList[OptionPRow], element *OptionPRow) bool

func AnswerReset 

func AnswerReset(value *Answer)

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

func AnswerSave 

func AnswerSave(value *Answer, buffer []byte, context ...TableWriteContext) int64

func AnswerSaveBody 

func AnswerSaveBody(w *TableWriter, value *Answer) bool

func AnswerSaveBodyFields 

func AnswerSaveBodyFields(w *TableWriter, value *Answer) bool

func AnswerSaveBodyFieldsRetain 

func AnswerSaveBodyFieldsRetain(w *TableRetainWriter, value *Answer) bool

func AnswerSaveBodyRetain 

func AnswerSaveBodyRetain(w *TableRetainWriter, value *Answer) bool

func AnswerSaveMessageBody 

func AnswerSaveMessageBody(w *TableMessageWriter, value *Answer) bool

func AnswerSaveRetain 

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

func AnswerSaveText 

func AnswerSaveText(value *Answer, context ...TableWriteContext) (string, error)

AnswerSaveText returns the base64 of Answer'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 AnswerSave takes.

func AnswerToJson 

func AnswerToJson(value *Answer, buffer []byte, allocator ...TableAllocator) int64

func AnswerToJsonMeasure 

func AnswerToJsonMeasure(value *Answer, allocator ...TableAllocator) int64

func BarsBlockBegin 

func BarsBlockBegin(b *BarsBlock, s *BarsBlockStorage, c BarsCounts, refusal *TableBlockRefusal) bool

---- block fill path: begin ---- BarsBlockBegin writes only the prologue and triples, never rows or padding. Storage and all counts are checked before any byte of the extent changes.

func BarsBlockBytes 

func BarsBlockBytes(b *BarsBlock) int64

func BarsBlockOpen 

func BarsBlockOpen(block *BarsBlock, base unsafe.Pointer, bytes int64) bool

---- block fill path: begin ---- ---- block fill path: end ---- BarsBlockOpen is the bool convenience for the handle's typed Open error.

func BarsCookFrom 

func BarsCookFrom(value *Bars, buffer []byte, order TableByteOrder) bool

func BarsCookMeasure 

func BarsCookMeasure(value *Bars) int64

func BarsCookMeasureReason 

func BarsCookMeasureReason(value *Bars) (int64, error)

func BarsFromJson 

func BarsFromJson(value *Bars, text []byte, report *TableReport) bool

BarsFromJson fills one Bars from a JSON text (mas-bandwidth/schema docs/SPEC-TABLES.md §16). A nil report is allowed; every tolerance event still decides the same way.

func BarsLoad 

func BarsLoad(value *Bars, data []byte, report *TableReport) bool

func BarsLoadBody 

func BarsLoadBody(r *TableReader, value *Bars) bool

func BarsLoadBodyRetain 

func BarsLoadBodyRetain(r *TableRetainReader, value *Bars) bool

func BarsLoadMessageBody 

func BarsLoadMessageBody(r *TableMessageReader, value *Bars) bool

func BarsLoadMessageBodyRetain 

func BarsLoadMessageBodyRetain(r *TableRetainMessageReader, value *Bars) bool

func BarsLoadMessages 

func BarsLoadMessages(values []Bars, vocabulary *TableVocabulary, data []byte, report *TableReport) (int64, bool)

func BarsMeasure 

func BarsMeasure(value *Bars) int64

func BarsMeasureBody 

func BarsMeasureBody(value *Bars, ids *TableIds) int64

func BarsMeasureBodyRetain 

func BarsMeasureBodyRetain(value *Bars, ids *TableRetainIds) int64

func BarsMeasureMessages 

func BarsMeasureMessages(values []*Bars, report *TableReport) int64

func BarsMeasureReason 

func BarsMeasureReason(value *Bars) (int64, error)

func BarsOpen 

func BarsOpen(cook *BarsCook, base unsafe.Pointer, length int64) bool

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

func BarsReset 

func BarsReset(value *Bars)

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

func BarsSave 

func BarsSave(value *Bars, buffer []byte) int64

func BarsSaveBody 

func BarsSaveBody(w *TableWriter, value *Bars) bool

func BarsSaveBodyFields 

func BarsSaveBodyFields(w *TableWriter, value *Bars) bool

func BarsSaveBodyFieldsRetain 

func BarsSaveBodyFieldsRetain(w *TableRetainWriter, value *Bars) bool

func BarsSaveBodyRetain 

func BarsSaveBodyRetain(w *TableRetainWriter, value *Bars) bool

func BarsSaveMessageBody 

func BarsSaveMessageBody(w *TableMessageWriter, value *Bars) bool

func BarsSaveMessages 

func BarsSaveMessages(values []*Bars, buffer []byte, report *TableReport) int64

func BarsSaveText 

func BarsSaveText(value *Bars) (string, error)

BarsSaveText returns the base64 of Bars'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.

func BarsToJson 

func BarsToJson(value *Bars, buffer []byte) int64

BarsToJson writes Bars's JSON text into the caller's slice and returns the bytes written — exactly BarsToJsonMeasure's answer — or -1 when it is short.

func BarsToJsonMeasure 

func BarsToJsonMeasure(value *Bars) int64

BarsToJsonMeasure is the exact size of Bars's JSON text, writing nothing.

func ChosenCookFrom 

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

func ChosenCookMeasure 

func ChosenCookMeasure(value *Chosen, context ...TableWriteContext) int64

func ChosenCookMeasureReason 

func ChosenCookMeasureReason(value *Chosen, context ...TableWriteContext) (int64, error)

func ChosenFromJson 

func ChosenFromJson(builder *ChosenBuilder, text []byte, report *TableReport) bool

func ChosenLoadBody 

func ChosenLoadBody(r *TableReader, value *Chosen) bool

func ChosenLoadBodyRetain 

func ChosenLoadBodyRetain(r *TableRetainReader, value *Chosen) bool

func ChosenLoadBuilder 

func ChosenLoadBuilder(b *ChosenBuilder, wire []byte, report *TableReport) bool

func ChosenLoadMeasure 

func ChosenLoadMeasure(wire []byte) int64

func ChosenLoadMeasureReason 

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

func ChosenLoadMessageBody 

func ChosenLoadMessageBody(r *TableMessageReader, value *Chosen) bool

func ChosenLoadMessageBodyRetain 

func ChosenLoadMessageBodyRetain(r *TableRetainMessageReader, value *Chosen) bool

func ChosenMeasure 

func ChosenMeasure(value *Chosen, context ...TableWriteContext) int64

func ChosenMeasureBody 

func ChosenMeasureBody(value *Chosen, ids *TableIds) int64

func ChosenMeasureBodyRetain 

func ChosenMeasureBodyRetain(value *Chosen, ids *TableRetainIds) int64

func ChosenMeasureReason 

func ChosenMeasureReason(value *Chosen, context ...TableWriteContext) (int64, error)

func ChosenMeasureRetain 

func ChosenMeasureRetain(value *Chosen, retain *TableRetain, allocator ...TableAllocator) int64

func ChosenOpen 

func ChosenOpen(cook *ChosenCook, base unsafe.Pointer, length int64) bool

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

func ChosenReset 

func ChosenReset(value *Chosen)

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

func ChosenSave 

func ChosenSave(value *Chosen, buffer []byte, context ...TableWriteContext) int64

func ChosenSaveBody 

func ChosenSaveBody(w *TableWriter, value *Chosen) bool

func ChosenSaveBodyFields 

func ChosenSaveBodyFields(w *TableWriter, value *Chosen) bool

func ChosenSaveBodyFieldsRetain 

func ChosenSaveBodyFieldsRetain(w *TableRetainWriter, value *Chosen) bool

func ChosenSaveBodyRetain 

func ChosenSaveBodyRetain(w *TableRetainWriter, value *Chosen) bool

func ChosenSaveMessageBody 

func ChosenSaveMessageBody(w *TableMessageWriter, value *Chosen) bool

func ChosenSaveRetain 

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

func ChosenSaveText 

func ChosenSaveText(value *Chosen, context ...TableWriteContext) (string, error)

ChosenSaveText returns the base64 of Chosen'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 ChosenSave takes.

func ChosenToJson 

func ChosenToJson(value *Chosen, buffer []byte, allocator ...TableAllocator) int64

func ChosenToJsonMeasure 

func ChosenToJsonMeasure(value *Chosen, allocator ...TableAllocator) int64

func ClusterCardCookFrom 

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

func ClusterCardCookMeasure 

func ClusterCardCookMeasure(value *ClusterCard, context ...TableWriteContext) int64

func ClusterCardCookMeasureReason 

func ClusterCardCookMeasureReason(value *ClusterCard, context ...TableWriteContext) (int64, error)

func ClusterCardFromJson 

func ClusterCardFromJson(builder *ClusterCardBuilder, text []byte, report *TableReport) bool

func ClusterCardLoadBody 

func ClusterCardLoadBody(r *TableReader, value *ClusterCard) bool

func ClusterCardLoadBodyRetain 

func ClusterCardLoadBodyRetain(r *TableRetainReader, value *ClusterCard) bool

func ClusterCardLoadBuilder 

func ClusterCardLoadBuilder(b *ClusterCardBuilder, wire []byte, report *TableReport) bool

func ClusterCardLoadMeasure 

func ClusterCardLoadMeasure(wire []byte) int64

func ClusterCardLoadMeasureReason 

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

func ClusterCardLoadMessageBody 

func ClusterCardLoadMessageBody(r *TableMessageReader, value *ClusterCard) bool

func ClusterCardLoadMessageBodyRetain 

func ClusterCardLoadMessageBodyRetain(r *TableRetainMessageReader, value *ClusterCard) bool

func ClusterCardMeasure 

func ClusterCardMeasure(value *ClusterCard, context ...TableWriteContext) int64

func ClusterCardMeasureBody 

func ClusterCardMeasureBody(value *ClusterCard, ids *TableIds) int64

func ClusterCardMeasureBodyRetain 

func ClusterCardMeasureBodyRetain(value *ClusterCard, ids *TableRetainIds) int64

func ClusterCardMeasureReason 

func ClusterCardMeasureReason(value *ClusterCard, context ...TableWriteContext) (int64, error)

func ClusterCardMeasureRetain 

func ClusterCardMeasureRetain(value *ClusterCard, retain *TableRetain, allocator ...TableAllocator) int64

func ClusterCardOpen 

func ClusterCardOpen(cook *ClusterCardCook, base unsafe.Pointer, length int64) bool

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

func ClusterCardReset 

func ClusterCardReset(value *ClusterCard)

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

func ClusterCardSave 

func ClusterCardSave(value *ClusterCard, buffer []byte, context ...TableWriteContext) int64

func ClusterCardSaveBody 

func ClusterCardSaveBody(w *TableWriter, value *ClusterCard) bool

func ClusterCardSaveBodyFields 

func ClusterCardSaveBodyFields(w *TableWriter, value *ClusterCard) bool

func ClusterCardSaveBodyFieldsRetain 

func ClusterCardSaveBodyFieldsRetain(w *TableRetainWriter, value *ClusterCard) bool

func ClusterCardSaveBodyRetain 

func ClusterCardSaveBodyRetain(w *TableRetainWriter, value *ClusterCard) bool

func ClusterCardSaveMessageBody 

func ClusterCardSaveMessageBody(w *TableMessageWriter, value *ClusterCard) bool

func ClusterCardSaveRetain 

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

func ClusterCardSaveText 

func ClusterCardSaveText(value *ClusterCard, context ...TableWriteContext) (string, error)

ClusterCardSaveText returns the base64 of ClusterCard'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 ClusterCardSave takes.

func ClusterCardToJson 

func ClusterCardToJson(value *ClusterCard, buffer []byte, allocator ...TableAllocator) int64

func ClusterCardToJsonMeasure 

func ClusterCardToJsonMeasure(value *ClusterCard, allocator ...TableAllocator) int64

func ClusterCardsEach 

func ClusterCardsEach(holder *TableList[ClusterCardRow], visit func(*ClusterCardRow) bool, arena ...*TableArena) bool

func ClusterCardsErase 

func ClusterCardsErase(arena *TableArena, holder *TableList[ClusterCardRow], element *ClusterCardRow) bool

func ClusterCookFrom 

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

func ClusterCookMeasure 

func ClusterCookMeasure(value *Cluster, context ...TableWriteContext) int64

func ClusterCookMeasureReason 

func ClusterCookMeasureReason(value *Cluster, context ...TableWriteContext) (int64, error)

func ClusterFromJson 

func ClusterFromJson(builder *ClusterBuilder, text []byte, report *TableReport) bool

func ClusterLoadBody 

func ClusterLoadBody(r *TableReader, value *Cluster) bool

func ClusterLoadBodyRetain 

func ClusterLoadBodyRetain(r *TableRetainReader, value *Cluster) bool

func ClusterLoadBuilder 

func ClusterLoadBuilder(b *ClusterBuilder, wire []byte, report *TableReport) bool

func ClusterLoadMeasure 

func ClusterLoadMeasure(wire []byte) int64

func ClusterLoadMeasureReason 

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

func ClusterLoadMessageBody 

func ClusterLoadMessageBody(r *TableMessageReader, value *Cluster) bool

func ClusterLoadMessageBodyRetain 

func ClusterLoadMessageBodyRetain(r *TableRetainMessageReader, value *Cluster) bool

func ClusterMeasure 

func ClusterMeasure(value *Cluster, context ...TableWriteContext) int64

func ClusterMeasureBody 

func ClusterMeasureBody(value *Cluster, ids *TableIds) int64

func ClusterMeasureBodyRetain 

func ClusterMeasureBodyRetain(value *Cluster, ids *TableRetainIds) int64

func ClusterMeasureReason 

func ClusterMeasureReason(value *Cluster, context ...TableWriteContext) (int64, error)

func ClusterMeasureRetain 

func ClusterMeasureRetain(value *Cluster, retain *TableRetain, allocator ...TableAllocator) int64

func ClusterOpen 

func ClusterOpen(cook *ClusterCook, base unsafe.Pointer, length int64) bool

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

func ClusterReset 

func ClusterReset(value *Cluster)

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

func ClusterSave 

func ClusterSave(value *Cluster, buffer []byte, context ...TableWriteContext) int64

func ClusterSaveBody 

func ClusterSaveBody(w *TableWriter, value *Cluster) bool

func ClusterSaveBodyFields 

func ClusterSaveBodyFields(w *TableWriter, value *Cluster) bool

func ClusterSaveBodyFieldsRetain 

func ClusterSaveBodyFieldsRetain(w *TableRetainWriter, value *Cluster) bool

func ClusterSaveBodyRetain 

func ClusterSaveBodyRetain(w *TableRetainWriter, value *Cluster) bool

func ClusterSaveMessageBody 

func ClusterSaveMessageBody(w *TableMessageWriter, value *Cluster) bool

func ClusterSaveRetain 

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

func ClusterSaveText 

func ClusterSaveText(value *Cluster, context ...TableWriteContext) (string, error)

ClusterSaveText returns the base64 of Cluster'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 ClusterSave takes.

func ClusterToJson 

func ClusterToJson(value *Cluster, buffer []byte, allocator ...TableAllocator) int64

func ClusterToJsonMeasure 

func ClusterToJsonMeasure(value *Cluster, allocator ...TableAllocator) int64

func CriterionCookFrom 

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

func CriterionCookMeasure 

func CriterionCookMeasure(value *Criterion, context ...TableWriteContext) int64

func CriterionCookMeasureReason 

func CriterionCookMeasureReason(value *Criterion, context ...TableWriteContext) (int64, error)

func CriterionFromJson 

func CriterionFromJson(builder *CriterionBuilder, text []byte, report *TableReport) bool

func CriterionLoadBody 

func CriterionLoadBody(r *TableReader, value *Criterion) bool

func CriterionLoadBodyRetain 

func CriterionLoadBodyRetain(r *TableRetainReader, value *Criterion) bool

func CriterionLoadBuilder 

func CriterionLoadBuilder(b *CriterionBuilder, wire []byte, report *TableReport) bool

func CriterionLoadMeasure 

func CriterionLoadMeasure(wire []byte) int64

func CriterionLoadMeasureReason 

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

func CriterionLoadMessageBody 

func CriterionLoadMessageBody(r *TableMessageReader, value *Criterion) bool

func CriterionLoadMessageBodyRetain 

func CriterionLoadMessageBodyRetain(r *TableRetainMessageReader, value *Criterion) bool

func CriterionMeasure 

func CriterionMeasure(value *Criterion, context ...TableWriteContext) int64

func CriterionMeasureBody 

func CriterionMeasureBody(value *Criterion, ids *TableIds) int64

func CriterionMeasureBodyRetain 

func CriterionMeasureBodyRetain(value *Criterion, ids *TableRetainIds) int64

func CriterionMeasureReason 

func CriterionMeasureReason(value *Criterion, context ...TableWriteContext) (int64, error)

func CriterionMeasureRetain 

func CriterionMeasureRetain(value *Criterion, retain *TableRetain, allocator ...TableAllocator) int64

func CriterionOpen 

func CriterionOpen(cook *CriterionCook, base unsafe.Pointer, length int64) bool

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

func CriterionReset 

func CriterionReset(value *Criterion)

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

func CriterionSave 

func CriterionSave(value *Criterion, buffer []byte, context ...TableWriteContext) int64

func CriterionSaveBody 

func CriterionSaveBody(w *TableWriter, value *Criterion) bool

func CriterionSaveBodyFields 

func CriterionSaveBodyFields(w *TableWriter, value *Criterion) bool

func CriterionSaveBodyFieldsRetain 

func CriterionSaveBodyFieldsRetain(w *TableRetainWriter, value *Criterion) bool

func CriterionSaveBodyRetain 

func CriterionSaveBodyRetain(w *TableRetainWriter, value *Criterion) bool

func CriterionSaveMessageBody 

func CriterionSaveMessageBody(w *TableMessageWriter, value *Criterion) bool

func CriterionSaveRetain 

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

func CriterionSaveText 

func CriterionSaveText(value *Criterion, context ...TableWriteContext) (string, error)

CriterionSaveText returns the base64 of Criterion'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 CriterionSave takes.

func CriterionToJson 

func CriterionToJson(value *Criterion, buffer []byte, allocator ...TableAllocator) int64

func CriterionToJsonMeasure 

func CriterionToJsonMeasure(value *Criterion, allocator ...TableAllocator) int64

func DecideSchemaCookFrom 

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

func DecideSchemaCookMeasure 

func DecideSchemaCookMeasure(value *DecideSchema, context ...TableWriteContext) int64

func DecideSchemaCookMeasureReason 

func DecideSchemaCookMeasureReason(value *DecideSchema, context ...TableWriteContext) (int64, error)

func DecideSchemaFromJson 

func DecideSchemaFromJson(builder *DecideSchemaBuilder, text []byte, report *TableReport) bool

func DecideSchemaLoadBody 

func DecideSchemaLoadBody(r *TableReader, value *DecideSchema) bool

func DecideSchemaLoadBodyRetain 

func DecideSchemaLoadBodyRetain(r *TableRetainReader, value *DecideSchema) bool

func DecideSchemaLoadBuilder 

func DecideSchemaLoadBuilder(b *DecideSchemaBuilder, wire []byte, report *TableReport) bool

func DecideSchemaLoadMeasure 

func DecideSchemaLoadMeasure(wire []byte) int64

func DecideSchemaLoadMeasureReason 

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

func DecideSchemaLoadMessageBody 

func DecideSchemaLoadMessageBody(r *TableMessageReader, value *DecideSchema) bool

func DecideSchemaLoadMessageBodyRetain 

func DecideSchemaLoadMessageBodyRetain(r *TableRetainMessageReader, value *DecideSchema) bool

func DecideSchemaMeasure 

func DecideSchemaMeasure(value *DecideSchema, context ...TableWriteContext) int64

func DecideSchemaMeasureBody 

func DecideSchemaMeasureBody(value *DecideSchema, ids *TableIds) int64

func DecideSchemaMeasureBodyRetain 

func DecideSchemaMeasureBodyRetain(value *DecideSchema, ids *TableRetainIds) int64

func DecideSchemaMeasureReason 

func DecideSchemaMeasureReason(value *DecideSchema, context ...TableWriteContext) (int64, error)

func DecideSchemaMeasureRetain 

func DecideSchemaMeasureRetain(value *DecideSchema, retain *TableRetain, allocator ...TableAllocator) int64

func DecideSchemaOpen 

func DecideSchemaOpen(cook *DecideSchemaCook, base unsafe.Pointer, length int64) bool

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

func DecideSchemaQuestionsEach 

func DecideSchemaQuestionsEach(holder *TableList[NamedQuestionRow], visit func(*NamedQuestionRow) bool, arena ...*TableArena) bool

func DecideSchemaQuestionsErase 

func DecideSchemaQuestionsErase(arena *TableArena, holder *TableList[NamedQuestionRow], element *NamedQuestionRow) bool

func DecideSchemaReset 

func DecideSchemaReset(value *DecideSchema)

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

func DecideSchemaSave 

func DecideSchemaSave(value *DecideSchema, buffer []byte, context ...TableWriteContext) int64

func DecideSchemaSaveBody 

func DecideSchemaSaveBody(w *TableWriter, value *DecideSchema) bool

func DecideSchemaSaveBodyFields 

func DecideSchemaSaveBodyFields(w *TableWriter, value *DecideSchema) bool

func DecideSchemaSaveBodyFieldsRetain 

func DecideSchemaSaveBodyFieldsRetain(w *TableRetainWriter, value *DecideSchema) bool

func DecideSchemaSaveBodyRetain 

func DecideSchemaSaveBodyRetain(w *TableRetainWriter, value *DecideSchema) bool

func DecideSchemaSaveMessageBody 

func DecideSchemaSaveMessageBody(w *TableMessageWriter, value *DecideSchema) bool

func DecideSchemaSaveRetain 

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

func DecideSchemaSaveText 

func DecideSchemaSaveText(value *DecideSchema, context ...TableWriteContext) (string, error)

DecideSchemaSaveText returns the base64 of DecideSchema'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 DecideSchemaSave takes.

func DecideSchemaToJson 

func DecideSchemaToJson(value *DecideSchema, buffer []byte, allocator ...TableAllocator) int64

func DecideSchemaToJsonMeasure 

func DecideSchemaToJsonMeasure(value *DecideSchema, allocator ...TableAllocator) int64

func DecidedCookFrom 

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

func DecidedCookMeasure 

func DecidedCookMeasure(value *Decided, context ...TableWriteContext) int64

func DecidedCookMeasureReason 

func DecidedCookMeasureReason(value *Decided, context ...TableWriteContext) (int64, error)

func DecidedFromJson 

func DecidedFromJson(builder *DecidedBuilder, text []byte, report *TableReport) bool

func DecidedLoadBody 

func DecidedLoadBody(r *TableReader, value *Decided) bool

func DecidedLoadBodyRetain 

func DecidedLoadBodyRetain(r *TableRetainReader, value *Decided) bool

func DecidedLoadBuilder 

func DecidedLoadBuilder(b *DecidedBuilder, wire []byte, report *TableReport) bool

func DecidedLoadMeasure 

func DecidedLoadMeasure(wire []byte) int64

func DecidedLoadMeasureReason 

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

func DecidedLoadMessageBody 

func DecidedLoadMessageBody(r *TableMessageReader, value *Decided) bool

func DecidedLoadMessageBodyRetain 

func DecidedLoadMessageBodyRetain(r *TableRetainMessageReader, value *Decided) bool

func DecidedMeasure 

func DecidedMeasure(value *Decided, context ...TableWriteContext) int64

func DecidedMeasureBody 

func DecidedMeasureBody(value *Decided, ids *TableIds) int64

func DecidedMeasureBodyRetain 

func DecidedMeasureBodyRetain(value *Decided, ids *TableRetainIds) int64

func DecidedMeasureReason 

func DecidedMeasureReason(value *Decided, context ...TableWriteContext) (int64, error)

func DecidedMeasureRetain 

func DecidedMeasureRetain(value *Decided, retain *TableRetain, allocator ...TableAllocator) int64

func DecidedOpen 

func DecidedOpen(cook *DecidedCook, base unsafe.Pointer, length int64) bool

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

func DecidedReset 

func DecidedReset(value *Decided)

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

func DecidedSave 

func DecidedSave(value *Decided, buffer []byte, context ...TableWriteContext) int64

func DecidedSaveBody 

func DecidedSaveBody(w *TableWriter, value *Decided) bool

func DecidedSaveBodyFields 

func DecidedSaveBodyFields(w *TableWriter, value *Decided) bool

func DecidedSaveBodyFieldsRetain 

func DecidedSaveBodyFieldsRetain(w *TableRetainWriter, value *Decided) bool

func DecidedSaveBodyRetain 

func DecidedSaveBodyRetain(w *TableRetainWriter, value *Decided) bool

func DecidedSaveMessageBody 

func DecidedSaveMessageBody(w *TableMessageWriter, value *Decided) bool

func DecidedSaveRetain 

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

func DecidedSaveText 

func DecidedSaveText(value *Decided, context ...TableWriteContext) (string, error)

DecidedSaveText returns the base64 of Decided'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 DecidedSave takes.

func DecidedToJson 

func DecidedToJson(value *Decided, buffer []byte, allocator ...TableAllocator) int64

func DecidedToJsonMeasure 

func DecidedToJsonMeasure(value *Decided, allocator ...TableAllocator) int64

func DecisionAnswersEach 

func DecisionAnswersEach(holder *TableList[NamedAnswerRow], visit func(*NamedAnswerRow) bool, arena ...*TableArena) bool

func DecisionAnswersErase 

func DecisionAnswersErase(arena *TableArena, holder *TableList[NamedAnswerRow], element *NamedAnswerRow) bool

func DecisionCookFrom 

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

func DecisionCookMeasure 

func DecisionCookMeasure(value *Decision, context ...TableWriteContext) int64

func DecisionCookMeasureReason 

func DecisionCookMeasureReason(value *Decision, context ...TableWriteContext) (int64, error)

func DecisionFromJson 

func DecisionFromJson(builder *DecisionBuilder, text []byte, report *TableReport) bool

func DecisionInputsEach 

func DecisionInputsEach(holder *TableList[InputRow], visit func(*InputRow) bool, arena ...*TableArena) bool

func DecisionInputsErase 

func DecisionInputsErase(arena *TableArena, holder *TableList[InputRow], element *InputRow) bool

func DecisionLoadBody 

func DecisionLoadBody(r *TableReader, value *Decision) bool

func DecisionLoadBodyRetain 

func DecisionLoadBodyRetain(r *TableRetainReader, value *Decision) bool

func DecisionLoadBuilder 

func DecisionLoadBuilder(b *DecisionBuilder, wire []byte, report *TableReport) bool

func DecisionLoadMeasure 

func DecisionLoadMeasure(wire []byte) int64

func DecisionLoadMeasureReason 

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

func DecisionLoadMessageBody 

func DecisionLoadMessageBody(r *TableMessageReader, value *Decision) bool

func DecisionLoadMessageBodyRetain 

func DecisionLoadMessageBodyRetain(r *TableRetainMessageReader, value *Decision) bool

func DecisionMeasure 

func DecisionMeasure(value *Decision, context ...TableWriteContext) int64

func DecisionMeasureBody 

func DecisionMeasureBody(value *Decision, ids *TableIds) int64

func DecisionMeasureBodyRetain 

func DecisionMeasureBodyRetain(value *Decision, ids *TableRetainIds) int64

func DecisionMeasureReason 

func DecisionMeasureReason(value *Decision, context ...TableWriteContext) (int64, error)

func DecisionMeasureRetain 

func DecisionMeasureRetain(value *Decision, retain *TableRetain, allocator ...TableAllocator) int64

func DecisionOpen 

func DecisionOpen(cook *DecisionCook, base unsafe.Pointer, length int64) bool

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

func DecisionReset 

func DecisionReset(value *Decision)

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

func DecisionSave 

func DecisionSave(value *Decision, buffer []byte, context ...TableWriteContext) int64

func DecisionSaveBody 

func DecisionSaveBody(w *TableWriter, value *Decision) bool

func DecisionSaveBodyFields 

func DecisionSaveBodyFields(w *TableWriter, value *Decision) bool

func DecisionSaveBodyFieldsRetain 

func DecisionSaveBodyFieldsRetain(w *TableRetainWriter, value *Decision) bool

func DecisionSaveBodyRetain 

func DecisionSaveBodyRetain(w *TableRetainWriter, value *Decision) bool

func DecisionSaveMessageBody 

func DecisionSaveMessageBody(w *TableMessageWriter, value *Decision) bool

func DecisionSaveRetain 

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

func DecisionSaveText 

func DecisionSaveText(value *Decision, context ...TableWriteContext) (string, error)

DecisionSaveText returns the base64 of Decision'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 DecisionSave takes.

func DecisionToJson 

func DecisionToJson(value *Decision, buffer []byte, allocator ...TableAllocator) int64

func DecisionToJsonMeasure 

func DecisionToJsonMeasure(value *Decision, allocator ...TableAllocator) int64

func EnumNameAnswerType 

func EnumNameAnswerType(value AnswerType) string

EnumNameAnswerType: debug/log/tooling name for any AnswerType wire value — out-of-set values (wire-legal up to the declared max) name as "???"

func EnumNameBilling 

func EnumNameBilling(value Billing) string

EnumNameBilling: debug/log/tooling name for any Billing wire value — out-of-set values (wire-legal up to the declared max) name as "???"

func EnumNameExampleLabel 

func EnumNameExampleLabel(value ExampleLabel) string

EnumNameExampleLabel: debug/log/tooling name for any ExampleLabel wire value — out-of-set values (wire-legal up to the declared max) name as "???"

func EnumNameFrameKind 

func EnumNameFrameKind(value FrameKind) string

EnumNameFrameKind: debug/log/tooling name for any FrameKind wire value — out-of-set values (wire-legal up to the declared max) name as "???"

func EnumNameLineKind 

func EnumNameLineKind(value LineKind) string

EnumNameLineKind: debug/log/tooling name for any LineKind wire value — out-of-set values (wire-legal up to the declared max) name as "???"

func ExampleCookFrom 

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

func ExampleCookMeasure 

func ExampleCookMeasure(value *Example, context ...TableWriteContext) int64

func ExampleCookMeasureReason 

func ExampleCookMeasureReason(value *Example, context ...TableWriteContext) (int64, error)

func ExampleFromJson 

func ExampleFromJson(builder *ExampleBuilder, text []byte, report *TableReport) bool

func ExampleLoadBody 

func ExampleLoadBody(r *TableReader, value *Example) bool

func ExampleLoadBodyRetain 

func ExampleLoadBodyRetain(r *TableRetainReader, value *Example) bool

func ExampleLoadBuilder 

func ExampleLoadBuilder(b *ExampleBuilder, wire []byte, report *TableReport) bool

func ExampleLoadMeasure 

func ExampleLoadMeasure(wire []byte) int64

func ExampleLoadMeasureReason 

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

func ExampleLoadMessageBody 

func ExampleLoadMessageBody(r *TableMessageReader, value *Example) bool

func ExampleLoadMessageBodyRetain 

func ExampleLoadMessageBodyRetain(r *TableRetainMessageReader, value *Example) bool

func ExampleMeasure 

func ExampleMeasure(value *Example, context ...TableWriteContext) int64

func ExampleMeasureBody 

func ExampleMeasureBody(value *Example, ids *TableIds) int64

func ExampleMeasureBodyRetain 

func ExampleMeasureBodyRetain(value *Example, ids *TableRetainIds) int64

func ExampleMeasureReason 

func ExampleMeasureReason(value *Example, context ...TableWriteContext) (int64, error)

func ExampleMeasureRetain 

func ExampleMeasureRetain(value *Example, retain *TableRetain, allocator ...TableAllocator) int64

func ExampleOpen 

func ExampleOpen(cook *ExampleCook, base unsafe.Pointer, length int64) bool

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

func ExampleReset 

func ExampleReset(value *Example)

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

func ExampleSave 

func ExampleSave(value *Example, buffer []byte, context ...TableWriteContext) int64

func ExampleSaveBody 

func ExampleSaveBody(w *TableWriter, value *Example) bool

func ExampleSaveBodyFields 

func ExampleSaveBodyFields(w *TableWriter, value *Example) bool

func ExampleSaveBodyFieldsRetain 

func ExampleSaveBodyFieldsRetain(w *TableRetainWriter, value *Example) bool

func ExampleSaveBodyRetain 

func ExampleSaveBodyRetain(w *TableRetainWriter, value *Example) bool

func ExampleSaveMessageBody 

func ExampleSaveMessageBody(w *TableMessageWriter, value *Example) bool

func ExampleSaveRetain 

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

func ExampleSaveText 

func ExampleSaveText(value *Example, context ...TableWriteContext) (string, error)

ExampleSaveText returns the base64 of Example'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 ExampleSave takes.

func ExampleToJson 

func ExampleToJson(value *Example, buffer []byte, allocator ...TableAllocator) int64

func ExampleToJsonMeasure 

func ExampleToJsonMeasure(value *Example, allocator ...TableAllocator) int64

func FailureCookFrom 

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

func FailureCookMeasure 

func FailureCookMeasure(value *Failure, context ...TableWriteContext) int64

func FailureCookMeasureReason 

func FailureCookMeasureReason(value *Failure, context ...TableWriteContext) (int64, error)

func FailureFromJson 

func FailureFromJson(builder *FailureBuilder, text []byte, report *TableReport) bool

func FailureLinesEach 

func FailureLinesEach(holder *TableList[GateLineRow], visit func(*GateLineRow) bool, arena ...*TableArena) bool

func FailureLinesErase 

func FailureLinesErase(arena *TableArena, holder *TableList[GateLineRow], element *GateLineRow) bool

func FailureLoadBody 

func FailureLoadBody(r *TableReader, value *Failure) bool

func FailureLoadBodyRetain 

func FailureLoadBodyRetain(r *TableRetainReader, value *Failure) bool

func FailureLoadBuilder 

func FailureLoadBuilder(b *FailureBuilder, wire []byte, report *TableReport) bool

func FailureLoadMeasure 

func FailureLoadMeasure(wire []byte) int64

func FailureLoadMeasureReason 

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

func FailureLoadMessageBody 

func FailureLoadMessageBody(r *TableMessageReader, value *Failure) bool

func FailureLoadMessageBodyRetain 

func FailureLoadMessageBodyRetain(r *TableRetainMessageReader, value *Failure) bool

func FailureMeasure 

func FailureMeasure(value *Failure, context ...TableWriteContext) int64

func FailureMeasureBody 

func FailureMeasureBody(value *Failure, ids *TableIds) int64

func FailureMeasureBodyRetain 

func FailureMeasureBodyRetain(value *Failure, ids *TableRetainIds) int64

func FailureMeasureReason 

func FailureMeasureReason(value *Failure, context ...TableWriteContext) (int64, error)

func FailureMeasureRetain 

func FailureMeasureRetain(value *Failure, retain *TableRetain, allocator ...TableAllocator) int64

func FailureOpen 

func FailureOpen(cook *FailureCook, base unsafe.Pointer, length int64) bool

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

func FailureReset 

func FailureReset(value *Failure)

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

func FailureSave 

func FailureSave(value *Failure, buffer []byte, context ...TableWriteContext) int64

func FailureSaveBody 

func FailureSaveBody(w *TableWriter, value *Failure) bool

func FailureSaveBodyFields 

func FailureSaveBodyFields(w *TableWriter, value *Failure) bool

func FailureSaveBodyFieldsRetain 

func FailureSaveBodyFieldsRetain(w *TableRetainWriter, value *Failure) bool

func FailureSaveBodyRetain 

func FailureSaveBodyRetain(w *TableRetainWriter, value *Failure) bool

func FailureSaveMessageBody 

func FailureSaveMessageBody(w *TableMessageWriter, value *Failure) bool

func FailureSaveRetain 

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

func FailureSaveText 

func FailureSaveText(value *Failure, context ...TableWriteContext) (string, error)

FailureSaveText returns the base64 of Failure'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 FailureSave takes.

func FailureToJson 

func FailureToJson(value *Failure, buffer []byte, allocator ...TableAllocator) int64

func FailureToJsonMeasure 

func FailureToJsonMeasure(value *Failure, allocator ...TableAllocator) int64

func FixedAnswerCookFrom 

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

func FixedAnswerCookMeasure 

func FixedAnswerCookMeasure(value *FixedAnswer, context ...TableWriteContext) int64

func FixedAnswerCookMeasureReason 

func FixedAnswerCookMeasureReason(value *FixedAnswer, context ...TableWriteContext) (int64, error)

func FixedAnswerFromJson 

func FixedAnswerFromJson(builder *FixedAnswerBuilder, text []byte, report *TableReport) bool

func FixedAnswerLoadBody 

func FixedAnswerLoadBody(r *TableReader, value *FixedAnswer) bool

func FixedAnswerLoadBodyRetain 

func FixedAnswerLoadBodyRetain(r *TableRetainReader, value *FixedAnswer) bool

func FixedAnswerLoadBuilder 

func FixedAnswerLoadBuilder(b *FixedAnswerBuilder, wire []byte, report *TableReport) bool

func FixedAnswerLoadMeasure 

func FixedAnswerLoadMeasure(wire []byte) int64

func FixedAnswerLoadMeasureReason 

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

func FixedAnswerLoadMessageBody 

func FixedAnswerLoadMessageBody(r *TableMessageReader, value *FixedAnswer) bool

func FixedAnswerLoadMessageBodyRetain 

func FixedAnswerLoadMessageBodyRetain(r *TableRetainMessageReader, value *FixedAnswer) bool

func FixedAnswerMeasure 

func FixedAnswerMeasure(value *FixedAnswer, context ...TableWriteContext) int64

func FixedAnswerMeasureBody 

func FixedAnswerMeasureBody(value *FixedAnswer, ids *TableIds) int64

func FixedAnswerMeasureBodyRetain 

func FixedAnswerMeasureBodyRetain(value *FixedAnswer, ids *TableRetainIds) int64

func FixedAnswerMeasureReason 

func FixedAnswerMeasureReason(value *FixedAnswer, context ...TableWriteContext) (int64, error)

func FixedAnswerMeasureRetain 

func FixedAnswerMeasureRetain(value *FixedAnswer, retain *TableRetain, allocator ...TableAllocator) int64

func FixedAnswerOpen 

func FixedAnswerOpen(cook *FixedAnswerCook, base unsafe.Pointer, length int64) bool

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

func FixedAnswerPEach 

func FixedAnswerPEach(holder *TableList[OptionPRow], visit func(*OptionPRow) bool, arena ...*TableArena) bool

func FixedAnswerPErase 

func FixedAnswerPErase(arena *TableArena, holder *TableList[OptionPRow], element *OptionPRow) bool

func FixedAnswerReset 

func FixedAnswerReset(value *FixedAnswer)

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

func FixedAnswerSave 

func FixedAnswerSave(value *FixedAnswer, buffer []byte, context ...TableWriteContext) int64

func FixedAnswerSaveBody 

func FixedAnswerSaveBody(w *TableWriter, value *FixedAnswer) bool

func FixedAnswerSaveBodyFields 

func FixedAnswerSaveBodyFields(w *TableWriter, value *FixedAnswer) bool

func FixedAnswerSaveBodyFieldsRetain 

func FixedAnswerSaveBodyFieldsRetain(w *TableRetainWriter, value *FixedAnswer) bool

func FixedAnswerSaveBodyRetain 

func FixedAnswerSaveBodyRetain(w *TableRetainWriter, value *FixedAnswer) bool

func FixedAnswerSaveMessageBody 

func FixedAnswerSaveMessageBody(w *TableMessageWriter, value *FixedAnswer) bool

func FixedAnswerSaveRetain 

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

func FixedAnswerSaveText 

func FixedAnswerSaveText(value *FixedAnswer, context ...TableWriteContext) (string, error)

FixedAnswerSaveText returns the base64 of FixedAnswer'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 FixedAnswerSave takes.

func FixedAnswerToJson 

func FixedAnswerToJson(value *FixedAnswer, buffer []byte, allocator ...TableAllocator) int64

func FixedAnswerToJsonMeasure 

func FixedAnswerToJsonMeasure(value *FixedAnswer, allocator ...TableAllocator) int64

func FixedTableAnswersEach 

func FixedTableAnswersEach(holder *TableList[NamedFixedAnswerRow], visit func(*NamedFixedAnswerRow) bool, arena ...*TableArena) bool

func FixedTableAnswersErase 

func FixedTableAnswersErase(arena *TableArena, holder *TableList[NamedFixedAnswerRow], element *NamedFixedAnswerRow) bool

func FixedTableCookFrom 

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

func FixedTableCookMeasure 

func FixedTableCookMeasure(value *FixedTable, context ...TableWriteContext) int64

func FixedTableCookMeasureReason 

func FixedTableCookMeasureReason(value *FixedTable, context ...TableWriteContext) (int64, error)

func FixedTableFromJson 

func FixedTableFromJson(builder *FixedTableBuilder, text []byte, report *TableReport) bool

func FixedTableLoadBody 

func FixedTableLoadBody(r *TableReader, value *FixedTable) bool

func FixedTableLoadBodyRetain 

func FixedTableLoadBodyRetain(r *TableRetainReader, value *FixedTable) bool

func FixedTableLoadBuilder 

func FixedTableLoadBuilder(b *FixedTableBuilder, wire []byte, report *TableReport) bool

func FixedTableLoadMeasure 

func FixedTableLoadMeasure(wire []byte) int64

func FixedTableLoadMeasureReason 

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

func FixedTableLoadMessageBody 

func FixedTableLoadMessageBody(r *TableMessageReader, value *FixedTable) bool

func FixedTableLoadMessageBodyRetain 

func FixedTableLoadMessageBodyRetain(r *TableRetainMessageReader, value *FixedTable) bool

func FixedTableMeasure 

func FixedTableMeasure(value *FixedTable, context ...TableWriteContext) int64

func FixedTableMeasureBody 

func FixedTableMeasureBody(value *FixedTable, ids *TableIds) int64

func FixedTableMeasureBodyRetain 

func FixedTableMeasureBodyRetain(value *FixedTable, ids *TableRetainIds) int64

func FixedTableMeasureReason 

func FixedTableMeasureReason(value *FixedTable, context ...TableWriteContext) (int64, error)

func FixedTableMeasureRetain 

func FixedTableMeasureRetain(value *FixedTable, retain *TableRetain, allocator ...TableAllocator) int64

func FixedTableOpen 

func FixedTableOpen(cook *FixedTableCook, base unsafe.Pointer, length int64) bool

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

func FixedTableReset 

func FixedTableReset(value *FixedTable)

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

func FixedTableSave 

func FixedTableSave(value *FixedTable, buffer []byte, context ...TableWriteContext) int64

func FixedTableSaveBody 

func FixedTableSaveBody(w *TableWriter, value *FixedTable) bool

func FixedTableSaveBodyFields 

func FixedTableSaveBodyFields(w *TableWriter, value *FixedTable) bool

func FixedTableSaveBodyFieldsRetain 

func FixedTableSaveBodyFieldsRetain(w *TableRetainWriter, value *FixedTable) bool

func FixedTableSaveBodyRetain 

func FixedTableSaveBodyRetain(w *TableRetainWriter, value *FixedTable) bool

func FixedTableSaveMessageBody 

func FixedTableSaveMessageBody(w *TableMessageWriter, value *FixedTable) bool

func FixedTableSaveRetain 

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

func FixedTableSaveText 

func FixedTableSaveText(value *FixedTable, context ...TableWriteContext) (string, error)

FixedTableSaveText returns the base64 of FixedTable'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 FixedTableSave takes.

func FixedTableToJson 

func FixedTableToJson(value *FixedTable, buffer []byte, allocator ...TableAllocator) int64

func FixedTableToJsonMeasure 

func FixedTableToJsonMeasure(value *FixedTable, allocator ...TableAllocator) int64

func FrameCookFrom 

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

func FrameCookMeasure 

func FrameCookMeasure(value *Frame, context ...TableWriteContext) int64

func FrameCookMeasureReason 

func FrameCookMeasureReason(value *Frame, context ...TableWriteContext) (int64, error)

func FrameFromJson 

func FrameFromJson(builder *FrameBuilder, text []byte, report *TableReport) bool

func FrameLoadBody 

func FrameLoadBody(r *TableReader, value *Frame) bool

func FrameLoadBodyRetain 

func FrameLoadBodyRetain(r *TableRetainReader, value *Frame) bool

func FrameLoadBuilder 

func FrameLoadBuilder(b *FrameBuilder, wire []byte, report *TableReport) bool

func FrameLoadMeasure 

func FrameLoadMeasure(wire []byte) int64

func FrameLoadMeasureReason 

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

func FrameLoadMessageBody 

func FrameLoadMessageBody(r *TableMessageReader, value *Frame) bool

func FrameLoadMessageBodyRetain 

func FrameLoadMessageBodyRetain(r *TableRetainMessageReader, value *Frame) bool

func FrameMeasure 

func FrameMeasure(value *Frame, context ...TableWriteContext) int64

func FrameMeasureBody 

func FrameMeasureBody(value *Frame, ids *TableIds) int64

func FrameMeasureBodyRetain 

func FrameMeasureBodyRetain(value *Frame, ids *TableRetainIds) int64

func FrameMeasureReason 

func FrameMeasureReason(value *Frame, context ...TableWriteContext) (int64, error)

func FrameMeasureRetain 

func FrameMeasureRetain(value *Frame, retain *TableRetain, allocator ...TableAllocator) int64

func FrameOpen 

func FrameOpen(cook *FrameCook, base unsafe.Pointer, length int64) bool

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

func FrameReset 

func FrameReset(value *Frame)

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

func FrameSave 

func FrameSave(value *Frame, buffer []byte, context ...TableWriteContext) int64

func FrameSaveBody 

func FrameSaveBody(w *TableWriter, value *Frame) bool

func FrameSaveBodyFields 

func FrameSaveBodyFields(w *TableWriter, value *Frame) bool

func FrameSaveBodyFieldsRetain 

func FrameSaveBodyFieldsRetain(w *TableRetainWriter, value *Frame) bool

func FrameSaveBodyRetain 

func FrameSaveBodyRetain(w *TableRetainWriter, value *Frame) bool

func FrameSaveMessageBody 

func FrameSaveMessageBody(w *TableMessageWriter, value *Frame) bool

func FrameSaveRetain 

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

func FrameSaveText 

func FrameSaveText(value *Frame, context ...TableWriteContext) (string, error)

FrameSaveText returns the base64 of Frame'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 FrameSave takes.

func FrameStageEach 

func FrameStageEach(holder *TableList[StagePathRow], visit func(*StagePathRow) bool, arena ...*TableArena) bool

func FrameStageErase 

func FrameStageErase(arena *TableArena, holder *TableList[StagePathRow], element *StagePathRow) bool

func FrameToJson 

func FrameToJson(value *Frame, buffer []byte, allocator ...TableAllocator) int64

func FrameToJsonMeasure 

func FrameToJsonMeasure(value *Frame, allocator ...TableAllocator) int64

func GateBarsBlockBegin 

func GateBarsBlockBegin(b *GateBarsBlock, s *GateBarsBlockStorage, c GateBarsCounts, refusal *TableBlockRefusal) bool

---- block fill path: begin ---- GateBarsBlockBegin writes only the prologue and triples, never rows or padding. Storage and all counts are checked before any byte of the extent changes.

func GateBarsBlockBytes 

func GateBarsBlockBytes(b *GateBarsBlock) int64

func GateBarsBlockOpen 

func GateBarsBlockOpen(block *GateBarsBlock, base unsafe.Pointer, bytes int64) bool

---- block fill path: begin ---- ---- block fill path: end ---- GateBarsBlockOpen is the bool convenience for the handle's typed Open error.

func GateBarsCookFrom 

func GateBarsCookFrom(value *GateBars, buffer []byte, order TableByteOrder) bool

func GateBarsCookMeasure 

func GateBarsCookMeasure(value *GateBars) int64

func GateBarsCookMeasureReason 

func GateBarsCookMeasureReason(value *GateBars) (int64, error)

func GateBarsFromJson 

func GateBarsFromJson(value *GateBars, text []byte, report *TableReport) bool

GateBarsFromJson fills one GateBars from a JSON text (mas-bandwidth/schema docs/SPEC-TABLES.md §16). A nil report is allowed; every tolerance event still decides the same way.

func GateBarsLoad 

func GateBarsLoad(value *GateBars, data []byte, report *TableReport) bool

func GateBarsLoadBody 

func GateBarsLoadBody(r *TableReader, value *GateBars) bool

func GateBarsLoadBodyRetain 

func GateBarsLoadBodyRetain(r *TableRetainReader, value *GateBars) bool

func GateBarsLoadMessageBody 

func GateBarsLoadMessageBody(r *TableMessageReader, value *GateBars) bool

func GateBarsLoadMessageBodyRetain 

func GateBarsLoadMessageBodyRetain(r *TableRetainMessageReader, value *GateBars) bool

func GateBarsLoadMessages 

func GateBarsLoadMessages(values []GateBars, vocabulary *TableVocabulary, data []byte, report *TableReport) (int64, bool)

func GateBarsMeasure 

func GateBarsMeasure(value *GateBars) int64

func GateBarsMeasureBody 

func GateBarsMeasureBody(value *GateBars, ids *TableIds) int64

func GateBarsMeasureBodyRetain 

func GateBarsMeasureBodyRetain(value *GateBars, ids *TableRetainIds) int64

func GateBarsMeasureMessages 

func GateBarsMeasureMessages(values []*GateBars, report *TableReport) int64

func GateBarsMeasureReason 

func GateBarsMeasureReason(value *GateBars) (int64, error)

func GateBarsOpen 

func GateBarsOpen(cook *GateBarsCook, base unsafe.Pointer, length int64) bool

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

func GateBarsReset 

func GateBarsReset(value *GateBars)

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

func GateBarsSave 

func GateBarsSave(value *GateBars, buffer []byte) int64

func GateBarsSaveBody 

func GateBarsSaveBody(w *TableWriter, value *GateBars) bool

func GateBarsSaveBodyFields 

func GateBarsSaveBodyFields(w *TableWriter, value *GateBars) bool

func GateBarsSaveBodyFieldsRetain 

func GateBarsSaveBodyFieldsRetain(w *TableRetainWriter, value *GateBars) bool

func GateBarsSaveBodyRetain 

func GateBarsSaveBodyRetain(w *TableRetainWriter, value *GateBars) bool

func GateBarsSaveMessageBody 

func GateBarsSaveMessageBody(w *TableMessageWriter, value *GateBars) bool

func GateBarsSaveMessages 

func GateBarsSaveMessages(values []*GateBars, buffer []byte, report *TableReport) int64

func GateBarsSaveText 

func GateBarsSaveText(value *GateBars) (string, error)

GateBarsSaveText returns the base64 of GateBars'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.

func GateBarsToJson 

func GateBarsToJson(value *GateBars, buffer []byte) int64

GateBarsToJson writes GateBars's JSON text into the caller's slice and returns the bytes written — exactly GateBarsToJsonMeasure's answer — or -1 when it is short.

func GateBarsToJsonMeasure 

func GateBarsToJsonMeasure(value *GateBars) int64

GateBarsToJsonMeasure is the exact size of GateBars's JSON text, writing nothing.

func GateLineCookFrom 

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

func GateLineCookMeasure 

func GateLineCookMeasure(value *GateLine, context ...TableWriteContext) int64

func GateLineCookMeasureReason 

func GateLineCookMeasureReason(value *GateLine, context ...TableWriteContext) (int64, error)

func GateLineFromJson 

func GateLineFromJson(builder *GateLineBuilder, text []byte, report *TableReport) bool

func GateLineLoadBody 

func GateLineLoadBody(r *TableReader, value *GateLine) bool

func GateLineLoadBodyRetain 

func GateLineLoadBodyRetain(r *TableRetainReader, value *GateLine) bool

func GateLineLoadBuilder 

func GateLineLoadBuilder(b *GateLineBuilder, wire []byte, report *TableReport) bool

func GateLineLoadMeasure 

func GateLineLoadMeasure(wire []byte) int64

func GateLineLoadMeasureReason 

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

func GateLineLoadMessageBody 

func GateLineLoadMessageBody(r *TableMessageReader, value *GateLine) bool

func GateLineLoadMessageBodyRetain 

func GateLineLoadMessageBodyRetain(r *TableRetainMessageReader, value *GateLine) bool

func GateLineMeasure 

func GateLineMeasure(value *GateLine, context ...TableWriteContext) int64

func GateLineMeasureBody 

func GateLineMeasureBody(value *GateLine, ids *TableIds) int64

func GateLineMeasureBodyRetain 

func GateLineMeasureBodyRetain(value *GateLine, ids *TableRetainIds) int64

func GateLineMeasureReason 

func GateLineMeasureReason(value *GateLine, context ...TableWriteContext) (int64, error)

func GateLineMeasureRetain 

func GateLineMeasureRetain(value *GateLine, retain *TableRetain, allocator ...TableAllocator) int64

func GateLineOpen 

func GateLineOpen(cook *GateLineCook, base unsafe.Pointer, length int64) bool

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

func GateLineReset 

func GateLineReset(value *GateLine)

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

func GateLineSave 

func GateLineSave(value *GateLine, buffer []byte, context ...TableWriteContext) int64

func GateLineSaveBody 

func GateLineSaveBody(w *TableWriter, value *GateLine) bool

func GateLineSaveBodyFields 

func GateLineSaveBodyFields(w *TableWriter, value *GateLine) bool

func GateLineSaveBodyFieldsRetain 

func GateLineSaveBodyFieldsRetain(w *TableRetainWriter, value *GateLine) bool

func GateLineSaveBodyRetain 

func GateLineSaveBodyRetain(w *TableRetainWriter, value *GateLine) bool

func GateLineSaveMessageBody 

func GateLineSaveMessageBody(w *TableMessageWriter, value *GateLine) bool

func GateLineSaveRetain 

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

func GateLineSaveText 

func GateLineSaveText(value *GateLine, context ...TableWriteContext) (string, error)

GateLineSaveText returns the base64 of GateLine'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 GateLineSave takes.

func GateLineToJson 

func GateLineToJson(value *GateLine, buffer []byte, allocator ...TableAllocator) int64

func GateLineToJsonMeasure 

func GateLineToJsonMeasure(value *GateLine, allocator ...TableAllocator) int64

func ImportExportCookFrom 

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

func ImportExportCookMeasure 

func ImportExportCookMeasure(value *ImportExport, context ...TableWriteContext) int64

func ImportExportCookMeasureReason 

func ImportExportCookMeasureReason(value *ImportExport, context ...TableWriteContext) (int64, error)

func ImportExportFromJson 

func ImportExportFromJson(builder *ImportExportBuilder, text []byte, report *TableReport) bool

func ImportExportLinesEach 

func ImportExportLinesEach(holder *TableList[ImportLogLineRow], visit func(*ImportLogLineRow) bool, arena ...*TableArena) bool

func ImportExportLinesErase 

func ImportExportLinesErase(arena *TableArena, holder *TableList[ImportLogLineRow], element *ImportLogLineRow) bool

func ImportExportLoadBody 

func ImportExportLoadBody(r *TableReader, value *ImportExport) bool

func ImportExportLoadBodyRetain 

func ImportExportLoadBodyRetain(r *TableRetainReader, value *ImportExport) bool

func ImportExportLoadBuilder 

func ImportExportLoadBuilder(b *ImportExportBuilder, wire []byte, report *TableReport) bool

func ImportExportLoadMeasure 

func ImportExportLoadMeasure(wire []byte) int64

func ImportExportLoadMeasureReason 

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

func ImportExportLoadMessageBody 

func ImportExportLoadMessageBody(r *TableMessageReader, value *ImportExport) bool

func ImportExportLoadMessageBodyRetain 

func ImportExportLoadMessageBodyRetain(r *TableRetainMessageReader, value *ImportExport) bool

func ImportExportMeasure 

func ImportExportMeasure(value *ImportExport, context ...TableWriteContext) int64

func ImportExportMeasureBody 

func ImportExportMeasureBody(value *ImportExport, ids *TableIds) int64

func ImportExportMeasureBodyRetain 

func ImportExportMeasureBodyRetain(value *ImportExport, ids *TableRetainIds) int64

func ImportExportMeasureReason 

func ImportExportMeasureReason(value *ImportExport, context ...TableWriteContext) (int64, error)

func ImportExportMeasureRetain 

func ImportExportMeasureRetain(value *ImportExport, retain *TableRetain, allocator ...TableAllocator) int64

func ImportExportOpen 

func ImportExportOpen(cook *ImportExportCook, base unsafe.Pointer, length int64) bool

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

func ImportExportReset 

func ImportExportReset(value *ImportExport)

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

func ImportExportSave 

func ImportExportSave(value *ImportExport, buffer []byte, context ...TableWriteContext) int64

func ImportExportSaveBody 

func ImportExportSaveBody(w *TableWriter, value *ImportExport) bool

func ImportExportSaveBodyFields 

func ImportExportSaveBodyFields(w *TableWriter, value *ImportExport) bool

func ImportExportSaveBodyFieldsRetain 

func ImportExportSaveBodyFieldsRetain(w *TableRetainWriter, value *ImportExport) bool

func ImportExportSaveBodyRetain 

func ImportExportSaveBodyRetain(w *TableRetainWriter, value *ImportExport) bool

func ImportExportSaveMessageBody 

func ImportExportSaveMessageBody(w *TableMessageWriter, value *ImportExport) bool

func ImportExportSaveRetain 

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

func ImportExportSaveText 

func ImportExportSaveText(value *ImportExport, context ...TableWriteContext) (string, error)

ImportExportSaveText returns the base64 of ImportExport'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 ImportExportSave takes.

func ImportExportToJson 

func ImportExportToJson(value *ImportExport, buffer []byte, allocator ...TableAllocator) int64

func ImportExportToJsonMeasure 

func ImportExportToJsonMeasure(value *ImportExport, allocator ...TableAllocator) int64

func ImportLogLineAnswersEach 

func ImportLogLineAnswersEach(holder *TableList[JudgmentIdRow], visit func(*JudgmentIdRow) bool, arena ...*TableArena) bool

func ImportLogLineAnswersErase 

func ImportLogLineAnswersErase(arena *TableArena, holder *TableList[JudgmentIdRow], element *JudgmentIdRow) bool

func ImportLogLineCookFrom 

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

func ImportLogLineCookMeasure 

func ImportLogLineCookMeasure(value *ImportLogLine, context ...TableWriteContext) int64

func ImportLogLineCookMeasureReason 

func ImportLogLineCookMeasureReason(value *ImportLogLine, context ...TableWriteContext) (int64, error)

func ImportLogLineFromJson 

func ImportLogLineFromJson(builder *ImportLogLineBuilder, text []byte, report *TableReport) bool

func ImportLogLineLoadBody 

func ImportLogLineLoadBody(r *TableReader, value *ImportLogLine) bool

func ImportLogLineLoadBodyRetain 

func ImportLogLineLoadBodyRetain(r *TableRetainReader, value *ImportLogLine) bool

func ImportLogLineLoadBuilder 

func ImportLogLineLoadBuilder(b *ImportLogLineBuilder, wire []byte, report *TableReport) bool

func ImportLogLineLoadMeasure 

func ImportLogLineLoadMeasure(wire []byte) int64

func ImportLogLineLoadMeasureReason 

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

func ImportLogLineLoadMessageBody 

func ImportLogLineLoadMessageBody(r *TableMessageReader, value *ImportLogLine) bool

func ImportLogLineLoadMessageBodyRetain 

func ImportLogLineLoadMessageBodyRetain(r *TableRetainMessageReader, value *ImportLogLine) bool

func ImportLogLineMeasure 

func ImportLogLineMeasure(value *ImportLogLine, context ...TableWriteContext) int64

func ImportLogLineMeasureBody 

func ImportLogLineMeasureBody(value *ImportLogLine, ids *TableIds) int64

func ImportLogLineMeasureBodyRetain 

func ImportLogLineMeasureBodyRetain(value *ImportLogLine, ids *TableRetainIds) int64

func ImportLogLineMeasureReason 

func ImportLogLineMeasureReason(value *ImportLogLine, context ...TableWriteContext) (int64, error)

func ImportLogLineMeasureRetain 

func ImportLogLineMeasureRetain(value *ImportLogLine, retain *TableRetain, allocator ...TableAllocator) int64

func ImportLogLineOpen 

func ImportLogLineOpen(cook *ImportLogLineCook, base unsafe.Pointer, length int64) bool

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

func ImportLogLineReset 

func ImportLogLineReset(value *ImportLogLine)

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

func ImportLogLineSave 

func ImportLogLineSave(value *ImportLogLine, buffer []byte, context ...TableWriteContext) int64

func ImportLogLineSaveBody 

func ImportLogLineSaveBody(w *TableWriter, value *ImportLogLine) bool

func ImportLogLineSaveBodyFields 

func ImportLogLineSaveBodyFields(w *TableWriter, value *ImportLogLine) bool

func ImportLogLineSaveBodyFieldsRetain 

func ImportLogLineSaveBodyFieldsRetain(w *TableRetainWriter, value *ImportLogLine) bool

func ImportLogLineSaveBodyRetain 

func ImportLogLineSaveBodyRetain(w *TableRetainWriter, value *ImportLogLine) bool

func ImportLogLineSaveMessageBody 

func ImportLogLineSaveMessageBody(w *TableMessageWriter, value *ImportLogLine) bool

func ImportLogLineSaveRetain 

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

func ImportLogLineSaveText 

func ImportLogLineSaveText(value *ImportLogLine, context ...TableWriteContext) (string, error)

ImportLogLineSaveText returns the base64 of ImportLogLine'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 ImportLogLineSave takes.

func ImportLogLineToJson 

func ImportLogLineToJson(value *ImportLogLine, buffer []byte, allocator ...TableAllocator) int64

func ImportLogLineToJsonMeasure 

func ImportLogLineToJsonMeasure(value *ImportLogLine, allocator ...TableAllocator) int64

func InputCookFrom 

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

func InputCookMeasure 

func InputCookMeasure(value *Input, context ...TableWriteContext) int64

func InputCookMeasureReason 

func InputCookMeasureReason(value *Input, context ...TableWriteContext) (int64, error)

func InputFromJson 

func InputFromJson(builder *InputBuilder, text []byte, report *TableReport) bool

func InputLoadBody 

func InputLoadBody(r *TableReader, value *Input) bool

func InputLoadBodyRetain 

func InputLoadBodyRetain(r *TableRetainReader, value *Input) bool

func InputLoadBuilder 

func InputLoadBuilder(b *InputBuilder, wire []byte, report *TableReport) bool

func InputLoadMeasure 

func InputLoadMeasure(wire []byte) int64

func InputLoadMeasureReason 

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

func InputLoadMessageBody 

func InputLoadMessageBody(r *TableMessageReader, value *Input) bool

func InputLoadMessageBodyRetain 

func InputLoadMessageBodyRetain(r *TableRetainMessageReader, value *Input) bool

func InputMeasure 

func InputMeasure(value *Input, context ...TableWriteContext) int64

func InputMeasureBody 

func InputMeasureBody(value *Input, ids *TableIds) int64

func InputMeasureBodyRetain 

func InputMeasureBodyRetain(value *Input, ids *TableRetainIds) int64

func InputMeasureReason 

func InputMeasureReason(value *Input, context ...TableWriteContext) (int64, error)

func InputMeasureRetain 

func InputMeasureRetain(value *Input, retain *TableRetain, allocator ...TableAllocator) int64

func InputOpen 

func InputOpen(cook *InputCook, base unsafe.Pointer, length int64) bool

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

func InputReset 

func InputReset(value *Input)

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

func InputSave 

func InputSave(value *Input, buffer []byte, context ...TableWriteContext) int64

func InputSaveBody 

func InputSaveBody(w *TableWriter, value *Input) bool

func InputSaveBodyFields 

func InputSaveBodyFields(w *TableWriter, value *Input) bool

func InputSaveBodyFieldsRetain 

func InputSaveBodyFieldsRetain(w *TableRetainWriter, value *Input) bool

func InputSaveBodyRetain 

func InputSaveBodyRetain(w *TableRetainWriter, value *Input) bool

func InputSaveMessageBody 

func InputSaveMessageBody(w *TableMessageWriter, value *Input) bool

func InputSaveRetain 

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

func InputSaveText 

func InputSaveText(value *Input, context ...TableWriteContext) (string, error)

InputSaveText returns the base64 of Input'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 InputSave takes.

func InputToJson 

func InputToJson(value *Input, buffer []byte, allocator ...TableAllocator) int64

func InputToJsonMeasure 

func InputToJsonMeasure(value *Input, allocator ...TableAllocator) int64

func JevAnswerCookFrom 

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

func JevAnswerCookMeasure 

func JevAnswerCookMeasure(value *JevAnswer, context ...TableWriteContext) int64

func JevAnswerCookMeasureReason 

func JevAnswerCookMeasureReason(value *JevAnswer, context ...TableWriteContext) (int64, error)

func JevAnswerFromJson 

func JevAnswerFromJson(builder *JevAnswerBuilder, text []byte, report *TableReport) bool

func JevAnswerLoadBody 

func JevAnswerLoadBody(r *TableReader, value *JevAnswer) bool

func JevAnswerLoadBodyRetain 

func JevAnswerLoadBodyRetain(r *TableRetainReader, value *JevAnswer) bool

func JevAnswerLoadBuilder 

func JevAnswerLoadBuilder(b *JevAnswerBuilder, wire []byte, report *TableReport) bool

func JevAnswerLoadMeasure 

func JevAnswerLoadMeasure(wire []byte) int64

func JevAnswerLoadMeasureReason 

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

func JevAnswerLoadMessageBody 

func JevAnswerLoadMessageBody(r *TableMessageReader, value *JevAnswer) bool

func JevAnswerLoadMessageBodyRetain 

func JevAnswerLoadMessageBodyRetain(r *TableRetainMessageReader, value *JevAnswer) bool

func JevAnswerMeasure 

func JevAnswerMeasure(value *JevAnswer, context ...TableWriteContext) int64

func JevAnswerMeasureBody 

func JevAnswerMeasureBody(value *JevAnswer, ids *TableIds) int64

func JevAnswerMeasureBodyRetain 

func JevAnswerMeasureBodyRetain(value *JevAnswer, ids *TableRetainIds) int64

func JevAnswerMeasureReason 

func JevAnswerMeasureReason(value *JevAnswer, context ...TableWriteContext) (int64, error)

func JevAnswerMeasureRetain 

func JevAnswerMeasureRetain(value *JevAnswer, retain *TableRetain, allocator ...TableAllocator) int64

func JevAnswerOpen 

func JevAnswerOpen(cook *JevAnswerCook, base unsafe.Pointer, length int64) bool

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

func JevAnswerProbabilitiesEach 

func JevAnswerProbabilitiesEach(holder *TableList[OptionPRow], visit func(*OptionPRow) bool, arena ...*TableArena) bool

func JevAnswerProbabilitiesErase 

func JevAnswerProbabilitiesErase(arena *TableArena, holder *TableList[OptionPRow], element *OptionPRow) bool

func JevAnswerReset 

func JevAnswerReset(value *JevAnswer)

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

func JevAnswerSave 

func JevAnswerSave(value *JevAnswer, buffer []byte, context ...TableWriteContext) int64

func JevAnswerSaveBody 

func JevAnswerSaveBody(w *TableWriter, value *JevAnswer) bool

func JevAnswerSaveBodyFields 

func JevAnswerSaveBodyFields(w *TableWriter, value *JevAnswer) bool

func JevAnswerSaveBodyFieldsRetain 

func JevAnswerSaveBodyFieldsRetain(w *TableRetainWriter, value *JevAnswer) bool

func JevAnswerSaveBodyRetain 

func JevAnswerSaveBodyRetain(w *TableRetainWriter, value *JevAnswer) bool

func JevAnswerSaveMessageBody 

func JevAnswerSaveMessageBody(w *TableMessageWriter, value *JevAnswer) bool

func JevAnswerSaveRetain 

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

func JevAnswerSaveText 

func JevAnswerSaveText(value *JevAnswer, context ...TableWriteContext) (string, error)

JevAnswerSaveText returns the base64 of JevAnswer'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 JevAnswerSave takes.

func JevAnswerToJson 

func JevAnswerToJson(value *JevAnswer, buffer []byte, allocator ...TableAllocator) int64

func JevAnswerToJsonMeasure 

func JevAnswerToJsonMeasure(value *JevAnswer, allocator ...TableAllocator) int64

func JevRequestCookFrom 

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

func JevRequestCookMeasure 

func JevRequestCookMeasure(value *JevRequest, context ...TableWriteContext) int64

func JevRequestCookMeasureReason 

func JevRequestCookMeasureReason(value *JevRequest, context ...TableWriteContext) (int64, error)

func JevRequestFromJson 

func JevRequestFromJson(builder *JevRequestBuilder, text []byte, report *TableReport) bool

func JevRequestLoadBody 

func JevRequestLoadBody(r *TableReader, value *JevRequest) bool

func JevRequestLoadBodyRetain 

func JevRequestLoadBodyRetain(r *TableRetainReader, value *JevRequest) bool

func JevRequestLoadBuilder 

func JevRequestLoadBuilder(b *JevRequestBuilder, wire []byte, report *TableReport) bool

func JevRequestLoadMeasure 

func JevRequestLoadMeasure(wire []byte) int64

func JevRequestLoadMeasureReason 

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

func JevRequestLoadMessageBody 

func JevRequestLoadMessageBody(r *TableMessageReader, value *JevRequest) bool

func JevRequestLoadMessageBodyRetain 

func JevRequestLoadMessageBodyRetain(r *TableRetainMessageReader, value *JevRequest) bool

func JevRequestMeasure 

func JevRequestMeasure(value *JevRequest, context ...TableWriteContext) int64

func JevRequestMeasureBody 

func JevRequestMeasureBody(value *JevRequest, ids *TableIds) int64

func JevRequestMeasureBodyRetain 

func JevRequestMeasureBodyRetain(value *JevRequest, ids *TableRetainIds) int64

func JevRequestMeasureReason 

func JevRequestMeasureReason(value *JevRequest, context ...TableWriteContext) (int64, error)

func JevRequestMeasureRetain 

func JevRequestMeasureRetain(value *JevRequest, retain *TableRetain, allocator ...TableAllocator) int64

func JevRequestOpen 

func JevRequestOpen(cook *JevRequestCook, base unsafe.Pointer, length int64) bool

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

func JevRequestQuestionsEach 

func JevRequestQuestionsEach(holder *TableList[NamedQuestionRow], visit func(*NamedQuestionRow) bool, arena ...*TableArena) bool

func JevRequestQuestionsErase 

func JevRequestQuestionsErase(arena *TableArena, holder *TableList[NamedQuestionRow], element *NamedQuestionRow) bool

func JevRequestReset 

func JevRequestReset(value *JevRequest)

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

func JevRequestSave 

func JevRequestSave(value *JevRequest, buffer []byte, context ...TableWriteContext) int64

func JevRequestSaveBody 

func JevRequestSaveBody(w *TableWriter, value *JevRequest) bool

func JevRequestSaveBodyFields 

func JevRequestSaveBodyFields(w *TableWriter, value *JevRequest) bool

func JevRequestSaveBodyFieldsRetain 

func JevRequestSaveBodyFieldsRetain(w *TableRetainWriter, value *JevRequest) bool

func JevRequestSaveBodyRetain 

func JevRequestSaveBodyRetain(w *TableRetainWriter, value *JevRequest) bool

func JevRequestSaveMessageBody 

func JevRequestSaveMessageBody(w *TableMessageWriter, value *JevRequest) bool

func JevRequestSaveRetain 

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

func JevRequestSaveText 

func JevRequestSaveText(value *JevRequest, context ...TableWriteContext) (string, error)

JevRequestSaveText returns the base64 of JevRequest'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 JevRequestSave takes.

func JevRequestToJson 

func JevRequestToJson(value *JevRequest, buffer []byte, allocator ...TableAllocator) int64

func JevRequestToJsonMeasure 

func JevRequestToJsonMeasure(value *JevRequest, allocator ...TableAllocator) int64

func JevResponseAnswersEach 

func JevResponseAnswersEach(holder *TableList[NamedJevAnswerRow], visit func(*NamedJevAnswerRow) bool, arena ...*TableArena) bool

func JevResponseAnswersErase 

func JevResponseAnswersErase(arena *TableArena, holder *TableList[NamedJevAnswerRow], element *NamedJevAnswerRow) bool

func JevResponseCookFrom 

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

func JevResponseCookMeasure 

func JevResponseCookMeasure(value *JevResponse, context ...TableWriteContext) int64

func JevResponseCookMeasureReason 

func JevResponseCookMeasureReason(value *JevResponse, context ...TableWriteContext) (int64, error)

func JevResponseFromJson 

func JevResponseFromJson(builder *JevResponseBuilder, text []byte, report *TableReport) bool

func JevResponseLoadBody 

func JevResponseLoadBody(r *TableReader, value *JevResponse) bool

func JevResponseLoadBodyRetain 

func JevResponseLoadBodyRetain(r *TableRetainReader, value *JevResponse) bool

func JevResponseLoadBuilder 

func JevResponseLoadBuilder(b *JevResponseBuilder, wire []byte, report *TableReport) bool

func JevResponseLoadMeasure 

func JevResponseLoadMeasure(wire []byte) int64

func JevResponseLoadMeasureReason 

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

func JevResponseLoadMessageBody 

func JevResponseLoadMessageBody(r *TableMessageReader, value *JevResponse) bool

func JevResponseLoadMessageBodyRetain 

func JevResponseLoadMessageBodyRetain(r *TableRetainMessageReader, value *JevResponse) bool

func JevResponseMeasure 

func JevResponseMeasure(value *JevResponse, context ...TableWriteContext) int64

func JevResponseMeasureBody 

func JevResponseMeasureBody(value *JevResponse, ids *TableIds) int64

func JevResponseMeasureBodyRetain 

func JevResponseMeasureBodyRetain(value *JevResponse, ids *TableRetainIds) int64

func JevResponseMeasureReason 

func JevResponseMeasureReason(value *JevResponse, context ...TableWriteContext) (int64, error)

func JevResponseMeasureRetain 

func JevResponseMeasureRetain(value *JevResponse, retain *TableRetain, allocator ...TableAllocator) int64

func JevResponseOpen 

func JevResponseOpen(cook *JevResponseCook, base unsafe.Pointer, length int64) bool

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

func JevResponseReset 

func JevResponseReset(value *JevResponse)

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

func JevResponseSave 

func JevResponseSave(value *JevResponse, buffer []byte, context ...TableWriteContext) int64

func JevResponseSaveBody 

func JevResponseSaveBody(w *TableWriter, value *JevResponse) bool

func JevResponseSaveBodyFields 

func JevResponseSaveBodyFields(w *TableWriter, value *JevResponse) bool

func JevResponseSaveBodyFieldsRetain 

func JevResponseSaveBodyFieldsRetain(w *TableRetainWriter, value *JevResponse) bool

func JevResponseSaveBodyRetain 

func JevResponseSaveBodyRetain(w *TableRetainWriter, value *JevResponse) bool

func JevResponseSaveMessageBody 

func JevResponseSaveMessageBody(w *TableMessageWriter, value *JevResponse) bool

func JevResponseSaveRetain 

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

func JevResponseSaveText 

func JevResponseSaveText(value *JevResponse, context ...TableWriteContext) (string, error)

JevResponseSaveText returns the base64 of JevResponse'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 JevResponseSave takes.

func JevResponseToJson 

func JevResponseToJson(value *JevResponse, buffer []byte, allocator ...TableAllocator) int64

func JevResponseToJsonMeasure 

func JevResponseToJsonMeasure(value *JevResponse, allocator ...TableAllocator) int64

func JudgmentIdCookFrom 

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

func JudgmentIdCookMeasure 

func JudgmentIdCookMeasure(value *JudgmentId, context ...TableWriteContext) int64

func JudgmentIdCookMeasureReason 

func JudgmentIdCookMeasureReason(value *JudgmentId, context ...TableWriteContext) (int64, error)

func JudgmentIdFromJson 

func JudgmentIdFromJson(builder *JudgmentIdBuilder, text []byte, report *TableReport) bool

func JudgmentIdLoadBody 

func JudgmentIdLoadBody(r *TableReader, value *JudgmentId) bool

func JudgmentIdLoadBodyRetain 

func JudgmentIdLoadBodyRetain(r *TableRetainReader, value *JudgmentId) bool

func JudgmentIdLoadBuilder 

func JudgmentIdLoadBuilder(b *JudgmentIdBuilder, wire []byte, report *TableReport) bool

func JudgmentIdLoadMeasure 

func JudgmentIdLoadMeasure(wire []byte) int64

func JudgmentIdLoadMeasureReason 

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

func JudgmentIdLoadMessageBody 

func JudgmentIdLoadMessageBody(r *TableMessageReader, value *JudgmentId) bool

func JudgmentIdLoadMessageBodyRetain 

func JudgmentIdLoadMessageBodyRetain(r *TableRetainMessageReader, value *JudgmentId) bool

func JudgmentIdMeasure 

func JudgmentIdMeasure(value *JudgmentId, context ...TableWriteContext) int64

func JudgmentIdMeasureBody 

func JudgmentIdMeasureBody(value *JudgmentId, ids *TableIds) int64

func JudgmentIdMeasureBodyRetain 

func JudgmentIdMeasureBodyRetain(value *JudgmentId, ids *TableRetainIds) int64

func JudgmentIdMeasureReason 

func JudgmentIdMeasureReason(value *JudgmentId, context ...TableWriteContext) (int64, error)

func JudgmentIdMeasureRetain 

func JudgmentIdMeasureRetain(value *JudgmentId, retain *TableRetain, allocator ...TableAllocator) int64

func JudgmentIdOpen 

func JudgmentIdOpen(cook *JudgmentIdCook, base unsafe.Pointer, length int64) bool

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

func JudgmentIdReset 

func JudgmentIdReset(value *JudgmentId)

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

func JudgmentIdSave 

func JudgmentIdSave(value *JudgmentId, buffer []byte, context ...TableWriteContext) int64

func JudgmentIdSaveBody 

func JudgmentIdSaveBody(w *TableWriter, value *JudgmentId) bool

func JudgmentIdSaveBodyFields 

func JudgmentIdSaveBodyFields(w *TableWriter, value *JudgmentId) bool

func JudgmentIdSaveBodyFieldsRetain 

func JudgmentIdSaveBodyFieldsRetain(w *TableRetainWriter, value *JudgmentId) bool

func JudgmentIdSaveBodyRetain 

func JudgmentIdSaveBodyRetain(w *TableRetainWriter, value *JudgmentId) bool

func JudgmentIdSaveMessageBody 

func JudgmentIdSaveMessageBody(w *TableMessageWriter, value *JudgmentId) bool

func JudgmentIdSaveRetain 

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

func JudgmentIdSaveText 

func JudgmentIdSaveText(value *JudgmentId, context ...TableWriteContext) (string, error)

JudgmentIdSaveText returns the base64 of JudgmentId'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 JudgmentIdSave takes.

func JudgmentIdToJson 

func JudgmentIdToJson(value *JudgmentId, buffer []byte, allocator ...TableAllocator) int64

func JudgmentIdToJsonMeasure 

func JudgmentIdToJsonMeasure(value *JudgmentId, allocator ...TableAllocator) int64

func LogExportCookFrom 

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

func LogExportCookMeasure 

func LogExportCookMeasure(value *LogExport, context ...TableWriteContext) int64

func LogExportCookMeasureReason 

func LogExportCookMeasureReason(value *LogExport, context ...TableWriteContext) (int64, error)

func LogExportFromJson 

func LogExportFromJson(builder *LogExportBuilder, text []byte, report *TableReport) bool

func LogExportLinesEach 

func LogExportLinesEach(holder *TableList[LogLineRow], visit func(*LogLineRow) bool, arena ...*TableArena) bool

func LogExportLinesErase 

func LogExportLinesErase(arena *TableArena, holder *TableList[LogLineRow], element *LogLineRow) bool

func LogExportLoadBody 

func LogExportLoadBody(r *TableReader, value *LogExport) bool

func LogExportLoadBodyRetain 

func LogExportLoadBodyRetain(r *TableRetainReader, value *LogExport) bool

func LogExportLoadBuilder 

func LogExportLoadBuilder(b *LogExportBuilder, wire []byte, report *TableReport) bool

func LogExportLoadMeasure 

func LogExportLoadMeasure(wire []byte) int64

func LogExportLoadMeasureReason 

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

func LogExportLoadMessageBody 

func LogExportLoadMessageBody(r *TableMessageReader, value *LogExport) bool

func LogExportLoadMessageBodyRetain 

func LogExportLoadMessageBodyRetain(r *TableRetainMessageReader, value *LogExport) bool

func LogExportMeasure 

func LogExportMeasure(value *LogExport, context ...TableWriteContext) int64

func LogExportMeasureBody 

func LogExportMeasureBody(value *LogExport, ids *TableIds) int64

func LogExportMeasureBodyRetain 

func LogExportMeasureBodyRetain(value *LogExport, ids *TableRetainIds) int64

func LogExportMeasureReason 

func LogExportMeasureReason(value *LogExport, context ...TableWriteContext) (int64, error)

func LogExportMeasureRetain 

func LogExportMeasureRetain(value *LogExport, retain *TableRetain, allocator ...TableAllocator) int64

func LogExportOpen 

func LogExportOpen(cook *LogExportCook, base unsafe.Pointer, length int64) bool

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

func LogExportReset 

func LogExportReset(value *LogExport)

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

func LogExportSave 

func LogExportSave(value *LogExport, buffer []byte, context ...TableWriteContext) int64

func LogExportSaveBody 

func LogExportSaveBody(w *TableWriter, value *LogExport) bool

func LogExportSaveBodyFields 

func LogExportSaveBodyFields(w *TableWriter, value *LogExport) bool

func LogExportSaveBodyFieldsRetain 

func LogExportSaveBodyFieldsRetain(w *TableRetainWriter, value *LogExport) bool

func LogExportSaveBodyRetain 

func LogExportSaveBodyRetain(w *TableRetainWriter, value *LogExport) bool

func LogExportSaveMessageBody 

func LogExportSaveMessageBody(w *TableMessageWriter, value *LogExport) bool

func LogExportSaveRetain 

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

func LogExportSaveText 

func LogExportSaveText(value *LogExport, context ...TableWriteContext) (string, error)

LogExportSaveText returns the base64 of LogExport'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 LogExportSave takes.

func LogExportToJson 

func LogExportToJson(value *LogExport, buffer []byte, allocator ...TableAllocator) int64

func LogExportToJsonMeasure 

func LogExportToJsonMeasure(value *LogExport, allocator ...TableAllocator) int64

func LogLineCookFrom 

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

func LogLineCookMeasure 

func LogLineCookMeasure(value *LogLine, context ...TableWriteContext) int64

func LogLineCookMeasureReason 

func LogLineCookMeasureReason(value *LogLine, context ...TableWriteContext) (int64, error)

func LogLineFromJson 

func LogLineFromJson(builder *LogLineBuilder, text []byte, report *TableReport) bool

func LogLineLoadBody 

func LogLineLoadBody(r *TableReader, value *LogLine) bool

func LogLineLoadBodyRetain 

func LogLineLoadBodyRetain(r *TableRetainReader, value *LogLine) bool

func LogLineLoadBuilder 

func LogLineLoadBuilder(b *LogLineBuilder, wire []byte, report *TableReport) bool

func LogLineLoadMeasure 

func LogLineLoadMeasure(wire []byte) int64

func LogLineLoadMeasureReason 

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

func LogLineLoadMessageBody 

func LogLineLoadMessageBody(r *TableMessageReader, value *LogLine) bool

func LogLineLoadMessageBodyRetain 

func LogLineLoadMessageBodyRetain(r *TableRetainMessageReader, value *LogLine) bool

func LogLineMeasure 

func LogLineMeasure(value *LogLine, context ...TableWriteContext) int64

func LogLineMeasureBody 

func LogLineMeasureBody(value *LogLine, ids *TableIds) int64

func LogLineMeasureBodyRetain 

func LogLineMeasureBodyRetain(value *LogLine, ids *TableRetainIds) int64

func LogLineMeasureReason 

func LogLineMeasureReason(value *LogLine, context ...TableWriteContext) (int64, error)

func LogLineMeasureRetain 

func LogLineMeasureRetain(value *LogLine, retain *TableRetain, allocator ...TableAllocator) int64

func LogLineOpen 

func LogLineOpen(cook *LogLineCook, base unsafe.Pointer, length int64) bool

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

func LogLineReset 

func LogLineReset(value *LogLine)

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

func LogLineSave 

func LogLineSave(value *LogLine, buffer []byte, context ...TableWriteContext) int64

func LogLineSaveBody 

func LogLineSaveBody(w *TableWriter, value *LogLine) bool

func LogLineSaveBodyFields 

func LogLineSaveBodyFields(w *TableWriter, value *LogLine) bool

func LogLineSaveBodyFieldsRetain 

func LogLineSaveBodyFieldsRetain(w *TableRetainWriter, value *LogLine) bool

func LogLineSaveBodyRetain 

func LogLineSaveBodyRetain(w *TableRetainWriter, value *LogLine) bool

func LogLineSaveMessageBody 

func LogLineSaveMessageBody(w *TableMessageWriter, value *LogLine) bool

func LogLineSaveRetain 

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

func LogLineSaveText 

func LogLineSaveText(value *LogLine, context ...TableWriteContext) (string, error)

LogLineSaveText returns the base64 of LogLine'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 LogLineSave takes.

func LogLineSetEach 

func LogLineSetEach(holder *TableList[SetEntryRow], visit func(*SetEntryRow) bool, arena ...*TableArena) bool

func LogLineSetErase 

func LogLineSetErase(arena *TableArena, holder *TableList[SetEntryRow], element *SetEntryRow) bool

func LogLineToJson 

func LogLineToJson(value *LogLine, buffer []byte, allocator ...TableAllocator) int64

func LogLineToJsonMeasure 

func LogLineToJsonMeasure(value *LogLine, allocator ...TableAllocator) int64

func NamedAnswerCookFrom 

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

func NamedAnswerCookMeasure 

func NamedAnswerCookMeasure(value *NamedAnswer, context ...TableWriteContext) int64

func NamedAnswerCookMeasureReason 

func NamedAnswerCookMeasureReason(value *NamedAnswer, context ...TableWriteContext) (int64, error)

func NamedAnswerFromJson 

func NamedAnswerFromJson(builder *NamedAnswerBuilder, text []byte, report *TableReport) bool

func NamedAnswerLoadBody 

func NamedAnswerLoadBody(r *TableReader, value *NamedAnswer) bool

func NamedAnswerLoadBodyRetain 

func NamedAnswerLoadBodyRetain(r *TableRetainReader, value *NamedAnswer) bool

func NamedAnswerLoadBuilder 

func NamedAnswerLoadBuilder(b *NamedAnswerBuilder, wire []byte, report *TableReport) bool

func NamedAnswerLoadMeasure 

func NamedAnswerLoadMeasure(wire []byte) int64

func NamedAnswerLoadMeasureReason 

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

func NamedAnswerLoadMessageBody 

func NamedAnswerLoadMessageBody(r *TableMessageReader, value *NamedAnswer) bool

func NamedAnswerLoadMessageBodyRetain 

func NamedAnswerLoadMessageBodyRetain(r *TableRetainMessageReader, value *NamedAnswer) bool

func NamedAnswerMeasure 

func NamedAnswerMeasure(value *NamedAnswer, context ...TableWriteContext) int64

func NamedAnswerMeasureBody 

func NamedAnswerMeasureBody(value *NamedAnswer, ids *TableIds) int64

func NamedAnswerMeasureBodyRetain 

func NamedAnswerMeasureBodyRetain(value *NamedAnswer, ids *TableRetainIds) int64

func NamedAnswerMeasureReason 

func NamedAnswerMeasureReason(value *NamedAnswer, context ...TableWriteContext) (int64, error)

func NamedAnswerMeasureRetain 

func NamedAnswerMeasureRetain(value *NamedAnswer, retain *TableRetain, allocator ...TableAllocator) int64

func NamedAnswerOpen 

func NamedAnswerOpen(cook *NamedAnswerCook, base unsafe.Pointer, length int64) bool

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

func NamedAnswerReset 

func NamedAnswerReset(value *NamedAnswer)

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

func NamedAnswerSave 

func NamedAnswerSave(value *NamedAnswer, buffer []byte, context ...TableWriteContext) int64

func NamedAnswerSaveBody 

func NamedAnswerSaveBody(w *TableWriter, value *NamedAnswer) bool

func NamedAnswerSaveBodyFields 

func NamedAnswerSaveBodyFields(w *TableWriter, value *NamedAnswer) bool

func NamedAnswerSaveBodyFieldsRetain 

func NamedAnswerSaveBodyFieldsRetain(w *TableRetainWriter, value *NamedAnswer) bool

func NamedAnswerSaveBodyRetain 

func NamedAnswerSaveBodyRetain(w *TableRetainWriter, value *NamedAnswer) bool

func NamedAnswerSaveMessageBody 

func NamedAnswerSaveMessageBody(w *TableMessageWriter, value *NamedAnswer) bool

func NamedAnswerSaveRetain 

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

func NamedAnswerSaveText 

func NamedAnswerSaveText(value *NamedAnswer, context ...TableWriteContext) (string, error)

NamedAnswerSaveText returns the base64 of NamedAnswer'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 NamedAnswerSave takes.

func NamedAnswerToJson 

func NamedAnswerToJson(value *NamedAnswer, buffer []byte, allocator ...TableAllocator) int64

func NamedAnswerToJsonMeasure 

func NamedAnswerToJsonMeasure(value *NamedAnswer, allocator ...TableAllocator) int64

func NamedFixedAnswerCookFrom 

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

func NamedFixedAnswerCookMeasure 

func NamedFixedAnswerCookMeasure(value *NamedFixedAnswer, context ...TableWriteContext) int64

func NamedFixedAnswerCookMeasureReason 

func NamedFixedAnswerCookMeasureReason(value *NamedFixedAnswer, context ...TableWriteContext) (int64, error)

func NamedFixedAnswerFromJson 

func NamedFixedAnswerFromJson(builder *NamedFixedAnswerBuilder, text []byte, report *TableReport) bool

func NamedFixedAnswerLoadBody 

func NamedFixedAnswerLoadBody(r *TableReader, value *NamedFixedAnswer) bool

func NamedFixedAnswerLoadBodyRetain 

func NamedFixedAnswerLoadBodyRetain(r *TableRetainReader, value *NamedFixedAnswer) bool

func NamedFixedAnswerLoadBuilder 

func NamedFixedAnswerLoadBuilder(b *NamedFixedAnswerBuilder, wire []byte, report *TableReport) bool

func NamedFixedAnswerLoadMeasure 

func NamedFixedAnswerLoadMeasure(wire []byte) int64

func NamedFixedAnswerLoadMeasureReason 

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

func NamedFixedAnswerLoadMessageBody 

func NamedFixedAnswerLoadMessageBody(r *TableMessageReader, value *NamedFixedAnswer) bool

func NamedFixedAnswerLoadMessageBodyRetain 

func NamedFixedAnswerLoadMessageBodyRetain(r *TableRetainMessageReader, value *NamedFixedAnswer) bool

func NamedFixedAnswerMeasure 

func NamedFixedAnswerMeasure(value *NamedFixedAnswer, context ...TableWriteContext) int64

func NamedFixedAnswerMeasureBody 

func NamedFixedAnswerMeasureBody(value *NamedFixedAnswer, ids *TableIds) int64

func NamedFixedAnswerMeasureBodyRetain 

func NamedFixedAnswerMeasureBodyRetain(value *NamedFixedAnswer, ids *TableRetainIds) int64

func NamedFixedAnswerMeasureReason 

func NamedFixedAnswerMeasureReason(value *NamedFixedAnswer, context ...TableWriteContext) (int64, error)

func NamedFixedAnswerMeasureRetain 

func NamedFixedAnswerMeasureRetain(value *NamedFixedAnswer, retain *TableRetain, allocator ...TableAllocator) int64

func NamedFixedAnswerOpen 

func NamedFixedAnswerOpen(cook *NamedFixedAnswerCook, base unsafe.Pointer, length int64) bool

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

func NamedFixedAnswerReset 

func NamedFixedAnswerReset(value *NamedFixedAnswer)

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

func NamedFixedAnswerSave 

func NamedFixedAnswerSave(value *NamedFixedAnswer, buffer []byte, context ...TableWriteContext) int64

func NamedFixedAnswerSaveBody 

func NamedFixedAnswerSaveBody(w *TableWriter, value *NamedFixedAnswer) bool

func NamedFixedAnswerSaveBodyFields 

func NamedFixedAnswerSaveBodyFields(w *TableWriter, value *NamedFixedAnswer) bool

func NamedFixedAnswerSaveBodyFieldsRetain 

func NamedFixedAnswerSaveBodyFieldsRetain(w *TableRetainWriter, value *NamedFixedAnswer) bool

func NamedFixedAnswerSaveBodyRetain 

func NamedFixedAnswerSaveBodyRetain(w *TableRetainWriter, value *NamedFixedAnswer) bool

func NamedFixedAnswerSaveMessageBody 

func NamedFixedAnswerSaveMessageBody(w *TableMessageWriter, value *NamedFixedAnswer) bool

func NamedFixedAnswerSaveRetain 

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

func NamedFixedAnswerSaveText 

func NamedFixedAnswerSaveText(value *NamedFixedAnswer, context ...TableWriteContext) (string, error)

NamedFixedAnswerSaveText returns the base64 of NamedFixedAnswer'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 NamedFixedAnswerSave takes.

func NamedFixedAnswerToJson 

func NamedFixedAnswerToJson(value *NamedFixedAnswer, buffer []byte, allocator ...TableAllocator) int64

func NamedFixedAnswerToJsonMeasure 

func NamedFixedAnswerToJsonMeasure(value *NamedFixedAnswer, allocator ...TableAllocator) int64

func NamedJevAnswerCookFrom 

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

func NamedJevAnswerCookMeasure 

func NamedJevAnswerCookMeasure(value *NamedJevAnswer, context ...TableWriteContext) int64

func NamedJevAnswerCookMeasureReason 

func NamedJevAnswerCookMeasureReason(value *NamedJevAnswer, context ...TableWriteContext) (int64, error)

func NamedJevAnswerFromJson 

func NamedJevAnswerFromJson(builder *NamedJevAnswerBuilder, text []byte, report *TableReport) bool

func NamedJevAnswerLoadBody 

func NamedJevAnswerLoadBody(r *TableReader, value *NamedJevAnswer) bool

func NamedJevAnswerLoadBodyRetain 

func NamedJevAnswerLoadBodyRetain(r *TableRetainReader, value *NamedJevAnswer) bool

func NamedJevAnswerLoadBuilder 

func NamedJevAnswerLoadBuilder(b *NamedJevAnswerBuilder, wire []byte, report *TableReport) bool

func NamedJevAnswerLoadMeasure 

func NamedJevAnswerLoadMeasure(wire []byte) int64

func NamedJevAnswerLoadMeasureReason 

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

func NamedJevAnswerLoadMessageBody 

func NamedJevAnswerLoadMessageBody(r *TableMessageReader, value *NamedJevAnswer) bool

func NamedJevAnswerLoadMessageBodyRetain 

func NamedJevAnswerLoadMessageBodyRetain(r *TableRetainMessageReader, value *NamedJevAnswer) bool

func NamedJevAnswerMeasure 

func NamedJevAnswerMeasure(value *NamedJevAnswer, context ...TableWriteContext) int64

func NamedJevAnswerMeasureBody 

func NamedJevAnswerMeasureBody(value *NamedJevAnswer, ids *TableIds) int64

func NamedJevAnswerMeasureBodyRetain 

func NamedJevAnswerMeasureBodyRetain(value *NamedJevAnswer, ids *TableRetainIds) int64

func NamedJevAnswerMeasureReason 

func NamedJevAnswerMeasureReason(value *NamedJevAnswer, context ...TableWriteContext) (int64, error)

func NamedJevAnswerMeasureRetain 

func NamedJevAnswerMeasureRetain(value *NamedJevAnswer, retain *TableRetain, allocator ...TableAllocator) int64

func NamedJevAnswerOpen 

func NamedJevAnswerOpen(cook *NamedJevAnswerCook, base unsafe.Pointer, length int64) bool

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

func NamedJevAnswerReset 

func NamedJevAnswerReset(value *NamedJevAnswer)

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

func NamedJevAnswerSave 

func NamedJevAnswerSave(value *NamedJevAnswer, buffer []byte, context ...TableWriteContext) int64

func NamedJevAnswerSaveBody 

func NamedJevAnswerSaveBody(w *TableWriter, value *NamedJevAnswer) bool

func NamedJevAnswerSaveBodyFields 

func NamedJevAnswerSaveBodyFields(w *TableWriter, value *NamedJevAnswer) bool

func NamedJevAnswerSaveBodyFieldsRetain 

func NamedJevAnswerSaveBodyFieldsRetain(w *TableRetainWriter, value *NamedJevAnswer) bool

func NamedJevAnswerSaveBodyRetain 

func NamedJevAnswerSaveBodyRetain(w *TableRetainWriter, value *NamedJevAnswer) bool

func NamedJevAnswerSaveMessageBody 

func NamedJevAnswerSaveMessageBody(w *TableMessageWriter, value *NamedJevAnswer) bool

func NamedJevAnswerSaveRetain 

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

func NamedJevAnswerSaveText 

func NamedJevAnswerSaveText(value *NamedJevAnswer, context ...TableWriteContext) (string, error)

NamedJevAnswerSaveText returns the base64 of NamedJevAnswer'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 NamedJevAnswerSave takes.

func NamedJevAnswerToJson 

func NamedJevAnswerToJson(value *NamedJevAnswer, buffer []byte, allocator ...TableAllocator) int64

func NamedJevAnswerToJsonMeasure 

func NamedJevAnswerToJsonMeasure(value *NamedJevAnswer, allocator ...TableAllocator) int64

func NamedQuestionCookFrom 

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

func NamedQuestionCookMeasure 

func NamedQuestionCookMeasure(value *NamedQuestion, context ...TableWriteContext) int64

func NamedQuestionCookMeasureReason 

func NamedQuestionCookMeasureReason(value *NamedQuestion, context ...TableWriteContext) (int64, error)

func NamedQuestionFromJson 

func NamedQuestionFromJson(builder *NamedQuestionBuilder, text []byte, report *TableReport) bool

func NamedQuestionLoadBody 

func NamedQuestionLoadBody(r *TableReader, value *NamedQuestion) bool

func NamedQuestionLoadBodyRetain 

func NamedQuestionLoadBodyRetain(r *TableRetainReader, value *NamedQuestion) bool

func NamedQuestionLoadBuilder 

func NamedQuestionLoadBuilder(b *NamedQuestionBuilder, wire []byte, report *TableReport) bool

func NamedQuestionLoadMeasure 

func NamedQuestionLoadMeasure(wire []byte) int64

func NamedQuestionLoadMeasureReason 

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

func NamedQuestionLoadMessageBody 

func NamedQuestionLoadMessageBody(r *TableMessageReader, value *NamedQuestion) bool

func NamedQuestionLoadMessageBodyRetain 

func NamedQuestionLoadMessageBodyRetain(r *TableRetainMessageReader, value *NamedQuestion) bool

func NamedQuestionMeasure 

func NamedQuestionMeasure(value *NamedQuestion, context ...TableWriteContext) int64

func NamedQuestionMeasureBody 

func NamedQuestionMeasureBody(value *NamedQuestion, ids *TableIds) int64

func NamedQuestionMeasureBodyRetain 

func NamedQuestionMeasureBodyRetain(value *NamedQuestion, ids *TableRetainIds) int64

func NamedQuestionMeasureReason 

func NamedQuestionMeasureReason(value *NamedQuestion, context ...TableWriteContext) (int64, error)

func NamedQuestionMeasureRetain 

func NamedQuestionMeasureRetain(value *NamedQuestion, retain *TableRetain, allocator ...TableAllocator) int64

func NamedQuestionOpen 

func NamedQuestionOpen(cook *NamedQuestionCook, base unsafe.Pointer, length int64) bool

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

func NamedQuestionReset 

func NamedQuestionReset(value *NamedQuestion)

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

func NamedQuestionSave 

func NamedQuestionSave(value *NamedQuestion, buffer []byte, context ...TableWriteContext) int64

func NamedQuestionSaveBody 

func NamedQuestionSaveBody(w *TableWriter, value *NamedQuestion) bool

func NamedQuestionSaveBodyFields 

func NamedQuestionSaveBodyFields(w *TableWriter, value *NamedQuestion) bool

func NamedQuestionSaveBodyFieldsRetain 

func NamedQuestionSaveBodyFieldsRetain(w *TableRetainWriter, value *NamedQuestion) bool

func NamedQuestionSaveBodyRetain 

func NamedQuestionSaveBodyRetain(w *TableRetainWriter, value *NamedQuestion) bool

func NamedQuestionSaveMessageBody 

func NamedQuestionSaveMessageBody(w *TableMessageWriter, value *NamedQuestion) bool

func NamedQuestionSaveRetain 

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

func NamedQuestionSaveText 

func NamedQuestionSaveText(value *NamedQuestion, context ...TableWriteContext) (string, error)

NamedQuestionSaveText returns the base64 of NamedQuestion'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 NamedQuestionSave takes.

func NamedQuestionToJson 

func NamedQuestionToJson(value *NamedQuestion, buffer []byte, allocator ...TableAllocator) int64

func NamedQuestionToJsonMeasure 

func NamedQuestionToJsonMeasure(value *NamedQuestion, allocator ...TableAllocator) int64

func OptionPCookFrom 

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

func OptionPCookMeasure 

func OptionPCookMeasure(value *OptionP, context ...TableWriteContext) int64

func OptionPCookMeasureReason 

func OptionPCookMeasureReason(value *OptionP, context ...TableWriteContext) (int64, error)

func OptionPFromJson 

func OptionPFromJson(builder *OptionPBuilder, text []byte, report *TableReport) bool

func OptionPLoadBody 

func OptionPLoadBody(r *TableReader, value *OptionP) bool

func OptionPLoadBodyRetain 

func OptionPLoadBodyRetain(r *TableRetainReader, value *OptionP) bool

func OptionPLoadBuilder 

func OptionPLoadBuilder(b *OptionPBuilder, wire []byte, report *TableReport) bool

func OptionPLoadMeasure 

func OptionPLoadMeasure(wire []byte) int64

func OptionPLoadMeasureReason 

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

func OptionPLoadMessageBody 

func OptionPLoadMessageBody(r *TableMessageReader, value *OptionP) bool

func OptionPLoadMessageBodyRetain 

func OptionPLoadMessageBodyRetain(r *TableRetainMessageReader, value *OptionP) bool

func OptionPMeasure 

func OptionPMeasure(value *OptionP, context ...TableWriteContext) int64

func OptionPMeasureBody 

func OptionPMeasureBody(value *OptionP, ids *TableIds) int64

func OptionPMeasureBodyRetain 

func OptionPMeasureBodyRetain(value *OptionP, ids *TableRetainIds) int64

func OptionPMeasureReason 

func OptionPMeasureReason(value *OptionP, context ...TableWriteContext) (int64, error)

func OptionPMeasureRetain 

func OptionPMeasureRetain(value *OptionP, retain *TableRetain, allocator ...TableAllocator) int64

func OptionPOpen 

func OptionPOpen(cook *OptionPCook, base unsafe.Pointer, length int64) bool

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

func OptionPReset 

func OptionPReset(value *OptionP)

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

func OptionPSave 

func OptionPSave(value *OptionP, buffer []byte, context ...TableWriteContext) int64

func OptionPSaveBody 

func OptionPSaveBody(w *TableWriter, value *OptionP) bool

func OptionPSaveBodyFields 

func OptionPSaveBodyFields(w *TableWriter, value *OptionP) bool

func OptionPSaveBodyFieldsRetain 

func OptionPSaveBodyFieldsRetain(w *TableRetainWriter, value *OptionP) bool

func OptionPSaveBodyRetain 

func OptionPSaveBodyRetain(w *TableRetainWriter, value *OptionP) bool

func OptionPSaveMessageBody 

func OptionPSaveMessageBody(w *TableMessageWriter, value *OptionP) bool

func OptionPSaveRetain 

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

func OptionPSaveText 

func OptionPSaveText(value *OptionP, context ...TableWriteContext) (string, error)

OptionPSaveText returns the base64 of OptionP'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 OptionPSave takes.

func OptionPToJson 

func OptionPToJson(value *OptionP, buffer []byte, allocator ...TableAllocator) int64

func OptionPToJsonMeasure 

func OptionPToJsonMeasure(value *OptionP, allocator ...TableAllocator) int64

func OutcomeCookFrom 

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

func OutcomeCookMeasure 

func OutcomeCookMeasure(value *Outcome, context ...TableWriteContext) int64

func OutcomeCookMeasureReason 

func OutcomeCookMeasureReason(value *Outcome, context ...TableWriteContext) (int64, error)

func OutcomeFromJson 

func OutcomeFromJson(builder *OutcomeBuilder, text []byte, report *TableReport) bool

func OutcomeLoadBody 

func OutcomeLoadBody(r *TableReader, value *Outcome) bool

func OutcomeLoadBodyRetain 

func OutcomeLoadBodyRetain(r *TableRetainReader, value *Outcome) bool

func OutcomeLoadBuilder 

func OutcomeLoadBuilder(b *OutcomeBuilder, wire []byte, report *TableReport) bool

func OutcomeLoadMeasure 

func OutcomeLoadMeasure(wire []byte) int64

func OutcomeLoadMeasureReason 

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

func OutcomeLoadMessageBody 

func OutcomeLoadMessageBody(r *TableMessageReader, value *Outcome) bool

func OutcomeLoadMessageBodyRetain 

func OutcomeLoadMessageBodyRetain(r *TableRetainMessageReader, value *Outcome) bool

func OutcomeMeasure 

func OutcomeMeasure(value *Outcome, context ...TableWriteContext) int64

func OutcomeMeasureBody 

func OutcomeMeasureBody(value *Outcome, ids *TableIds) int64

func OutcomeMeasureBodyRetain 

func OutcomeMeasureBodyRetain(value *Outcome, ids *TableRetainIds) int64

func OutcomeMeasureReason 

func OutcomeMeasureReason(value *Outcome, context ...TableWriteContext) (int64, error)

func OutcomeMeasureRetain 

func OutcomeMeasureRetain(value *Outcome, retain *TableRetain, allocator ...TableAllocator) int64

func OutcomeOpen 

func OutcomeOpen(cook *OutcomeCook, base unsafe.Pointer, length int64) bool

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

func OutcomeReset 

func OutcomeReset(value *Outcome)

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

func OutcomeSave 

func OutcomeSave(value *Outcome, buffer []byte, context ...TableWriteContext) int64

func OutcomeSaveBody 

func OutcomeSaveBody(w *TableWriter, value *Outcome) bool

func OutcomeSaveBodyFields 

func OutcomeSaveBodyFields(w *TableWriter, value *Outcome) bool

func OutcomeSaveBodyFieldsRetain 

func OutcomeSaveBodyFieldsRetain(w *TableRetainWriter, value *Outcome) bool

func OutcomeSaveBodyRetain 

func OutcomeSaveBodyRetain(w *TableRetainWriter, value *Outcome) bool

func OutcomeSaveMessageBody 

func OutcomeSaveMessageBody(w *TableMessageWriter, value *Outcome) bool

func OutcomeSaveRetain 

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

func OutcomeSaveText 

func OutcomeSaveText(value *Outcome, context ...TableWriteContext) (string, error)

OutcomeSaveText returns the base64 of Outcome'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 OutcomeSave takes.

func OutcomeToJson 

func OutcomeToJson(value *Outcome, buffer []byte, allocator ...TableAllocator) int64

func OutcomeToJsonMeasure 

func OutcomeToJsonMeasure(value *Outcome, allocator ...TableAllocator) int64

func QuestionCookFrom 

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

func QuestionCookMeasure 

func QuestionCookMeasure(value *Question, context ...TableWriteContext) int64

func QuestionCookMeasureReason 

func QuestionCookMeasureReason(value *Question, context ...TableWriteContext) (int64, error)

func QuestionCriteriaEach 

func QuestionCriteriaEach(holder *TableList[CriterionRow], visit func(*CriterionRow) bool, arena ...*TableArena) bool

func QuestionCriteriaErase 

func QuestionCriteriaErase(arena *TableArena, holder *TableList[CriterionRow], element *CriterionRow) bool

func QuestionFromJson 

func QuestionFromJson(builder *QuestionBuilder, text []byte, report *TableReport) bool

func QuestionLoadBody 

func QuestionLoadBody(r *TableReader, value *Question) bool

func QuestionLoadBodyRetain 

func QuestionLoadBodyRetain(r *TableRetainReader, value *Question) bool

func QuestionLoadBuilder 

func QuestionLoadBuilder(b *QuestionBuilder, wire []byte, report *TableReport) bool

func QuestionLoadMeasure 

func QuestionLoadMeasure(wire []byte) int64

func QuestionLoadMeasureReason 

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

func QuestionLoadMessageBody 

func QuestionLoadMessageBody(r *TableMessageReader, value *Question) bool

func QuestionLoadMessageBodyRetain 

func QuestionLoadMessageBodyRetain(r *TableRetainMessageReader, value *Question) bool

func QuestionMeasure 

func QuestionMeasure(value *Question, context ...TableWriteContext) int64

func QuestionMeasureBody 

func QuestionMeasureBody(value *Question, ids *TableIds) int64

func QuestionMeasureBodyRetain 

func QuestionMeasureBodyRetain(value *Question, ids *TableRetainIds) int64

func QuestionMeasureReason 

func QuestionMeasureReason(value *Question, context ...TableWriteContext) (int64, error)

func QuestionMeasureRetain 

func QuestionMeasureRetain(value *Question, retain *TableRetain, allocator ...TableAllocator) int64

func QuestionOpen 

func QuestionOpen(cook *QuestionCook, base unsafe.Pointer, length int64) bool

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

func QuestionReset 

func QuestionReset(value *Question)

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

func QuestionSave 

func QuestionSave(value *Question, buffer []byte, context ...TableWriteContext) int64

func QuestionSaveBody 

func QuestionSaveBody(w *TableWriter, value *Question) bool

func QuestionSaveBodyFields 

func QuestionSaveBodyFields(w *TableWriter, value *Question) bool

func QuestionSaveBodyFieldsRetain 

func QuestionSaveBodyFieldsRetain(w *TableRetainWriter, value *Question) bool

func QuestionSaveBodyRetain 

func QuestionSaveBodyRetain(w *TableRetainWriter, value *Question) bool

func QuestionSaveMessageBody 

func QuestionSaveMessageBody(w *TableMessageWriter, value *Question) bool

func QuestionSaveRetain 

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

func QuestionSaveText 

func QuestionSaveText(value *Question, context ...TableWriteContext) (string, error)

QuestionSaveText returns the base64 of Question'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 QuestionSave takes.

func QuestionToJson 

func QuestionToJson(value *Question, buffer []byte, allocator ...TableAllocator) int64

func QuestionToJsonMeasure 

func QuestionToJsonMeasure(value *Question, allocator ...TableAllocator) int64

func RawRecordCookFrom 

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

func RawRecordCookMeasure 

func RawRecordCookMeasure(value *RawRecord, context ...TableWriteContext) int64

func RawRecordCookMeasureReason 

func RawRecordCookMeasureReason(value *RawRecord, context ...TableWriteContext) (int64, error)

func RawRecordFromJson 

func RawRecordFromJson(builder *RawRecordBuilder, text []byte, report *TableReport) bool

func RawRecordLoadBody 

func RawRecordLoadBody(r *TableReader, value *RawRecord) bool

func RawRecordLoadBodyRetain 

func RawRecordLoadBodyRetain(r *TableRetainReader, value *RawRecord) bool

func RawRecordLoadBuilder 

func RawRecordLoadBuilder(b *RawRecordBuilder, wire []byte, report *TableReport) bool

func RawRecordLoadMeasure 

func RawRecordLoadMeasure(wire []byte) int64

func RawRecordLoadMeasureReason 

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

func RawRecordLoadMessageBody 

func RawRecordLoadMessageBody(r *TableMessageReader, value *RawRecord) bool

func RawRecordLoadMessageBodyRetain 

func RawRecordLoadMessageBodyRetain(r *TableRetainMessageReader, value *RawRecord) bool

func RawRecordMeasure 

func RawRecordMeasure(value *RawRecord, context ...TableWriteContext) int64

func RawRecordMeasureBody 

func RawRecordMeasureBody(value *RawRecord, ids *TableIds) int64

func RawRecordMeasureBodyRetain 

func RawRecordMeasureBodyRetain(value *RawRecord, ids *TableRetainIds) int64

func RawRecordMeasureReason 

func RawRecordMeasureReason(value *RawRecord, context ...TableWriteContext) (int64, error)

func RawRecordMeasureRetain 

func RawRecordMeasureRetain(value *RawRecord, retain *TableRetain, allocator ...TableAllocator) int64

func RawRecordOpen 

func RawRecordOpen(cook *RawRecordCook, base unsafe.Pointer, length int64) bool

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

func RawRecordReset 

func RawRecordReset(value *RawRecord)

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

func RawRecordSave 

func RawRecordSave(value *RawRecord, buffer []byte, context ...TableWriteContext) int64

func RawRecordSaveBody 

func RawRecordSaveBody(w *TableWriter, value *RawRecord) bool

func RawRecordSaveBodyFields 

func RawRecordSaveBodyFields(w *TableWriter, value *RawRecord) bool

func RawRecordSaveBodyFieldsRetain 

func RawRecordSaveBodyFieldsRetain(w *TableRetainWriter, value *RawRecord) bool

func RawRecordSaveBodyRetain 

func RawRecordSaveBodyRetain(w *TableRetainWriter, value *RawRecord) bool

func RawRecordSaveMessageBody 

func RawRecordSaveMessageBody(w *TableMessageWriter, value *RawRecord) bool

func RawRecordSaveRetain 

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

func RawRecordSaveText 

func RawRecordSaveText(value *RawRecord, context ...TableWriteContext) (string, error)

RawRecordSaveText returns the base64 of RawRecord'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 RawRecordSave takes.

func RawRecordToJson 

func RawRecordToJson(value *RawRecord, buffer []byte, allocator ...TableAllocator) int64

func RawRecordToJsonMeasure 

func RawRecordToJsonMeasure(value *RawRecord, allocator ...TableAllocator) int64

func RawTokensBlockBegin 

func RawTokensBlockBegin(b *RawTokensBlock, s *RawTokensBlockStorage, c RawTokensCounts, refusal *TableBlockRefusal) bool

---- block fill path: begin ---- RawTokensBlockBegin writes only the prologue and triples, never rows or padding. Storage and all counts are checked before any byte of the extent changes.

func RawTokensBlockBytes 

func RawTokensBlockBytes(b *RawTokensBlock) int64

func RawTokensBlockOpen 

func RawTokensBlockOpen(block *RawTokensBlock, base unsafe.Pointer, bytes int64) bool

---- block fill path: begin ---- ---- block fill path: end ---- RawTokensBlockOpen is the bool convenience for the handle's typed Open error.

func RawTokensCookFrom 

func RawTokensCookFrom(value *RawTokens, buffer []byte, order TableByteOrder) bool

func RawTokensCookMeasure 

func RawTokensCookMeasure(value *RawTokens) int64

func RawTokensCookMeasureReason 

func RawTokensCookMeasureReason(value *RawTokens) (int64, error)

func RawTokensFromJson 

func RawTokensFromJson(value *RawTokens, text []byte, report *TableReport) bool

RawTokensFromJson fills one RawTokens from a JSON text (mas-bandwidth/schema docs/SPEC-TABLES.md §16). A nil report is allowed; every tolerance event still decides the same way.

func RawTokensLoad 

func RawTokensLoad(value *RawTokens, data []byte, report *TableReport) bool

func RawTokensLoadBody 

func RawTokensLoadBody(r *TableReader, value *RawTokens) bool

func RawTokensLoadBodyRetain 

func RawTokensLoadBodyRetain(r *TableRetainReader, value *RawTokens) bool

func RawTokensLoadMessageBody 

func RawTokensLoadMessageBody(r *TableMessageReader, value *RawTokens) bool

func RawTokensLoadMessageBodyRetain 

func RawTokensLoadMessageBodyRetain(r *TableRetainMessageReader, value *RawTokens) bool

func RawTokensLoadMessages 

func RawTokensLoadMessages(values []RawTokens, vocabulary *TableVocabulary, data []byte, report *TableReport) (int64, bool)

func RawTokensMeasure 

func RawTokensMeasure(value *RawTokens) int64

func RawTokensMeasureBody 

func RawTokensMeasureBody(value *RawTokens, ids *TableIds) int64

func RawTokensMeasureBodyRetain 

func RawTokensMeasureBodyRetain(value *RawTokens, ids *TableRetainIds) int64

func RawTokensMeasureMessages 

func RawTokensMeasureMessages(values []*RawTokens, report *TableReport) int64

func RawTokensMeasureReason 

func RawTokensMeasureReason(value *RawTokens) (int64, error)

func RawTokensOpen 

func RawTokensOpen(cook *RawTokensCook, base unsafe.Pointer, length int64) bool

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

func RawTokensReset 

func RawTokensReset(value *RawTokens)

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

func RawTokensSave 

func RawTokensSave(value *RawTokens, buffer []byte) int64

func RawTokensSaveBody 

func RawTokensSaveBody(w *TableWriter, value *RawTokens) bool

func RawTokensSaveBodyFields 

func RawTokensSaveBodyFields(w *TableWriter, value *RawTokens) bool

func RawTokensSaveBodyFieldsRetain 

func RawTokensSaveBodyFieldsRetain(w *TableRetainWriter, value *RawTokens) bool

func RawTokensSaveBodyRetain 

func RawTokensSaveBodyRetain(w *TableRetainWriter, value *RawTokens) bool

func RawTokensSaveMessageBody 

func RawTokensSaveMessageBody(w *TableMessageWriter, value *RawTokens) bool

func RawTokensSaveMessages 

func RawTokensSaveMessages(values []*RawTokens, buffer []byte, report *TableReport) int64

func RawTokensSaveText 

func RawTokensSaveText(value *RawTokens) (string, error)

RawTokensSaveText returns the base64 of RawTokens'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.

func RawTokensToJson 

func RawTokensToJson(value *RawTokens, buffer []byte) int64

RawTokensToJson writes RawTokens's JSON text into the caller's slice and returns the bytes written — exactly RawTokensToJsonMeasure's answer — or -1 when it is short.

func RawTokensToJsonMeasure 

func RawTokensToJsonMeasure(value *RawTokens) int64

RawTokensToJsonMeasure is the exact size of RawTokens's JSON text, writing nothing.

func RawUsageCookFrom 

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

func RawUsageCookMeasure 

func RawUsageCookMeasure(value *RawUsage, context ...TableWriteContext) int64

func RawUsageCookMeasureReason 

func RawUsageCookMeasureReason(value *RawUsage, context ...TableWriteContext) (int64, error)

func RawUsageFromJson 

func RawUsageFromJson(builder *RawUsageBuilder, text []byte, report *TableReport) bool

func RawUsageLoadBody 

func RawUsageLoadBody(r *TableReader, value *RawUsage) bool

func RawUsageLoadBodyRetain 

func RawUsageLoadBodyRetain(r *TableRetainReader, value *RawUsage) bool

func RawUsageLoadBuilder 

func RawUsageLoadBuilder(b *RawUsageBuilder, wire []byte, report *TableReport) bool

func RawUsageLoadMeasure 

func RawUsageLoadMeasure(wire []byte) int64

func RawUsageLoadMeasureReason 

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

func RawUsageLoadMessageBody 

func RawUsageLoadMessageBody(r *TableMessageReader, value *RawUsage) bool

func RawUsageLoadMessageBodyRetain 

func RawUsageLoadMessageBodyRetain(r *TableRetainMessageReader, value *RawUsage) bool

func RawUsageMeasure 

func RawUsageMeasure(value *RawUsage, context ...TableWriteContext) int64

func RawUsageMeasureBody 

func RawUsageMeasureBody(value *RawUsage, ids *TableIds) int64

func RawUsageMeasureBodyRetain 

func RawUsageMeasureBodyRetain(value *RawUsage, ids *TableRetainIds) int64

func RawUsageMeasureReason 

func RawUsageMeasureReason(value *RawUsage, context ...TableWriteContext) (int64, error)

func RawUsageMeasureRetain 

func RawUsageMeasureRetain(value *RawUsage, retain *TableRetain, allocator ...TableAllocator) int64

func RawUsageOpen 

func RawUsageOpen(cook *RawUsageCook, base unsafe.Pointer, length int64) bool

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

func RawUsageRecordsEach 

func RawUsageRecordsEach(holder *TableList[RawRecordRow], visit func(*RawRecordRow) bool, arena ...*TableArena) bool

func RawUsageRecordsErase 

func RawUsageRecordsErase(arena *TableArena, holder *TableList[RawRecordRow], element *RawRecordRow) bool

func RawUsageReset 

func RawUsageReset(value *RawUsage)

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

func RawUsageSave 

func RawUsageSave(value *RawUsage, buffer []byte, context ...TableWriteContext) int64

func RawUsageSaveBody 

func RawUsageSaveBody(w *TableWriter, value *RawUsage) bool

func RawUsageSaveBodyFields 

func RawUsageSaveBodyFields(w *TableWriter, value *RawUsage) bool

func RawUsageSaveBodyFieldsRetain 

func RawUsageSaveBodyFieldsRetain(w *TableRetainWriter, value *RawUsage) bool

func RawUsageSaveBodyRetain 

func RawUsageSaveBodyRetain(w *TableRetainWriter, value *RawUsage) bool

func RawUsageSaveMessageBody 

func RawUsageSaveMessageBody(w *TableMessageWriter, value *RawUsage) bool

func RawUsageSaveRetain 

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

func RawUsageSaveText 

func RawUsageSaveText(value *RawUsage, context ...TableWriteContext) (string, error)

RawUsageSaveText returns the base64 of RawUsage'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 RawUsageSave takes.

func RawUsageToJson 

func RawUsageToJson(value *RawUsage, buffer []byte, allocator ...TableAllocator) int64

func RawUsageToJsonMeasure 

func RawUsageToJsonMeasure(value *RawUsage, allocator ...TableAllocator) int64

func RecordLineCookFrom 

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

func RecordLineCookMeasure 

func RecordLineCookMeasure(value *RecordLine, context ...TableWriteContext) int64

func RecordLineCookMeasureReason 

func RecordLineCookMeasureReason(value *RecordLine, context ...TableWriteContext) (int64, error)

func RecordLineFromJson 

func RecordLineFromJson(builder *RecordLineBuilder, text []byte, report *TableReport) bool

func RecordLineLoadBody 

func RecordLineLoadBody(r *TableReader, value *RecordLine) bool

func RecordLineLoadBodyRetain 

func RecordLineLoadBodyRetain(r *TableRetainReader, value *RecordLine) bool

func RecordLineLoadBuilder 

func RecordLineLoadBuilder(b *RecordLineBuilder, wire []byte, report *TableReport) bool

func RecordLineLoadMeasure 

func RecordLineLoadMeasure(wire []byte) int64

func RecordLineLoadMeasureReason 

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

func RecordLineLoadMessageBody 

func RecordLineLoadMessageBody(r *TableMessageReader, value *RecordLine) bool

func RecordLineLoadMessageBodyRetain 

func RecordLineLoadMessageBodyRetain(r *TableRetainMessageReader, value *RecordLine) bool

func RecordLineMeasure 

func RecordLineMeasure(value *RecordLine, context ...TableWriteContext) int64

func RecordLineMeasureBody 

func RecordLineMeasureBody(value *RecordLine, ids *TableIds) int64

func RecordLineMeasureBodyRetain 

func RecordLineMeasureBodyRetain(value *RecordLine, ids *TableRetainIds) int64

func RecordLineMeasureReason 

func RecordLineMeasureReason(value *RecordLine, context ...TableWriteContext) (int64, error)

func RecordLineMeasureRetain 

func RecordLineMeasureRetain(value *RecordLine, retain *TableRetain, allocator ...TableAllocator) int64

func RecordLineOpen 

func RecordLineOpen(cook *RecordLineCook, base unsafe.Pointer, length int64) bool

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

func RecordLineReset 

func RecordLineReset(value *RecordLine)

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

func RecordLineSave 

func RecordLineSave(value *RecordLine, buffer []byte, context ...TableWriteContext) int64

func RecordLineSaveBody 

func RecordLineSaveBody(w *TableWriter, value *RecordLine) bool

func RecordLineSaveBodyFields 

func RecordLineSaveBodyFields(w *TableWriter, value *RecordLine) bool

func RecordLineSaveBodyFieldsRetain 

func RecordLineSaveBodyFieldsRetain(w *TableRetainWriter, value *RecordLine) bool

func RecordLineSaveBodyRetain 

func RecordLineSaveBodyRetain(w *TableRetainWriter, value *RecordLine) bool

func RecordLineSaveMessageBody 

func RecordLineSaveMessageBody(w *TableMessageWriter, value *RecordLine) bool

func RecordLineSaveRetain 

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

func RecordLineSaveText 

func RecordLineSaveText(value *RecordLine, context ...TableWriteContext) (string, error)

RecordLineSaveText returns the base64 of RecordLine'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 RecordLineSave takes.

func RecordLineToJson 

func RecordLineToJson(value *RecordLine, buffer []byte, allocator ...TableAllocator) int64

func RecordLineToJsonMeasure 

func RecordLineToJsonMeasure(value *RecordLine, allocator ...TableAllocator) int64

func SetEntryCookFrom 

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

func SetEntryCookMeasure 

func SetEntryCookMeasure(value *SetEntry, context ...TableWriteContext) int64

func SetEntryCookMeasureReason 

func SetEntryCookMeasureReason(value *SetEntry, context ...TableWriteContext) (int64, error)

func SetEntryFromJson 

func SetEntryFromJson(builder *SetEntryBuilder, text []byte, report *TableReport) bool

func SetEntryLoadBody 

func SetEntryLoadBody(r *TableReader, value *SetEntry) bool

func SetEntryLoadBodyRetain 

func SetEntryLoadBodyRetain(r *TableRetainReader, value *SetEntry) bool

func SetEntryLoadBuilder 

func SetEntryLoadBuilder(b *SetEntryBuilder, wire []byte, report *TableReport) bool

func SetEntryLoadMeasure 

func SetEntryLoadMeasure(wire []byte) int64

func SetEntryLoadMeasureReason 

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

func SetEntryLoadMessageBody 

func SetEntryLoadMessageBody(r *TableMessageReader, value *SetEntry) bool

func SetEntryLoadMessageBodyRetain 

func SetEntryLoadMessageBodyRetain(r *TableRetainMessageReader, value *SetEntry) bool

func SetEntryMeasure 

func SetEntryMeasure(value *SetEntry, context ...TableWriteContext) int64

func SetEntryMeasureBody 

func SetEntryMeasureBody(value *SetEntry, ids *TableIds) int64

func SetEntryMeasureBodyRetain 

func SetEntryMeasureBodyRetain(value *SetEntry, ids *TableRetainIds) int64

func SetEntryMeasureReason 

func SetEntryMeasureReason(value *SetEntry, context ...TableWriteContext) (int64, error)

func SetEntryMeasureRetain 

func SetEntryMeasureRetain(value *SetEntry, retain *TableRetain, allocator ...TableAllocator) int64

func SetEntryOpen 

func SetEntryOpen(cook *SetEntryCook, base unsafe.Pointer, length int64) bool

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

func SetEntryReset 

func SetEntryReset(value *SetEntry)

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

func SetEntrySave 

func SetEntrySave(value *SetEntry, buffer []byte, context ...TableWriteContext) int64

func SetEntrySaveBody 

func SetEntrySaveBody(w *TableWriter, value *SetEntry) bool

func SetEntrySaveBodyFields 

func SetEntrySaveBodyFields(w *TableWriter, value *SetEntry) bool

func SetEntrySaveBodyFieldsRetain 

func SetEntrySaveBodyFieldsRetain(w *TableRetainWriter, value *SetEntry) bool

func SetEntrySaveBodyRetain 

func SetEntrySaveBodyRetain(w *TableRetainWriter, value *SetEntry) bool

func SetEntrySaveMessageBody 

func SetEntrySaveMessageBody(w *TableMessageWriter, value *SetEntry) bool

func SetEntrySaveRetain 

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

func SetEntrySaveText 

func SetEntrySaveText(value *SetEntry, context ...TableWriteContext) (string, error)

SetEntrySaveText returns the base64 of SetEntry'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 SetEntrySave takes.

func SetEntryToJson 

func SetEntryToJson(value *SetEntry, buffer []byte, allocator ...TableAllocator) int64

func SetEntryToJsonMeasure 

func SetEntryToJsonMeasure(value *SetEntry, allocator ...TableAllocator) int64

func StagePathCookFrom 

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

func StagePathCookMeasure 

func StagePathCookMeasure(value *StagePath, context ...TableWriteContext) int64

func StagePathCookMeasureReason 

func StagePathCookMeasureReason(value *StagePath, context ...TableWriteContext) (int64, error)

func StagePathFromJson 

func StagePathFromJson(builder *StagePathBuilder, text []byte, report *TableReport) bool

func StagePathLoadBody 

func StagePathLoadBody(r *TableReader, value *StagePath) bool

func StagePathLoadBodyRetain 

func StagePathLoadBodyRetain(r *TableRetainReader, value *StagePath) bool

func StagePathLoadBuilder 

func StagePathLoadBuilder(b *StagePathBuilder, wire []byte, report *TableReport) bool

func StagePathLoadMeasure 

func StagePathLoadMeasure(wire []byte) int64

func StagePathLoadMeasureReason 

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

func StagePathLoadMessageBody 

func StagePathLoadMessageBody(r *TableMessageReader, value *StagePath) bool

func StagePathLoadMessageBodyRetain 

func StagePathLoadMessageBodyRetain(r *TableRetainMessageReader, value *StagePath) bool

func StagePathMeasure 

func StagePathMeasure(value *StagePath, context ...TableWriteContext) int64

func StagePathMeasureBody 

func StagePathMeasureBody(value *StagePath, ids *TableIds) int64

func StagePathMeasureBodyRetain 

func StagePathMeasureBodyRetain(value *StagePath, ids *TableRetainIds) int64

func StagePathMeasureReason 

func StagePathMeasureReason(value *StagePath, context ...TableWriteContext) (int64, error)

func StagePathMeasureRetain 

func StagePathMeasureRetain(value *StagePath, retain *TableRetain, allocator ...TableAllocator) int64

func StagePathOpen 

func StagePathOpen(cook *StagePathCook, base unsafe.Pointer, length int64) bool

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

func StagePathReset 

func StagePathReset(value *StagePath)

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

func StagePathSave 

func StagePathSave(value *StagePath, buffer []byte, context ...TableWriteContext) int64

func StagePathSaveBody 

func StagePathSaveBody(w *TableWriter, value *StagePath) bool

func StagePathSaveBodyFields 

func StagePathSaveBodyFields(w *TableWriter, value *StagePath) bool

func StagePathSaveBodyFieldsRetain 

func StagePathSaveBodyFieldsRetain(w *TableRetainWriter, value *StagePath) bool

func StagePathSaveBodyRetain 

func StagePathSaveBodyRetain(w *TableRetainWriter, value *StagePath) bool

func StagePathSaveMessageBody 

func StagePathSaveMessageBody(w *TableMessageWriter, value *StagePath) bool

func StagePathSaveRetain 

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

func StagePathSaveText 

func StagePathSaveText(value *StagePath, context ...TableWriteContext) (string, error)

StagePathSaveText returns the base64 of StagePath'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 StagePathSave takes.

func StagePathToJson 

func StagePathToJson(value *StagePath, buffer []byte, allocator ...TableAllocator) int64

func StagePathToJsonMeasure 

func StagePathToJsonMeasure(value *StagePath, 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

func UsageBlockBegin 

func UsageBlockBegin(b *UsageBlock, s *UsageBlockStorage, c UsageCounts, refusal *TableBlockRefusal) bool

---- block fill path: begin ---- UsageBlockBegin writes only the prologue and triples, never rows or padding. Storage and all counts are checked before any byte of the extent changes.

func UsageBlockBytes 

func UsageBlockBytes(b *UsageBlock) int64

func UsageBlockOpen 

func UsageBlockOpen(block *UsageBlock, base unsafe.Pointer, bytes int64) bool

---- block fill path: begin ---- ---- block fill path: end ---- UsageBlockOpen is the bool convenience for the handle's typed Open error.

func UsageCookFrom 

func UsageCookFrom(value *Usage, buffer []byte, order TableByteOrder) bool

func UsageCookMeasure 

func UsageCookMeasure(value *Usage) int64

func UsageCookMeasureReason 

func UsageCookMeasureReason(value *Usage) (int64, error)

func UsageFromJson 

func UsageFromJson(value *Usage, text []byte, report *TableReport) bool

UsageFromJson fills one Usage from a JSON text (mas-bandwidth/schema docs/SPEC-TABLES.md §16). A nil report is allowed; every tolerance event still decides the same way.

func UsageLoad 

func UsageLoad(value *Usage, data []byte, report *TableReport) bool

func UsageLoadBody 

func UsageLoadBody(r *TableReader, value *Usage) bool

func UsageLoadBodyRetain 

func UsageLoadBodyRetain(r *TableRetainReader, value *Usage) bool

func UsageLoadMessageBody 

func UsageLoadMessageBody(r *TableMessageReader, value *Usage) bool

func UsageLoadMessageBodyRetain 

func UsageLoadMessageBodyRetain(r *TableRetainMessageReader, value *Usage) bool

func UsageLoadMessages 

func UsageLoadMessages(values []Usage, vocabulary *TableVocabulary, data []byte, report *TableReport) (int64, bool)

func UsageMeasure 

func UsageMeasure(value *Usage) int64

func UsageMeasureBody 

func UsageMeasureBody(value *Usage, ids *TableIds) int64

func UsageMeasureBodyRetain 

func UsageMeasureBodyRetain(value *Usage, ids *TableRetainIds) int64

func UsageMeasureMessages 

func UsageMeasureMessages(values []*Usage, report *TableReport) int64

func UsageMeasureReason 

func UsageMeasureReason(value *Usage) (int64, error)

func UsageOpen 

func UsageOpen(cook *UsageCook, base unsafe.Pointer, length int64) bool

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

func UsageReset 

func UsageReset(value *Usage)

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

func UsageSave 

func UsageSave(value *Usage, buffer []byte) int64

func UsageSaveBody 

func UsageSaveBody(w *TableWriter, value *Usage) bool

func UsageSaveBodyFields 

func UsageSaveBodyFields(w *TableWriter, value *Usage) bool

func UsageSaveBodyFieldsRetain 

func UsageSaveBodyFieldsRetain(w *TableRetainWriter, value *Usage) bool

func UsageSaveBodyRetain 

func UsageSaveBodyRetain(w *TableRetainWriter, value *Usage) bool

func UsageSaveMessageBody 

func UsageSaveMessageBody(w *TableMessageWriter, value *Usage) bool

func UsageSaveMessages 

func UsageSaveMessages(values []*Usage, buffer []byte, report *TableReport) int64

func UsageSaveText 

func UsageSaveText(value *Usage) (string, error)

UsageSaveText returns the base64 of Usage'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.

func UsageToJson 

func UsageToJson(value *Usage, buffer []byte) int64

UsageToJson writes Usage's JSON text into the caller's slice and returns the bytes written — exactly UsageToJsonMeasure's answer — or -1 when it is short.

func UsageToJsonMeasure 

func UsageToJsonMeasure(value *Usage) int64

UsageToJsonMeasure is the exact size of Usage's JSON text, writing nothing.

Types

type Act 

type Act = ActRow

func ActEmplace 

func ActEmplace(worker *TableWorker, slot *TableRef) *Act

func ActLoad 

func ActLoad(region, wire []byte, report *TableReport) *Act

func ActLoadRetain 

func ActLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Act

func ActLoadText 

func ActLoadText(text string, report *TableReport) (*Act, error)

ActLoadText reads one Act 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 ActReadStrict 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 ActReadStrict 

func ActReadStrict(wire []byte) (*Act, error)

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

type ActBuilder 

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

func (*ActBuilder) AsConst 

func (b *ActBuilder) AsConst() *Act

func (*ActBuilder) GetRoot 

func (b *ActBuilder) GetRoot() *Act

func (*ActBuilder) Init 

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

func (*ActBuilder) Lock 

func (b *ActBuilder) Lock() bool

func (*ActBuilder) PackMeasure 

func (b *ActBuilder) PackMeasure() int64

func (*ActBuilder) PackMeasureReason 

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

func (*ActBuilder) Region 

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

func (*ActBuilder) Shutdown 

func (b *ActBuilder) Shutdown()

type ActCook 

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

ActCook is Act'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 — ActOpen, ActAt — 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 (*ActCook) Open 

func (cook *ActCook) 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 (ActCook) RegionAlignment 

func (c ActCook) 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 (ActCook) Root 

func (c ActCook) Root() *ActRow

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 (ActCook) RootAlign 

func (c ActCook) RootAlign() int64

func (ActCook) RootSize 

func (c ActCook) RootSize() int64

func (ActCook) Type 

func (c ActCook) Type() *TableCookInfo

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

type ActRow 

type ActRow struct {
	Id   int64 // *: signed self-relative delta, zero is null (§6.3)
	Step int64 // *: signed self-relative delta, zero is null (§6.3)
	Op   int64 // *: signed self-relative delta, zero is null (§6.3)
	At   int64 // *: signed self-relative delta, zero is null (§6.3)
}

ActRow — 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 ActAt 

func ActAt(slot *int64, arena ...*TableArena) *ActRow

ActAt 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 Answer 

type Answer = AnswerRow

func AnswerLoad 

func AnswerLoad(region, wire []byte, report *TableReport) *Answer

func AnswerLoadRetain 

func AnswerLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Answer

func AnswerLoadText 

func AnswerLoadText(text string, report *TableReport) (*Answer, error)

AnswerLoadText reads one Answer 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 AnswerReadStrict 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 AnswerReadStrict 

func AnswerReadStrict(wire []byte) (*Answer, error)

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

type AnswerBuilder 

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

func (*AnswerBuilder) AsConst 

func (b *AnswerBuilder) AsConst() *Answer

func (*AnswerBuilder) GetRoot 

func (b *AnswerBuilder) GetRoot() *Answer

func (*AnswerBuilder) Init 

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

func (*AnswerBuilder) Lock 

func (b *AnswerBuilder) Lock() bool

func (*AnswerBuilder) PackMeasure 

func (b *AnswerBuilder) PackMeasure() int64

func (*AnswerBuilder) PackMeasureReason 

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

func (*AnswerBuilder) Region 

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

func (*AnswerBuilder) Shutdown 

func (b *AnswerBuilder) Shutdown()

type AnswerCook 

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

AnswerCook is Answer'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 — AnswerOpen, AnswerAt — 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 (*AnswerCook) Open 

func (cook *AnswerCook) 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 (AnswerCook) RegionAlignment 

func (c AnswerCook) 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 (AnswerCook) Root 

func (c AnswerCook) Root() *AnswerRow

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 (AnswerCook) RootAlign 

func (c AnswerCook) RootAlign() int64

func (AnswerCook) RootSize 

func (c AnswerCook) RootSize() int64

func (AnswerCook) Type 

func (c AnswerCook) Type() *TableCookInfo

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

type AnswerRow 

type AnswerRow struct {
	Kind AnswerType

	Value      int64 // *: signed self-relative delta, zero is null (§6.3)
	P          TableList[OptionPRow]
	Confidence float64
	Method     int64 // *: signed self-relative delta, zero is null (§6.3)
	// contains filtered or unexported fields
}

AnswerRow — 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 AnswerAt 

func AnswerAt(slot *int64, arena ...*TableArena) *AnswerRow

AnswerAt 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 AnswerType 

type AnswerType uint8

AnswerType — None = 0 implicit, variants dense from 1, wire range [0, 2] (SPEC §4.2) 

const (
	AnswerTypeNone   AnswerType = 0
	AnswerTypeChoice AnswerType = 1
	AnswerTypeNoul   AnswerType = 2
	AnswerTypeCount  AnswerType = 2 // the declared variant count (SPEC §4.2)
	AnswerTypeMax    AnswerType = 2 // the exported extent (SPEC §4.2)
)

func (AnswerType) TableEnumId 

func (value AnswerType) TableEnumId() (uint64, bool)

TableEnumId: AnswerType on the TABLE wire rides as the 64-bit hash of its VARIANT NAME, so a variant may be added anywhere, removed, or reordered and old data still reads (mas-bandwidth/schema docs/SPEC-TABLES.md §5). None uses reference zero; hash zero remains a valid named id. The bool is false when no variant names this value: no wire identity.

func (*AnswerType) TableEnumValue 

func (value *AnswerType) TableEnumValue(id uint64) bool

TableEnumValue resolves a table-wire variant id to a AnswerType, in place. The bool is false for an id this build cannot name; the value is left at None, which is what an unknown variant reads as (mas-bandwidth/schema docs/SPEC-TABLES.md §5).

type Bars 

type Bars = BarsRow

func BarsLoadText 

func BarsLoadText(text string, report *TableReport) (*Bars, error)

BarsLoadText fills one Bars from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8). It is the STRICT read (§6.5) over the decoded wire: it refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant Load 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 BarsReadStrict 

func BarsReadStrict(wire []byte) (*Bars, error)

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

type BarsBlock 

type BarsBlock struct {
	Base       unsafe.Pointer       // the extent's base, 64-byte aligned
	Projection *BarsBlockProjection // the projection, at offset 0
	Bytes      int64                // the extent in use
}

BarsBlock is Bars's block: a pointer and a length, and then rows in place. Opening one is ONE check and no copy; reading a row is one add (§19.2).

The bytes belong to the CONSUMER — a []byte it owns, an mmap, or memory a producer handed across. Nothing here allocates.

A block is valid until the next fill over the SAME storage, which invalidates every block over it and every row pointer taken from one.

func (*BarsBlock) Open 

func (block *BarsBlock) Open(base unsafe.Pointer, bytes int64) error

Open reads all prologue and layout words bytewise before the final base alignment check. Every refusal names the first failed clause in SPEC §19.2.

func (*BarsBlock) Type 

func (b *BarsBlock) Type() *TableBlockInfo

Type is this block's descriptors: constant data, so a reflective read costs a lookup and not a parse. The row layouts hang off the element column rather than taking names of their own, so a walker reaches every record through the graph.

type BarsBlockProjection 

type BarsBlockProjection struct {
	Magic        uint64 // generated: identifies a schema block
	BuildVersion uint64 // generated: the unit's build version (mas-bandwidth/schema docs/SPEC-TABLES.md §20)
	ByteOrder    uint64 // generated: 1 little, 2 big
	Bounce       float64
	Review       float64
}

BarsBlockProjection — the block PROJECTION: the table's own instance as it sits at the front of a block, opening with the generated PROLOGUE and carrying, per out-of-line array, the triple that says where its rows are. It is a record like any other and follows the same C ABI rule (§19.3).

It is a SEPARATE record from BarsRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type BarsBlockStorage 

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

BarsBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*BarsBlockStorage) Create 

func (s *BarsBlockStorage) Create(a TableBlockAllocator) bool

func (*BarsBlockStorage) Destroy 

func (s *BarsBlockStorage) Destroy()

type BarsCook 

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

BarsCook is Bars'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 — BarsOpen, BarsAt — 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 (*BarsCook) Open 

func (cook *BarsCook) 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 (BarsCook) RegionAlignment 

func (c BarsCook) 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 (BarsCook) Root 

func (c BarsCook) Root() *BarsRow

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 (BarsCook) RootAlign 

func (c BarsCook) RootAlign() int64

func (BarsCook) RootSize 

func (c BarsCook) RootSize() int64

func (BarsCook) Type 

func (c BarsCook) Type() *TableCookInfo

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

type BarsCounts 

type BarsCounts struct {
}

BarsCounts is gathered before Begin; clamping is the caller's policy.

type BarsRow 

type BarsRow struct {
	Bounce float64
	Review float64
}

BarsRow — 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 BarsAt 

func BarsAt(slot *int64, arena ...*TableArena) *BarsRow

BarsAt 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 Billing 

type Billing uint8

Billing — None = 0 implicit, variants dense from 1, wire range [0, 3] (SPEC §4.2) 

const (
	BillingNone         Billing = 0
	BillingMetered      Billing = 1
	BillingPlan         Billing = 2
	BillingSubscription Billing = 3
	BillingCount        Billing = 3 // the declared variant count (SPEC §4.2)
	BillingMax          Billing = 3 // the exported extent (SPEC §4.2)
)

func (Billing) TableEnumId 

func (value Billing) TableEnumId() (uint64, bool)

TableEnumId: Billing on the TABLE wire rides as the 64-bit hash of its VARIANT NAME, so a variant may be added anywhere, removed, or reordered and old data still reads (mas-bandwidth/schema docs/SPEC-TABLES.md §5). None uses reference zero; hash zero remains a valid named id. The bool is false when no variant names this value: no wire identity.

func (*Billing) TableEnumValue 

func (value *Billing) TableEnumValue(id uint64) bool

TableEnumValue resolves a table-wire variant id to a Billing, in place. The bool is false for an id this build cannot name; the value is left at None, which is what an unknown variant reads as (mas-bandwidth/schema docs/SPEC-TABLES.md §5).

type Chosen 

type Chosen = ChosenRow

func ChosenLoad 

func ChosenLoad(region, wire []byte, report *TableReport) *Chosen

func ChosenLoadRetain 

func ChosenLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Chosen

func ChosenLoadText 

func ChosenLoadText(text string, report *TableReport) (*Chosen, error)

ChosenLoadText reads one Chosen 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 ChosenReadStrict 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 ChosenReadStrict 

func ChosenReadStrict(wire []byte) (*Chosen, error)

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

type ChosenBuilder 

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

func (*ChosenBuilder) AsConst 

func (b *ChosenBuilder) AsConst() *Chosen

func (*ChosenBuilder) GetRoot 

func (b *ChosenBuilder) GetRoot() *Chosen

func (*ChosenBuilder) Init 

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

func (*ChosenBuilder) Lock 

func (b *ChosenBuilder) Lock() bool

func (*ChosenBuilder) PackMeasure 

func (b *ChosenBuilder) PackMeasure() int64

func (*ChosenBuilder) PackMeasureReason 

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

func (*ChosenBuilder) Region 

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

func (*ChosenBuilder) Shutdown 

func (b *ChosenBuilder) Shutdown()

type ChosenCook 

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

ChosenCook is Chosen'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 — ChosenOpen, ChosenAt — 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 (*ChosenCook) Open 

func (cook *ChosenCook) 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 (ChosenCook) RegionAlignment 

func (c ChosenCook) 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 (ChosenCook) Root 

func (c ChosenCook) Root() *ChosenRow

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 (ChosenCook) RootAlign 

func (c ChosenCook) RootAlign() int64

func (ChosenCook) RootSize 

func (c ChosenCook) RootSize() int64

func (ChosenCook) Type 

func (c ChosenCook) Type() *TableCookInfo

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

type ChosenRow 

type ChosenRow struct {
	Verb   int64 // *: signed self-relative delta, zero is null (§6.3)
	P      float64
	Fix    int64 // *: signed self-relative delta, zero is null (§6.3)
	Reason int64 // *: signed self-relative delta, zero is null (§6.3)
	Act    int64 // *: signed self-relative delta, zero is null (§6.3)
	Why    int64 // *: signed self-relative delta, zero is null (§6.3)
}

ChosenRow — 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 ChosenAt 

func ChosenAt(slot *int64, arena ...*TableArena) *ChosenRow

ChosenAt 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 Cluster 

type Cluster = ClusterRow

func ClusterLoad 

func ClusterLoad(region, wire []byte, report *TableReport) *Cluster

func ClusterLoadRetain 

func ClusterLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Cluster

func ClusterLoadText 

func ClusterLoadText(text string, report *TableReport) (*Cluster, error)

ClusterLoadText reads one Cluster 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 ClusterReadStrict 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 ClusterReadStrict 

func ClusterReadStrict(wire []byte) (*Cluster, error)

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

type ClusterBuilder 

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

func (*ClusterBuilder) AsConst 

func (b *ClusterBuilder) AsConst() *Cluster

func (*ClusterBuilder) GetRoot 

func (b *ClusterBuilder) GetRoot() *Cluster

func (*ClusterBuilder) Init 

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

func (*ClusterBuilder) Lock 

func (b *ClusterBuilder) Lock() bool

func (*ClusterBuilder) PackMeasure 

func (b *ClusterBuilder) PackMeasure() int64

func (*ClusterBuilder) PackMeasureReason 

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

func (*ClusterBuilder) Region 

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

func (*ClusterBuilder) Shutdown 

func (b *ClusterBuilder) Shutdown()

type ClusterCard 

type ClusterCard = ClusterCardRow

func ClusterCardLoad 

func ClusterCardLoad(region, wire []byte, report *TableReport) *ClusterCard

func ClusterCardLoadRetain 

func ClusterCardLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *ClusterCard

func ClusterCardLoadText 

func ClusterCardLoadText(text string, report *TableReport) (*ClusterCard, error)

ClusterCardLoadText reads one ClusterCard 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 ClusterCardReadStrict 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 ClusterCardReadStrict 

func ClusterCardReadStrict(wire []byte) (*ClusterCard, error)

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

type ClusterCardBuilder 

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

func (*ClusterCardBuilder) AsConst 

func (b *ClusterCardBuilder) AsConst() *ClusterCard

func (*ClusterCardBuilder) GetRoot 

func (b *ClusterCardBuilder) GetRoot() *ClusterCard

func (*ClusterCardBuilder) Init 

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

func (*ClusterCardBuilder) Lock 

func (b *ClusterCardBuilder) Lock() bool

func (*ClusterCardBuilder) PackMeasure 

func (b *ClusterCardBuilder) PackMeasure() int64

func (*ClusterCardBuilder) PackMeasureReason 

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

func (*ClusterCardBuilder) Region 

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

func (*ClusterCardBuilder) Shutdown 

func (b *ClusterCardBuilder) Shutdown()

type ClusterCardCook 

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

ClusterCardCook is ClusterCard'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 — ClusterCardOpen, ClusterCardAt — 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 (*ClusterCardCook) Open 

func (cook *ClusterCardCook) 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 (ClusterCardCook) RegionAlignment 

func (c ClusterCardCook) 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 (ClusterCardCook) Root 

func (c ClusterCardCook) Root() *ClusterCardRow

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 (ClusterCardCook) RootAlign 

func (c ClusterCardCook) RootAlign() int64

func (ClusterCardCook) RootSize 

func (c ClusterCardCook) RootSize() int64

func (ClusterCardCook) Type 

func (c ClusterCardCook) Type() *TableCookInfo

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

type ClusterCardRow 

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

ClusterCardRow — 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 ClusterCardAt 

func ClusterCardAt(slot *int64, arena ...*TableArena) *ClusterCardRow

ClusterCardAt 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.

func ClusterCardsAdd 

func ClusterCardsAdd(worker *TableWorker, holder *TableList[ClusterCardRow]) *ClusterCardRow

type ClusterCook 

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

ClusterCook is Cluster'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 — ClusterOpen, ClusterAt — 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 (*ClusterCook) Open 

func (cook *ClusterCook) 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 (ClusterCook) RegionAlignment 

func (c ClusterCook) 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 (ClusterCook) Root 

func (c ClusterCook) Root() *ClusterRow

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 (ClusterCook) RootAlign 

func (c ClusterCook) RootAlign() int64

func (ClusterCook) RootSize 

func (c ClusterCook) RootSize() int64

func (ClusterCook) Type 

func (c ClusterCook) Type() *TableCookInfo

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

type ClusterRow 

type ClusterRow struct {
	ClassName int64 // *: signed self-relative delta, zero is null (§6.3)
	Count     int64
	Cards     TableList[ClusterCardRow]
}

ClusterRow — 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 ClusterAt 

func ClusterAt(slot *int64, arena ...*TableArena) *ClusterRow

ClusterAt 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 Criterion 

type Criterion = CriterionRow

func CriterionLoad 

func CriterionLoad(region, wire []byte, report *TableReport) *Criterion

func CriterionLoadRetain 

func CriterionLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Criterion

func CriterionLoadText 

func CriterionLoadText(text string, report *TableReport) (*Criterion, error)

CriterionLoadText reads one Criterion 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 CriterionReadStrict 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 CriterionReadStrict 

func CriterionReadStrict(wire []byte) (*Criterion, error)

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

type CriterionBuilder 

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

func (*CriterionBuilder) AsConst 

func (b *CriterionBuilder) AsConst() *Criterion

func (*CriterionBuilder) GetRoot 

func (b *CriterionBuilder) GetRoot() *Criterion

func (*CriterionBuilder) Init 

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

func (*CriterionBuilder) Lock 

func (b *CriterionBuilder) Lock() bool

func (*CriterionBuilder) PackMeasure 

func (b *CriterionBuilder) PackMeasure() int64

func (*CriterionBuilder) PackMeasureReason 

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

func (*CriterionBuilder) Region 

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

func (*CriterionBuilder) Shutdown 

func (b *CriterionBuilder) Shutdown()

type CriterionCook 

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

CriterionCook is Criterion'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 — CriterionOpen, CriterionAt — 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 (*CriterionCook) Open 

func (cook *CriterionCook) 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 (CriterionCook) RegionAlignment 

func (c CriterionCook) 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 (CriterionCook) Root 

func (c CriterionCook) Root() *CriterionRow

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 (CriterionCook) RootAlign 

func (c CriterionCook) RootAlign() int64

func (CriterionCook) RootSize 

func (c CriterionCook) RootSize() int64

func (CriterionCook) Type 

func (c CriterionCook) Type() *TableCookInfo

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

type CriterionRow 

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

CriterionRow — 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 CriterionAt 

func CriterionAt(slot *int64, arena ...*TableArena) *CriterionRow

CriterionAt 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.

func QuestionCriteriaAdd 

func QuestionCriteriaAdd(worker *TableWorker, holder *TableList[CriterionRow]) *CriterionRow

type DecideSchema 

type DecideSchema = DecideSchemaRow

func DecideSchemaLoad 

func DecideSchemaLoad(region, wire []byte, report *TableReport) *DecideSchema

func DecideSchemaLoadRetain 

func DecideSchemaLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *DecideSchema

func DecideSchemaLoadText 

func DecideSchemaLoadText(text string, report *TableReport) (*DecideSchema, error)

DecideSchemaLoadText reads one DecideSchema 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 DecideSchemaReadStrict 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 DecideSchemaReadStrict 

func DecideSchemaReadStrict(wire []byte) (*DecideSchema, error)

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

type DecideSchemaBuilder 

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

func (*DecideSchemaBuilder) AsConst 

func (b *DecideSchemaBuilder) AsConst() *DecideSchema

func (*DecideSchemaBuilder) GetRoot 

func (b *DecideSchemaBuilder) GetRoot() *DecideSchema

func (*DecideSchemaBuilder) Init 

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

func (*DecideSchemaBuilder) Lock 

func (b *DecideSchemaBuilder) Lock() bool

func (*DecideSchemaBuilder) PackMeasure 

func (b *DecideSchemaBuilder) PackMeasure() int64

func (*DecideSchemaBuilder) PackMeasureReason 

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

func (*DecideSchemaBuilder) Region 

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

func (*DecideSchemaBuilder) Shutdown 

func (b *DecideSchemaBuilder) Shutdown()

type DecideSchemaCook 

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

DecideSchemaCook is DecideSchema'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 — DecideSchemaOpen, DecideSchemaAt — 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 (*DecideSchemaCook) Open 

func (cook *DecideSchemaCook) 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 (DecideSchemaCook) RegionAlignment 

func (c DecideSchemaCook) 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 (DecideSchemaCook) Root 

func (c DecideSchemaCook) Root() *DecideSchemaRow

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 (DecideSchemaCook) RootAlign 

func (c DecideSchemaCook) RootAlign() int64

func (DecideSchemaCook) RootSize 

func (c DecideSchemaCook) RootSize() int64

func (DecideSchemaCook) Type 

func (c DecideSchemaCook) Type() *TableCookInfo

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

type DecideSchemaRow 

type DecideSchemaRow struct {
	Name      int64 // *: signed self-relative delta, zero is null (§6.3)
	Questions TableList[NamedQuestionRow]
}

DecideSchemaRow — 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 DecideSchemaAt 

func DecideSchemaAt(slot *int64, arena ...*TableArena) *DecideSchemaRow

DecideSchemaAt 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 Decided 

type Decided = DecidedRow

func DecidedLoad 

func DecidedLoad(region, wire []byte, report *TableReport) *Decided

func DecidedLoadRetain 

func DecidedLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Decided

func DecidedLoadText 

func DecidedLoadText(text string, report *TableReport) (*Decided, error)

DecidedLoadText reads one Decided 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 DecidedReadStrict 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 DecidedReadStrict 

func DecidedReadStrict(wire []byte) (*Decided, error)

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

type DecidedBuilder 

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

func (*DecidedBuilder) AsConst 

func (b *DecidedBuilder) AsConst() *Decided

func (*DecidedBuilder) GetRoot 

func (b *DecidedBuilder) GetRoot() *Decided

func (*DecidedBuilder) Init 

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

func (*DecidedBuilder) Lock 

func (b *DecidedBuilder) Lock() bool

func (*DecidedBuilder) PackMeasure 

func (b *DecidedBuilder) PackMeasure() int64

func (*DecidedBuilder) PackMeasureReason 

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

func (*DecidedBuilder) Region 

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

func (*DecidedBuilder) Shutdown 

func (b *DecidedBuilder) Shutdown()

type DecidedCook 

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

DecidedCook is Decided'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 — DecidedOpen, DecidedAt — 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 (*DecidedCook) Open 

func (cook *DecidedCook) 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 (DecidedCook) RegionAlignment 

func (c DecidedCook) 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 (DecidedCook) Root 

func (c DecidedCook) Root() *DecidedRow

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 (DecidedCook) RootAlign 

func (c DecidedCook) RootAlign() int64

func (DecidedCook) RootSize 

func (c DecidedCook) RootSize() int64

func (DecidedCook) Type 

func (c DecidedCook) Type() *TableCookInfo

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

type DecidedRow 

type DecidedRow struct {
	Value int64 // *: signed self-relative delta, zero is null (§6.3)
	P     float64
	Op    int64 // *: signed self-relative delta, zero is null (§6.3)
}

DecidedRow — 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 DecidedAt 

func DecidedAt(slot *int64, arena ...*TableArena) *DecidedRow

DecidedAt 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 Decision 

type Decision = DecisionRow

func DecisionEmplace 

func DecisionEmplace(worker *TableWorker, slot *TableRef) *Decision

func DecisionLoad 

func DecisionLoad(region, wire []byte, report *TableReport) *Decision

func DecisionLoadRetain 

func DecisionLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Decision

func DecisionLoadText 

func DecisionLoadText(text string, report *TableReport) (*Decision, error)

DecisionLoadText reads one Decision 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 DecisionReadStrict 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 DecisionReadStrict 

func DecisionReadStrict(wire []byte) (*Decision, error)

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

type DecisionBuilder 

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

func (*DecisionBuilder) AsConst 

func (b *DecisionBuilder) AsConst() *Decision

func (*DecisionBuilder) GetRoot 

func (b *DecisionBuilder) GetRoot() *Decision

func (*DecisionBuilder) Init 

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

func (*DecisionBuilder) Lock 

func (b *DecisionBuilder) Lock() bool

func (*DecisionBuilder) PackMeasure 

func (b *DecisionBuilder) PackMeasure() int64

func (*DecisionBuilder) PackMeasureReason 

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

func (*DecisionBuilder) Region 

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

func (*DecisionBuilder) Shutdown 

func (b *DecisionBuilder) Shutdown()

type DecisionCook 

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

DecisionCook is Decision'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 — DecisionOpen, DecisionAt — 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 (*DecisionCook) Open 

func (cook *DecisionCook) 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 (DecisionCook) RegionAlignment 

func (c DecisionCook) 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 (DecisionCook) Root 

func (c DecisionCook) Root() *DecisionRow

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 (DecisionCook) RootAlign 

func (c DecisionCook) RootAlign() int64

func (DecisionCook) RootSize 

func (c DecisionCook) RootSize() int64

func (DecisionCook) Type 

func (c DecisionCook) Type() *TableCookInfo

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

type DecisionRow 

type DecisionRow struct {
	Id           int64 // *: signed self-relative delta, zero is null (§6.3)
	DecisionName int64 // *: signed self-relative delta, zero is null (§6.3)
	Schema       int64 // *: signed self-relative delta, zero is null (§6.3)
	Backend      int64 // *: signed self-relative delta, zero is null (§6.3)
	At           int64 // *: signed self-relative delta, zero is null (§6.3)
	Inputs       TableList[InputRow]
	State        int64 // *: signed self-relative delta, zero is null (§6.3)
	Answers      TableList[NamedAnswerRow]
	Usage        UsageRow
}

DecisionRow — 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 DecisionAt 

func DecisionAt(slot *int64, arena ...*TableArena) *DecisionRow

DecisionAt 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 Example 

type Example = ExampleRow

func ExampleLoad 

func ExampleLoad(region, wire []byte, report *TableReport) *Example

func ExampleLoadRetain 

func ExampleLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Example

func ExampleLoadText 

func ExampleLoadText(text string, report *TableReport) (*Example, error)

ExampleLoadText reads one Example 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 ExampleReadStrict 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 ExampleReadStrict 

func ExampleReadStrict(wire []byte) (*Example, error)

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

type ExampleBuilder 

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

func (*ExampleBuilder) AsConst 

func (b *ExampleBuilder) AsConst() *Example

func (*ExampleBuilder) GetRoot 

func (b *ExampleBuilder) GetRoot() *Example

func (*ExampleBuilder) Init 

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

func (*ExampleBuilder) Lock 

func (b *ExampleBuilder) Lock() bool

func (*ExampleBuilder) PackMeasure 

func (b *ExampleBuilder) PackMeasure() int64

func (*ExampleBuilder) PackMeasureReason 

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

func (*ExampleBuilder) Region 

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

func (*ExampleBuilder) Shutdown 

func (b *ExampleBuilder) Shutdown()

type ExampleCook 

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

ExampleCook is Example'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 — ExampleOpen, ExampleAt — 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 (*ExampleCook) Open 

func (cook *ExampleCook) 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 (ExampleCook) RegionAlignment 

func (c ExampleCook) 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 (ExampleCook) Root 

func (c ExampleCook) Root() *ExampleRow

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 (ExampleCook) RootAlign 

func (c ExampleCook) RootAlign() int64

func (ExampleCook) RootSize 

func (c ExampleCook) RootSize() int64

func (ExampleCook) Type 

func (c ExampleCook) Type() *TableCookInfo

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

type ExampleLabel 

type ExampleLabel uint8

ExampleLabel — None = 0 implicit, variants dense from 1, wire range [0, 3] (SPEC §4.2) 

const (
	ExampleLabelNone  ExampleLabel = 0
	ExampleLabelFlash ExampleLabel = 1
	ExampleLabelPro   ExampleLabel = 2
	ExampleLabelHeavy ExampleLabel = 3
	ExampleLabelCount ExampleLabel = 3 // the declared variant count (SPEC §4.2)
	ExampleLabelMax   ExampleLabel = 3 // the exported extent (SPEC §4.2)
)

func (ExampleLabel) TableEnumId 

func (value ExampleLabel) TableEnumId() (uint64, bool)

TableEnumId: ExampleLabel on the TABLE wire rides as the 64-bit hash of its VARIANT NAME, so a variant may be added anywhere, removed, or reordered and old data still reads (mas-bandwidth/schema docs/SPEC-TABLES.md §5). None uses reference zero; hash zero remains a valid named id. The bool is false when no variant names this value: no wire identity.

func (*ExampleLabel) TableEnumValue 

func (value *ExampleLabel) TableEnumValue(id uint64) bool

TableEnumValue resolves a table-wire variant id to a ExampleLabel, in place. The bool is false for an id this build cannot name; the value is left at None, which is what an unknown variant reads as (mas-bandwidth/schema docs/SPEC-TABLES.md §5).

type ExampleRow 

type ExampleRow struct {
	Card    int64 // *: signed self-relative delta, zero is null (§6.3)
	Heading int64 // *: signed self-relative delta, zero is null (§6.3)
	Paths   int64 // *: signed self-relative delta, zero is null (§6.3)
	Kind    int64 // *: signed self-relative delta, zero is null (§6.3)
	Label   ExampleLabel
	// contains filtered or unexported fields
}

ExampleRow — 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 ExampleAt 

func ExampleAt(slot *int64, arena ...*TableArena) *ExampleRow

ExampleAt 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 Failure 

type Failure = FailureRow

func FailureLoad 

func FailureLoad(region, wire []byte, report *TableReport) *Failure

func FailureLoadRetain 

func FailureLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Failure

func FailureLoadText 

func FailureLoadText(text string, report *TableReport) (*Failure, error)

FailureLoadText reads one Failure 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 FailureReadStrict 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 FailureReadStrict 

func FailureReadStrict(wire []byte) (*Failure, error)

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

type FailureBuilder 

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

func (*FailureBuilder) AsConst 

func (b *FailureBuilder) AsConst() *Failure

func (*FailureBuilder) GetRoot 

func (b *FailureBuilder) GetRoot() *Failure

func (*FailureBuilder) Init 

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

func (*FailureBuilder) Lock 

func (b *FailureBuilder) Lock() bool

func (*FailureBuilder) PackMeasure 

func (b *FailureBuilder) PackMeasure() int64

func (*FailureBuilder) PackMeasureReason 

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

func (*FailureBuilder) Region 

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

func (*FailureBuilder) Shutdown 

func (b *FailureBuilder) Shutdown()

type FailureCook 

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

FailureCook is Failure'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 — FailureOpen, FailureAt — 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 (*FailureCook) Open 

func (cook *FailureCook) 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 (FailureCook) RegionAlignment 

func (c FailureCook) 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 (FailureCook) Root 

func (c FailureCook) Root() *FailureRow

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 (FailureCook) RootAlign 

func (c FailureCook) RootAlign() int64

func (FailureCook) RootSize 

func (c FailureCook) RootSize() int64

func (FailureCook) Type 

func (c FailureCook) Type() *TableCookInfo

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

type FailureRow 

type FailureRow struct {
	Pkg   int64 // *: signed self-relative delta, zero is null (§6.3)
	Test  int64 // *: signed self-relative delta, zero is null (§6.3)
	Lines TableList[GateLineRow]
}

FailureRow — 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 FailureAt 

func FailureAt(slot *int64, arena ...*TableArena) *FailureRow

FailureAt 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 FixedAnswer 

type FixedAnswer = FixedAnswerRow

func FixedAnswerLoad 

func FixedAnswerLoad(region, wire []byte, report *TableReport) *FixedAnswer

func FixedAnswerLoadRetain 

func FixedAnswerLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *FixedAnswer

func FixedAnswerLoadText 

func FixedAnswerLoadText(text string, report *TableReport) (*FixedAnswer, error)

FixedAnswerLoadText reads one FixedAnswer 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 FixedAnswerReadStrict 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 FixedAnswerReadStrict 

func FixedAnswerReadStrict(wire []byte) (*FixedAnswer, error)

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

type FixedAnswerBuilder 

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

func (*FixedAnswerBuilder) AsConst 

func (b *FixedAnswerBuilder) AsConst() *FixedAnswer

func (*FixedAnswerBuilder) GetRoot 

func (b *FixedAnswerBuilder) GetRoot() *FixedAnswer

func (*FixedAnswerBuilder) Init 

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

func (*FixedAnswerBuilder) Lock 

func (b *FixedAnswerBuilder) Lock() bool

func (*FixedAnswerBuilder) PackMeasure 

func (b *FixedAnswerBuilder) PackMeasure() int64

func (*FixedAnswerBuilder) PackMeasureReason 

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

func (*FixedAnswerBuilder) Region 

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

func (*FixedAnswerBuilder) Shutdown 

func (b *FixedAnswerBuilder) Shutdown()

type FixedAnswerCook 

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

FixedAnswerCook is FixedAnswer'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 — FixedAnswerOpen, FixedAnswerAt — 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 (*FixedAnswerCook) Open 

func (cook *FixedAnswerCook) 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 (FixedAnswerCook) RegionAlignment 

func (c FixedAnswerCook) 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 (FixedAnswerCook) Root 

func (c FixedAnswerCook) Root() *FixedAnswerRow

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 (FixedAnswerCook) RootAlign 

func (c FixedAnswerCook) RootAlign() int64

func (FixedAnswerCook) RootSize 

func (c FixedAnswerCook) RootSize() int64

func (FixedAnswerCook) Type 

func (c FixedAnswerCook) Type() *TableCookInfo

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

type FixedAnswerRow 

type FixedAnswerRow struct {
	Choice      int64 // *: signed self-relative delta, zero is null (§6.3)
	P           TableList[OptionPRow]
	Noul        float64
	NoulPresent bool // ?: one byte, in Go's model as in C++
	// contains filtered or unexported fields
}

FixedAnswerRow — 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 FixedAnswerAt 

func FixedAnswerAt(slot *int64, arena ...*TableArena) *FixedAnswerRow

FixedAnswerAt 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 FixedTable 

type FixedTable = FixedTableRow

func FixedTableLoad 

func FixedTableLoad(region, wire []byte, report *TableReport) *FixedTable

func FixedTableLoadRetain 

func FixedTableLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *FixedTable

func FixedTableLoadText 

func FixedTableLoadText(text string, report *TableReport) (*FixedTable, error)

FixedTableLoadText reads one FixedTable 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 FixedTableReadStrict 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 FixedTableReadStrict 

func FixedTableReadStrict(wire []byte) (*FixedTable, error)

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

type FixedTableBuilder 

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

func (*FixedTableBuilder) AsConst 

func (b *FixedTableBuilder) AsConst() *FixedTable

func (*FixedTableBuilder) GetRoot 

func (b *FixedTableBuilder) GetRoot() *FixedTable

func (*FixedTableBuilder) Init 

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

func (*FixedTableBuilder) Lock 

func (b *FixedTableBuilder) Lock() bool

func (*FixedTableBuilder) PackMeasure 

func (b *FixedTableBuilder) PackMeasure() int64

func (*FixedTableBuilder) PackMeasureReason 

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

func (*FixedTableBuilder) Region 

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

func (*FixedTableBuilder) Shutdown 

func (b *FixedTableBuilder) Shutdown()

type FixedTableCook 

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

FixedTableCook is FixedTable'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 — FixedTableOpen, FixedTableAt — 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 (*FixedTableCook) Open 

func (cook *FixedTableCook) 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 (FixedTableCook) RegionAlignment 

func (c FixedTableCook) 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 (FixedTableCook) Root 

func (c FixedTableCook) Root() *FixedTableRow

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 (FixedTableCook) RootAlign 

func (c FixedTableCook) RootAlign() int64

func (FixedTableCook) RootSize 

func (c FixedTableCook) RootSize() int64

func (FixedTableCook) Type 

func (c FixedTableCook) Type() *TableCookInfo

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

type FixedTableRow 

type FixedTableRow struct {
	Answers TableList[NamedFixedAnswerRow]
}

FixedTableRow — 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 FixedTableAt 

func FixedTableAt(slot *int64, arena ...*TableArena) *FixedTableRow

FixedTableAt 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 Frame 

type Frame = FrameRow

func FrameLoad 

func FrameLoad(region, wire []byte, report *TableReport) *Frame

func FrameLoadRetain 

func FrameLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Frame

func FrameLoadText 

func FrameLoadText(text string, report *TableReport) (*Frame, error)

FrameLoadText reads one Frame 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 FrameReadStrict 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 FrameReadStrict 

func FrameReadStrict(wire []byte) (*Frame, error)

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

type FrameBuilder 

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

func (*FrameBuilder) AsConst 

func (b *FrameBuilder) AsConst() *Frame

func (*FrameBuilder) GetRoot 

func (b *FrameBuilder) GetRoot() *Frame

func (*FrameBuilder) Init 

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

func (*FrameBuilder) Lock 

func (b *FrameBuilder) Lock() bool

func (*FrameBuilder) PackMeasure 

func (b *FrameBuilder) PackMeasure() int64

func (*FrameBuilder) PackMeasureReason 

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

func (*FrameBuilder) Region 

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

func (*FrameBuilder) Shutdown 

func (b *FrameBuilder) Shutdown()

type FrameCook 

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

FrameCook is Frame'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 — FrameOpen, FrameAt — 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 (*FrameCook) Open 

func (cook *FrameCook) 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 (FrameCook) RegionAlignment 

func (c FrameCook) 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 (FrameCook) Root 

func (c FrameCook) Root() *FrameRow

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 (FrameCook) RootAlign 

func (c FrameCook) RootAlign() int64

func (FrameCook) RootSize 

func (c FrameCook) RootSize() int64

func (FrameCook) Type 

func (c FrameCook) Type() *TableCookInfo

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

type FrameKind 

type FrameKind uint8

FrameKind — None = 0 implicit, variants dense from 1, wire range [0, 2] (SPEC §4.2) 

const (
	FrameKindNone  FrameKind = 0
	FrameKindWork  FrameKind = 1
	FrameKindRead  FrameKind = 2
	FrameKindCount FrameKind = 2 // the declared variant count (SPEC §4.2)
	FrameKindMax   FrameKind = 2 // the exported extent (SPEC §4.2)
)

func (FrameKind) TableEnumId 

func (value FrameKind) TableEnumId() (uint64, bool)

TableEnumId: FrameKind on the TABLE wire rides as the 64-bit hash of its VARIANT NAME, so a variant may be added anywhere, removed, or reordered and old data still reads (mas-bandwidth/schema docs/SPEC-TABLES.md §5). None uses reference zero; hash zero remains a valid named id. The bool is false when no variant names this value: no wire identity.

func (*FrameKind) TableEnumValue 

func (value *FrameKind) TableEnumValue(id uint64) bool

TableEnumValue resolves a table-wire variant id to a FrameKind, in place. The bool is false for an id this build cannot name; the value is left at None, which is what an unknown variant reads as (mas-bandwidth/schema docs/SPEC-TABLES.md §5).

type FrameRow 

type FrameRow struct {
	Kind FrameKind

	Card                  int64 // *: signed self-relative delta, zero is null (§6.3)
	Attempt               int64
	Tier                  int64 // *: signed self-relative delta, zero is null (§6.3)
	Model                 int64 // *: signed self-relative delta, zero is null (§6.3)
	Repo                  int64 // *: signed self-relative delta, zero is null (§6.3)
	BaseRef               int64 // *: signed self-relative delta, zero is null (§6.3)
	StageSha              int64 // *: signed self-relative delta, zero is null (§6.3)
	Branch                int64 // *: signed self-relative delta, zero is null (§6.3)
	PrevHead              int64 // *: signed self-relative delta, zero is null (§6.3)
	PrevAttempt           int64
	Why                   int64 // *: signed self-relative delta, zero is null (§6.3)
	Finding               int64 // *: signed self-relative delta, zero is null (§6.3)
	Fix                   int64 // *: signed self-relative delta, zero is null (§6.3)
	ReviewBase            int64 // *: signed self-relative delta, zero is null (§6.3)
	Stage                 TableList[StagePathRow]
	Recipes               int64 // *: signed self-relative delta, zero is null (§6.3)
	DecideBounce          int64 // *: signed self-relative delta, zero is null (§6.3)
	DecideReview          int64 // *: signed self-relative delta, zero is null (§6.3)
	DecideGateFlaky       int64 // *: signed self-relative delta, zero is null (§6.3)
	DecideGatePreexisting int64 // *: signed self-relative delta, zero is null (§6.3)
	// contains filtered or unexported fields
}

FrameRow — 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 FrameAt 

func FrameAt(slot *int64, arena ...*TableArena) *FrameRow

FrameAt 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 GateBars 

type GateBars = GateBarsRow

func GateBarsLoadText 

func GateBarsLoadText(text string, report *TableReport) (*GateBars, error)

GateBarsLoadText fills one GateBars from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8). It is the STRICT read (§6.5) over the decoded wire: it refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant Load 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 GateBarsReadStrict 

func GateBarsReadStrict(wire []byte) (*GateBars, error)

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

type GateBarsBlock 

type GateBarsBlock struct {
	Base       unsafe.Pointer           // the extent's base, 64-byte aligned
	Projection *GateBarsBlockProjection // the projection, at offset 0
	Bytes      int64                    // the extent in use
}

GateBarsBlock is GateBars's block: a pointer and a length, and then rows in place. Opening one is ONE check and no copy; reading a row is one add (§19.2).

The bytes belong to the CONSUMER — a []byte it owns, an mmap, or memory a producer handed across. Nothing here allocates.

A block is valid until the next fill over the SAME storage, which invalidates every block over it and every row pointer taken from one.

func (*GateBarsBlock) Open 

func (block *GateBarsBlock) Open(base unsafe.Pointer, bytes int64) error

Open reads all prologue and layout words bytewise before the final base alignment check. Every refusal names the first failed clause in SPEC §19.2.

func (*GateBarsBlock) Type 

func (b *GateBarsBlock) Type() *TableBlockInfo

Type is this block's descriptors: constant data, so a reflective read costs a lookup and not a parse. The row layouts hang off the element column rather than taking names of their own, so a walker reaches every record through the graph.

type GateBarsBlockProjection 

type GateBarsBlockProjection struct {
	Magic        uint64 // generated: identifies a schema block
	BuildVersion uint64 // generated: the unit's build version (mas-bandwidth/schema docs/SPEC-TABLES.md §20)
	ByteOrder    uint64 // generated: 1 little, 2 big
	Flaky        float64
	PreExisting  float64
}

GateBarsBlockProjection — the block PROJECTION: the table's own instance as it sits at the front of a block, opening with the generated PROLOGUE and carrying, per out-of-line array, the triple that says where its rows are. It is a record like any other and follows the same C ABI rule (§19.3).

It is a SEPARATE record from GateBarsRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type GateBarsBlockStorage 

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

GateBarsBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*GateBarsBlockStorage) Create 

func (s *GateBarsBlockStorage) Create(a TableBlockAllocator) bool

func (*GateBarsBlockStorage) Destroy 

func (s *GateBarsBlockStorage) Destroy()

type GateBarsCook 

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

GateBarsCook is GateBars'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 — GateBarsOpen, GateBarsAt — 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 (*GateBarsCook) Open 

func (cook *GateBarsCook) 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 (GateBarsCook) RegionAlignment 

func (c GateBarsCook) 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 (GateBarsCook) Root 

func (c GateBarsCook) Root() *GateBarsRow

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 (GateBarsCook) RootAlign 

func (c GateBarsCook) RootAlign() int64

func (GateBarsCook) RootSize 

func (c GateBarsCook) RootSize() int64

func (GateBarsCook) Type 

func (c GateBarsCook) Type() *TableCookInfo

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

type GateBarsCounts 

type GateBarsCounts struct {
}

GateBarsCounts is gathered before Begin; clamping is the caller's policy.

type GateBarsRow 

type GateBarsRow struct {
	Flaky       float64
	PreExisting float64
}

GateBarsRow — 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 GateBarsAt 

func GateBarsAt(slot *int64, arena ...*TableArena) *GateBarsRow

GateBarsAt 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 GateLine 

type GateLine = GateLineRow

func GateLineLoad 

func GateLineLoad(region, wire []byte, report *TableReport) *GateLine

func GateLineLoadRetain 

func GateLineLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *GateLine

func GateLineLoadText 

func GateLineLoadText(text string, report *TableReport) (*GateLine, error)

GateLineLoadText reads one GateLine 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 GateLineReadStrict 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 GateLineReadStrict 

func GateLineReadStrict(wire []byte) (*GateLine, error)

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

type GateLineBuilder 

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

func (*GateLineBuilder) AsConst 

func (b *GateLineBuilder) AsConst() *GateLine

func (*GateLineBuilder) GetRoot 

func (b *GateLineBuilder) GetRoot() *GateLine

func (*GateLineBuilder) Init 

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

func (*GateLineBuilder) Lock 

func (b *GateLineBuilder) Lock() bool

func (*GateLineBuilder) PackMeasure 

func (b *GateLineBuilder) PackMeasure() int64

func (*GateLineBuilder) PackMeasureReason 

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

func (*GateLineBuilder) Region 

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

func (*GateLineBuilder) Shutdown 

func (b *GateLineBuilder) Shutdown()

type GateLineCook 

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

GateLineCook is GateLine'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 — GateLineOpen, GateLineAt — 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 (*GateLineCook) Open 

func (cook *GateLineCook) 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 (GateLineCook) RegionAlignment 

func (c GateLineCook) 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 (GateLineCook) Root 

func (c GateLineCook) Root() *GateLineRow

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 (GateLineCook) RootAlign 

func (c GateLineCook) RootAlign() int64

func (GateLineCook) RootSize 

func (c GateLineCook) RootSize() int64

func (GateLineCook) Type 

func (c GateLineCook) Type() *TableCookInfo

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

type GateLineRow 

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

GateLineRow — 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 FailureLinesAdd 

func FailureLinesAdd(worker *TableWorker, holder *TableList[GateLineRow]) *GateLineRow

func GateLineAt 

func GateLineAt(slot *int64, arena ...*TableArena) *GateLineRow

GateLineAt 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 ImportExport 

type ImportExport = ImportExportRow

func ImportExportLoad 

func ImportExportLoad(region, wire []byte, report *TableReport) *ImportExport

func ImportExportLoadRetain 

func ImportExportLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *ImportExport

func ImportExportLoadText 

func ImportExportLoadText(text string, report *TableReport) (*ImportExport, error)

ImportExportLoadText reads one ImportExport 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 ImportExportReadStrict 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 ImportExportReadStrict 

func ImportExportReadStrict(wire []byte) (*ImportExport, error)

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

type ImportExportBuilder 

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

func (*ImportExportBuilder) AsConst 

func (b *ImportExportBuilder) AsConst() *ImportExport

func (*ImportExportBuilder) GetRoot 

func (b *ImportExportBuilder) GetRoot() *ImportExport

func (*ImportExportBuilder) Init 

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

func (*ImportExportBuilder) Lock 

func (b *ImportExportBuilder) Lock() bool

func (*ImportExportBuilder) PackMeasure 

func (b *ImportExportBuilder) PackMeasure() int64

func (*ImportExportBuilder) PackMeasureReason 

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

func (*ImportExportBuilder) Region 

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

func (*ImportExportBuilder) Shutdown 

func (b *ImportExportBuilder) Shutdown()

type ImportExportCook 

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

ImportExportCook is ImportExport'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 — ImportExportOpen, ImportExportAt — 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 (*ImportExportCook) Open 

func (cook *ImportExportCook) 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 (ImportExportCook) RegionAlignment 

func (c ImportExportCook) 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 (ImportExportCook) Root 

func (c ImportExportCook) Root() *ImportExportRow

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 (ImportExportCook) RootAlign 

func (c ImportExportCook) RootAlign() int64

func (ImportExportCook) RootSize 

func (c ImportExportCook) RootSize() int64

func (ImportExportCook) Type 

func (c ImportExportCook) Type() *TableCookInfo

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

type ImportExportRow 

type ImportExportRow struct {
	Lines TableList[ImportLogLineRow]
}

ImportExportRow — 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 ImportExportAt 

func ImportExportAt(slot *int64, arena ...*TableArena) *ImportExportRow

ImportExportAt 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 ImportLogLine 

type ImportLogLine = ImportLogLineRow

func ImportLogLineLoad 

func ImportLogLineLoad(region, wire []byte, report *TableReport) *ImportLogLine

func ImportLogLineLoadRetain 

func ImportLogLineLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *ImportLogLine

func ImportLogLineLoadText 

func ImportLogLineLoadText(text string, report *TableReport) (*ImportLogLine, error)

ImportLogLineLoadText reads one ImportLogLine 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 ImportLogLineReadStrict 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 ImportLogLineReadStrict 

func ImportLogLineReadStrict(wire []byte) (*ImportLogLine, error)

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

type ImportLogLineBuilder 

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

func (*ImportLogLineBuilder) AsConst 

func (b *ImportLogLineBuilder) AsConst() *ImportLogLine

func (*ImportLogLineBuilder) GetRoot 

func (b *ImportLogLineBuilder) GetRoot() *ImportLogLine

func (*ImportLogLineBuilder) Init 

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

func (*ImportLogLineBuilder) Lock 

func (b *ImportLogLineBuilder) Lock() bool

func (*ImportLogLineBuilder) PackMeasure 

func (b *ImportLogLineBuilder) PackMeasure() int64

func (*ImportLogLineBuilder) PackMeasureReason 

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

func (*ImportLogLineBuilder) Region 

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

func (*ImportLogLineBuilder) Shutdown 

func (b *ImportLogLineBuilder) Shutdown()

type ImportLogLineCook 

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

ImportLogLineCook is ImportLogLine'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 — ImportLogLineOpen, ImportLogLineAt — 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 (*ImportLogLineCook) Open 

func (cook *ImportLogLineCook) 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 (ImportLogLineCook) RegionAlignment 

func (c ImportLogLineCook) 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 (ImportLogLineCook) Root 

func (c ImportLogLineCook) Root() *ImportLogLineRow

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 (ImportLogLineCook) RootAlign 

func (c ImportLogLineCook) RootAlign() int64

func (ImportLogLineCook) RootSize 

func (c ImportLogLineCook) RootSize() int64

func (ImportLogLineCook) Type 

func (c ImportLogLineCook) Type() *TableCookInfo

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

type ImportLogLineRow 

type ImportLogLineRow struct {
	Verb    int64 // *: signed self-relative delta, zero is null (§6.3)
	Answers TableList[JudgmentIdRow]
}

ImportLogLineRow — 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 ImportExportLinesAdd 

func ImportExportLinesAdd(worker *TableWorker, holder *TableList[ImportLogLineRow]) *ImportLogLineRow

func ImportLogLineAt 

func ImportLogLineAt(slot *int64, arena ...*TableArena) *ImportLogLineRow

ImportLogLineAt 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 Input 

type Input = InputRow

func InputLoad 

func InputLoad(region, wire []byte, report *TableReport) *Input

func InputLoadRetain 

func InputLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Input

func InputLoadText 

func InputLoadText(text string, report *TableReport) (*Input, error)

InputLoadText reads one Input 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 InputReadStrict 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 InputReadStrict 

func InputReadStrict(wire []byte) (*Input, error)

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

type InputBuilder 

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

func (*InputBuilder) AsConst 

func (b *InputBuilder) AsConst() *Input

func (*InputBuilder) GetRoot 

func (b *InputBuilder) GetRoot() *Input

func (*InputBuilder) Init 

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

func (*InputBuilder) Lock 

func (b *InputBuilder) Lock() bool

func (*InputBuilder) PackMeasure 

func (b *InputBuilder) PackMeasure() int64

func (*InputBuilder) PackMeasureReason 

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

func (*InputBuilder) Region 

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

func (*InputBuilder) Shutdown 

func (b *InputBuilder) Shutdown()

type InputCook 

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

InputCook is Input'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 — InputOpen, InputAt — 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 (*InputCook) Open 

func (cook *InputCook) 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 (InputCook) RegionAlignment 

func (c InputCook) 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 (InputCook) Root 

func (c InputCook) Root() *InputRow

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 (InputCook) RootAlign 

func (c InputCook) RootAlign() int64

func (InputCook) RootSize 

func (c InputCook) RootSize() int64

func (InputCook) Type 

func (c InputCook) Type() *TableCookInfo

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

type InputRow 

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

InputRow — 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 DecisionInputsAdd 

func DecisionInputsAdd(worker *TableWorker, holder *TableList[InputRow]) *InputRow

func InputAt 

func InputAt(slot *int64, arena ...*TableArena) *InputRow

InputAt 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 JevAnswer 

type JevAnswer = JevAnswerRow

func JevAnswerLoad 

func JevAnswerLoad(region, wire []byte, report *TableReport) *JevAnswer

func JevAnswerLoadRetain 

func JevAnswerLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *JevAnswer

func JevAnswerLoadText 

func JevAnswerLoadText(text string, report *TableReport) (*JevAnswer, error)

JevAnswerLoadText reads one JevAnswer 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 JevAnswerReadStrict 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 JevAnswerReadStrict 

func JevAnswerReadStrict(wire []byte) (*JevAnswer, error)

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

type JevAnswerBuilder 

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

func (*JevAnswerBuilder) AsConst 

func (b *JevAnswerBuilder) AsConst() *JevAnswer

func (*JevAnswerBuilder) GetRoot 

func (b *JevAnswerBuilder) GetRoot() *JevAnswer

func (*JevAnswerBuilder) Init 

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

func (*JevAnswerBuilder) Lock 

func (b *JevAnswerBuilder) Lock() bool

func (*JevAnswerBuilder) PackMeasure 

func (b *JevAnswerBuilder) PackMeasure() int64

func (*JevAnswerBuilder) PackMeasureReason 

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

func (*JevAnswerBuilder) Region 

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

func (*JevAnswerBuilder) Shutdown 

func (b *JevAnswerBuilder) Shutdown()

type JevAnswerCook 

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

JevAnswerCook is JevAnswer'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 — JevAnswerOpen, JevAnswerAt — 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 (*JevAnswerCook) Open 

func (cook *JevAnswerCook) 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 (JevAnswerCook) RegionAlignment 

func (c JevAnswerCook) 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 (JevAnswerCook) Root 

func (c JevAnswerCook) Root() *JevAnswerRow

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 (JevAnswerCook) RootAlign 

func (c JevAnswerCook) RootAlign() int64

func (JevAnswerCook) RootSize 

func (c JevAnswerCook) RootSize() int64

func (JevAnswerCook) Type 

func (c JevAnswerCook) Type() *TableCookInfo

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

type JevAnswerRow 

type JevAnswerRow struct {
	Kind              int64 // *: signed self-relative delta, zero is null (§6.3)
	Choice            int64 // *: signed self-relative delta, zero is null (§6.3)
	Probabilities     TableList[OptionPRow]
	Confidence        float64
	ConfidencePresent bool // ?: one byte, in Go's model as in C++

	Noul        float64
	NoulPresent bool // ?: one byte, in Go's model as in C++
	// contains filtered or unexported fields
}

JevAnswerRow — 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 JevAnswerAt 

func JevAnswerAt(slot *int64, arena ...*TableArena) *JevAnswerRow

JevAnswerAt 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 JevRequest 

type JevRequest = JevRequestRow

func JevRequestLoad 

func JevRequestLoad(region, wire []byte, report *TableReport) *JevRequest

func JevRequestLoadRetain 

func JevRequestLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *JevRequest

func JevRequestLoadText 

func JevRequestLoadText(text string, report *TableReport) (*JevRequest, error)

JevRequestLoadText reads one JevRequest 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 JevRequestReadStrict 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 JevRequestReadStrict 

func JevRequestReadStrict(wire []byte) (*JevRequest, error)

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

type JevRequestBuilder 

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

func (*JevRequestBuilder) AsConst 

func (b *JevRequestBuilder) AsConst() *JevRequest

func (*JevRequestBuilder) GetRoot 

func (b *JevRequestBuilder) GetRoot() *JevRequest

func (*JevRequestBuilder) Init 

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

func (*JevRequestBuilder) Lock 

func (b *JevRequestBuilder) Lock() bool

func (*JevRequestBuilder) PackMeasure 

func (b *JevRequestBuilder) PackMeasure() int64

func (*JevRequestBuilder) PackMeasureReason 

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

func (*JevRequestBuilder) Region 

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

func (*JevRequestBuilder) Shutdown 

func (b *JevRequestBuilder) Shutdown()

type JevRequestCook 

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

JevRequestCook is JevRequest'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 — JevRequestOpen, JevRequestAt — 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 (*JevRequestCook) Open 

func (cook *JevRequestCook) 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 (JevRequestCook) RegionAlignment 

func (c JevRequestCook) 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 (JevRequestCook) Root 

func (c JevRequestCook) Root() *JevRequestRow

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 (JevRequestCook) RootAlign 

func (c JevRequestCook) RootAlign() int64

func (JevRequestCook) RootSize 

func (c JevRequestCook) RootSize() int64

func (JevRequestCook) Type 

func (c JevRequestCook) Type() *TableCookInfo

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

type JevRequestRow 

type JevRequestRow struct {
	State     int64 // *: signed self-relative delta, zero is null (§6.3)
	Model     int64 // *: signed self-relative delta, zero is null (§6.3)
	Questions TableList[NamedQuestionRow]
}

JevRequestRow — 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 JevRequestAt 

func JevRequestAt(slot *int64, arena ...*TableArena) *JevRequestRow

JevRequestAt 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 JevResponse 

type JevResponse = JevResponseRow

func JevResponseLoad 

func JevResponseLoad(region, wire []byte, report *TableReport) *JevResponse

func JevResponseLoadRetain 

func JevResponseLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *JevResponse

func JevResponseLoadText 

func JevResponseLoadText(text string, report *TableReport) (*JevResponse, error)

JevResponseLoadText reads one JevResponse 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 JevResponseReadStrict 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 JevResponseReadStrict 

func JevResponseReadStrict(wire []byte) (*JevResponse, error)

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

type JevResponseBuilder 

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

func (*JevResponseBuilder) AsConst 

func (b *JevResponseBuilder) AsConst() *JevResponse

func (*JevResponseBuilder) GetRoot 

func (b *JevResponseBuilder) GetRoot() *JevResponse

func (*JevResponseBuilder) Init 

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

func (*JevResponseBuilder) Lock 

func (b *JevResponseBuilder) Lock() bool

func (*JevResponseBuilder) PackMeasure 

func (b *JevResponseBuilder) PackMeasure() int64

func (*JevResponseBuilder) PackMeasureReason 

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

func (*JevResponseBuilder) Region 

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

func (*JevResponseBuilder) Shutdown 

func (b *JevResponseBuilder) Shutdown()

type JevResponseCook 

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

JevResponseCook is JevResponse'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 — JevResponseOpen, JevResponseAt — 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 (*JevResponseCook) Open 

func (cook *JevResponseCook) 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 (JevResponseCook) RegionAlignment 

func (c JevResponseCook) 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 (JevResponseCook) Root 

func (c JevResponseCook) Root() *JevResponseRow

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 (JevResponseCook) RootAlign 

func (c JevResponseCook) RootAlign() int64

func (JevResponseCook) RootSize 

func (c JevResponseCook) RootSize() int64

func (JevResponseCook) Type 

func (c JevResponseCook) Type() *TableCookInfo

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

type JevResponseRow 

type JevResponseRow struct {
	Answers TableList[NamedJevAnswerRow]
	Usage   UsageRow
}

JevResponseRow — 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 JevResponseAt 

func JevResponseAt(slot *int64, arena ...*TableArena) *JevResponseRow

JevResponseAt 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 JudgmentId 

type JudgmentId = JudgmentIdRow

func JudgmentIdLoad 

func JudgmentIdLoad(region, wire []byte, report *TableReport) *JudgmentId

func JudgmentIdLoadRetain 

func JudgmentIdLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *JudgmentId

func JudgmentIdLoadText 

func JudgmentIdLoadText(text string, report *TableReport) (*JudgmentId, error)

JudgmentIdLoadText reads one JudgmentId 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 JudgmentIdReadStrict 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 JudgmentIdReadStrict 

func JudgmentIdReadStrict(wire []byte) (*JudgmentId, error)

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

type JudgmentIdBuilder 

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

func (*JudgmentIdBuilder) AsConst 

func (b *JudgmentIdBuilder) AsConst() *JudgmentId

func (*JudgmentIdBuilder) GetRoot 

func (b *JudgmentIdBuilder) GetRoot() *JudgmentId

func (*JudgmentIdBuilder) Init 

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

func (*JudgmentIdBuilder) Lock 

func (b *JudgmentIdBuilder) Lock() bool

func (*JudgmentIdBuilder) PackMeasure 

func (b *JudgmentIdBuilder) PackMeasure() int64

func (*JudgmentIdBuilder) PackMeasureReason 

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

func (*JudgmentIdBuilder) Region 

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

func (*JudgmentIdBuilder) Shutdown 

func (b *JudgmentIdBuilder) Shutdown()

type JudgmentIdCook 

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

JudgmentIdCook is JudgmentId'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 — JudgmentIdOpen, JudgmentIdAt — 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 (*JudgmentIdCook) Open 

func (cook *JudgmentIdCook) 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 (JudgmentIdCook) RegionAlignment 

func (c JudgmentIdCook) 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 (JudgmentIdCook) Root 

func (c JudgmentIdCook) Root() *JudgmentIdRow

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 (JudgmentIdCook) RootAlign 

func (c JudgmentIdCook) RootAlign() int64

func (JudgmentIdCook) RootSize 

func (c JudgmentIdCook) RootSize() int64

func (JudgmentIdCook) Type 

func (c JudgmentIdCook) Type() *TableCookInfo

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

type JudgmentIdRow 

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

JudgmentIdRow — 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 ImportLogLineAnswersAdd 

func ImportLogLineAnswersAdd(worker *TableWorker, holder *TableList[JudgmentIdRow]) *JudgmentIdRow

func JudgmentIdAt 

func JudgmentIdAt(slot *int64, arena ...*TableArena) *JudgmentIdRow

JudgmentIdAt 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 LineKind 

type LineKind uint8

LineKind — None = 0 implicit, variants dense from 1, wire range [0, 3] (SPEC §4.2) 

const (
	LineKindNone     LineKind = 0
	LineKindDecision LineKind = 1
	LineKindOutcome  LineKind = 2
	LineKindAct      LineKind = 3
	LineKindCount    LineKind = 3 // the declared variant count (SPEC §4.2)
	LineKindMax      LineKind = 3 // the exported extent (SPEC §4.2)
)

func (LineKind) TableEnumId 

func (value LineKind) TableEnumId() (uint64, bool)

TableEnumId: LineKind on the TABLE wire rides as the 64-bit hash of its VARIANT NAME, so a variant may be added anywhere, removed, or reordered and old data still reads (mas-bandwidth/schema docs/SPEC-TABLES.md §5). None uses reference zero; hash zero remains a valid named id. The bool is false when no variant names this value: no wire identity.

func (*LineKind) TableEnumValue 

func (value *LineKind) TableEnumValue(id uint64) bool

TableEnumValue resolves a table-wire variant id to a LineKind, in place. The bool is false for an id this build cannot name; the value is left at None, which is what an unknown variant reads as (mas-bandwidth/schema docs/SPEC-TABLES.md §5).

type LogExport 

type LogExport = LogExportRow

func LogExportLoad 

func LogExportLoad(region, wire []byte, report *TableReport) *LogExport

func LogExportLoadRetain 

func LogExportLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *LogExport

func LogExportLoadText 

func LogExportLoadText(text string, report *TableReport) (*LogExport, error)

LogExportLoadText reads one LogExport 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 LogExportReadStrict 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 LogExportReadStrict 

func LogExportReadStrict(wire []byte) (*LogExport, error)

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

type LogExportBuilder 

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

func (*LogExportBuilder) AsConst 

func (b *LogExportBuilder) AsConst() *LogExport

func (*LogExportBuilder) GetRoot 

func (b *LogExportBuilder) GetRoot() *LogExport

func (*LogExportBuilder) Init 

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

func (*LogExportBuilder) Lock 

func (b *LogExportBuilder) Lock() bool

func (*LogExportBuilder) PackMeasure 

func (b *LogExportBuilder) PackMeasure() int64

func (*LogExportBuilder) PackMeasureReason 

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

func (*LogExportBuilder) Region 

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

func (*LogExportBuilder) Shutdown 

func (b *LogExportBuilder) Shutdown()

type LogExportCook 

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

LogExportCook is LogExport'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 — LogExportOpen, LogExportAt — 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 (*LogExportCook) Open 

func (cook *LogExportCook) 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 (LogExportCook) RegionAlignment 

func (c LogExportCook) 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 (LogExportCook) Root 

func (c LogExportCook) Root() *LogExportRow

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 (LogExportCook) RootAlign 

func (c LogExportCook) RootAlign() int64

func (LogExportCook) RootSize 

func (c LogExportCook) RootSize() int64

func (LogExportCook) Type 

func (c LogExportCook) Type() *TableCookInfo

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

type LogExportRow 

type LogExportRow struct {
	Lines TableList[LogLineRow]
}

LogExportRow — 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 LogExportAt 

func LogExportAt(slot *int64, arena ...*TableArena) *LogExportRow

LogExportAt 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 LogLine 

type LogLine = LogLineRow

func LogLineLoad 

func LogLineLoad(region, wire []byte, report *TableReport) *LogLine

func LogLineLoadRetain 

func LogLineLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *LogLine

func LogLineLoadText 

func LogLineLoadText(text string, report *TableReport) (*LogLine, error)

LogLineLoadText reads one LogLine 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 LogLineReadStrict 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 LogLineReadStrict 

func LogLineReadStrict(wire []byte) (*LogLine, error)

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

type LogLineBuilder 

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

func (*LogLineBuilder) AsConst 

func (b *LogLineBuilder) AsConst() *LogLine

func (*LogLineBuilder) GetRoot 

func (b *LogLineBuilder) GetRoot() *LogLine

func (*LogLineBuilder) Init 

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

func (*LogLineBuilder) Lock 

func (b *LogLineBuilder) Lock() bool

func (*LogLineBuilder) PackMeasure 

func (b *LogLineBuilder) PackMeasure() int64

func (*LogLineBuilder) PackMeasureReason 

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

func (*LogLineBuilder) Region 

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

func (*LogLineBuilder) Shutdown 

func (b *LogLineBuilder) Shutdown()

type LogLineCook 

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

LogLineCook is LogLine'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 — LogLineOpen, LogLineAt — 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 (*LogLineCook) Open 

func (cook *LogLineCook) 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 (LogLineCook) RegionAlignment 

func (c LogLineCook) 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 (LogLineCook) Root 

func (c LogLineCook) Root() *LogLineRow

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 (LogLineCook) RootAlign 

func (c LogLineCook) RootAlign() int64

func (LogLineCook) RootSize 

func (c LogLineCook) RootSize() int64

func (LogLineCook) Type 

func (c LogLineCook) Type() *TableCookInfo

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

type LogLineRow 

type LogLineRow struct {
	Card      int64 // *: signed self-relative delta, zero is null (§6.3)
	Primary   int64 // *: signed self-relative delta, zero is null (§6.3)
	TableName int64 // *: signed self-relative delta, zero is null (§6.3)
	To        int64 // *: signed self-relative delta, zero is null (§6.3)
	Removed   bool

	Set TableList[SetEntryRow]
	// contains filtered or unexported fields
}

LogLineRow — 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 LogExportLinesAdd 

func LogExportLinesAdd(worker *TableWorker, holder *TableList[LogLineRow]) *LogLineRow

func LogLineAt 

func LogLineAt(slot *int64, arena ...*TableArena) *LogLineRow

LogLineAt 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 NamedAnswer 

type NamedAnswer = NamedAnswerRow

func NamedAnswerLoad 

func NamedAnswerLoad(region, wire []byte, report *TableReport) *NamedAnswer

func NamedAnswerLoadRetain 

func NamedAnswerLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NamedAnswer

func NamedAnswerLoadText 

func NamedAnswerLoadText(text string, report *TableReport) (*NamedAnswer, error)

NamedAnswerLoadText reads one NamedAnswer 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 NamedAnswerReadStrict 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 NamedAnswerReadStrict 

func NamedAnswerReadStrict(wire []byte) (*NamedAnswer, error)

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

type NamedAnswerBuilder 

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

func (*NamedAnswerBuilder) AsConst 

func (b *NamedAnswerBuilder) AsConst() *NamedAnswer

func (*NamedAnswerBuilder) GetRoot 

func (b *NamedAnswerBuilder) GetRoot() *NamedAnswer

func (*NamedAnswerBuilder) Init 

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

func (*NamedAnswerBuilder) Lock 

func (b *NamedAnswerBuilder) Lock() bool

func (*NamedAnswerBuilder) PackMeasure 

func (b *NamedAnswerBuilder) PackMeasure() int64

func (*NamedAnswerBuilder) PackMeasureReason 

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

func (*NamedAnswerBuilder) Region 

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

func (*NamedAnswerBuilder) Shutdown 

func (b *NamedAnswerBuilder) Shutdown()

type NamedAnswerCook 

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

NamedAnswerCook is NamedAnswer'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 — NamedAnswerOpen, NamedAnswerAt — 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 (*NamedAnswerCook) Open 

func (cook *NamedAnswerCook) 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 (NamedAnswerCook) RegionAlignment 

func (c NamedAnswerCook) 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 (NamedAnswerCook) Root 

func (c NamedAnswerCook) Root() *NamedAnswerRow

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 (NamedAnswerCook) RootAlign 

func (c NamedAnswerCook) RootAlign() int64

func (NamedAnswerCook) RootSize 

func (c NamedAnswerCook) RootSize() int64

func (NamedAnswerCook) Type 

func (c NamedAnswerCook) Type() *TableCookInfo

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

type NamedAnswerRow 

type NamedAnswerRow struct {
	Question int64 // *: signed self-relative delta, zero is null (§6.3)
	Answer   AnswerRow
}

NamedAnswerRow — 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 DecisionAnswersAdd 

func DecisionAnswersAdd(worker *TableWorker, holder *TableList[NamedAnswerRow]) *NamedAnswerRow

func NamedAnswerAt 

func NamedAnswerAt(slot *int64, arena ...*TableArena) *NamedAnswerRow

NamedAnswerAt 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 NamedFixedAnswer 

type NamedFixedAnswer = NamedFixedAnswerRow

func NamedFixedAnswerLoad 

func NamedFixedAnswerLoad(region, wire []byte, report *TableReport) *NamedFixedAnswer

func NamedFixedAnswerLoadRetain 

func NamedFixedAnswerLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NamedFixedAnswer

func NamedFixedAnswerLoadText 

func NamedFixedAnswerLoadText(text string, report *TableReport) (*NamedFixedAnswer, error)

NamedFixedAnswerLoadText reads one NamedFixedAnswer 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 NamedFixedAnswerReadStrict 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 NamedFixedAnswerReadStrict 

func NamedFixedAnswerReadStrict(wire []byte) (*NamedFixedAnswer, error)

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

type NamedFixedAnswerBuilder 

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

func (*NamedFixedAnswerBuilder) AsConst 

func (b *NamedFixedAnswerBuilder) AsConst() *NamedFixedAnswer

func (*NamedFixedAnswerBuilder) GetRoot 

func (b *NamedFixedAnswerBuilder) GetRoot() *NamedFixedAnswer

func (*NamedFixedAnswerBuilder) Init 

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

func (*NamedFixedAnswerBuilder) Lock 

func (b *NamedFixedAnswerBuilder) Lock() bool

func (*NamedFixedAnswerBuilder) PackMeasure 

func (b *NamedFixedAnswerBuilder) PackMeasure() int64

func (*NamedFixedAnswerBuilder) PackMeasureReason 

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

func (*NamedFixedAnswerBuilder) Region 

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

func (*NamedFixedAnswerBuilder) Shutdown 

func (b *NamedFixedAnswerBuilder) Shutdown()

type NamedFixedAnswerCook 

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

NamedFixedAnswerCook is NamedFixedAnswer'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 — NamedFixedAnswerOpen, NamedFixedAnswerAt — 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 (*NamedFixedAnswerCook) Open 

func (cook *NamedFixedAnswerCook) 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 (NamedFixedAnswerCook) RegionAlignment 

func (c NamedFixedAnswerCook) 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 (NamedFixedAnswerCook) Root 

func (c NamedFixedAnswerCook) Root() *NamedFixedAnswerRow

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 (NamedFixedAnswerCook) RootAlign 

func (c NamedFixedAnswerCook) RootAlign() int64

func (NamedFixedAnswerCook) RootSize 

func (c NamedFixedAnswerCook) RootSize() int64

func (NamedFixedAnswerCook) Type 

func (c NamedFixedAnswerCook) Type() *TableCookInfo

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

type NamedFixedAnswerRow 

type NamedFixedAnswerRow struct {
	Question int64 // *: signed self-relative delta, zero is null (§6.3)
	Answer   FixedAnswerRow
}

NamedFixedAnswerRow — 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 FixedTableAnswersAdd 

func FixedTableAnswersAdd(worker *TableWorker, holder *TableList[NamedFixedAnswerRow]) *NamedFixedAnswerRow

func NamedFixedAnswerAt 

func NamedFixedAnswerAt(slot *int64, arena ...*TableArena) *NamedFixedAnswerRow

NamedFixedAnswerAt 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 NamedJevAnswer 

type NamedJevAnswer = NamedJevAnswerRow

func NamedJevAnswerLoad 

func NamedJevAnswerLoad(region, wire []byte, report *TableReport) *NamedJevAnswer

func NamedJevAnswerLoadRetain 

func NamedJevAnswerLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NamedJevAnswer

func NamedJevAnswerLoadText 

func NamedJevAnswerLoadText(text string, report *TableReport) (*NamedJevAnswer, error)

NamedJevAnswerLoadText reads one NamedJevAnswer 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 NamedJevAnswerReadStrict 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 NamedJevAnswerReadStrict 

func NamedJevAnswerReadStrict(wire []byte) (*NamedJevAnswer, error)

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

type NamedJevAnswerBuilder 

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

func (*NamedJevAnswerBuilder) AsConst 

func (b *NamedJevAnswerBuilder) AsConst() *NamedJevAnswer

func (*NamedJevAnswerBuilder) GetRoot 

func (b *NamedJevAnswerBuilder) GetRoot() *NamedJevAnswer

func (*NamedJevAnswerBuilder) Init 

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

func (*NamedJevAnswerBuilder) Lock 

func (b *NamedJevAnswerBuilder) Lock() bool

func (*NamedJevAnswerBuilder) PackMeasure 

func (b *NamedJevAnswerBuilder) PackMeasure() int64

func (*NamedJevAnswerBuilder) PackMeasureReason 

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

func (*NamedJevAnswerBuilder) Region 

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

func (*NamedJevAnswerBuilder) Shutdown 

func (b *NamedJevAnswerBuilder) Shutdown()

type NamedJevAnswerCook 

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

NamedJevAnswerCook is NamedJevAnswer'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 — NamedJevAnswerOpen, NamedJevAnswerAt — 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 (*NamedJevAnswerCook) Open 

func (cook *NamedJevAnswerCook) 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 (NamedJevAnswerCook) RegionAlignment 

func (c NamedJevAnswerCook) 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 (NamedJevAnswerCook) Root 

func (c NamedJevAnswerCook) Root() *NamedJevAnswerRow

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 (NamedJevAnswerCook) RootAlign 

func (c NamedJevAnswerCook) RootAlign() int64

func (NamedJevAnswerCook) RootSize 

func (c NamedJevAnswerCook) RootSize() int64

func (NamedJevAnswerCook) Type 

func (c NamedJevAnswerCook) Type() *TableCookInfo

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

type NamedJevAnswerRow 

type NamedJevAnswerRow struct {
	Question int64 // *: signed self-relative delta, zero is null (§6.3)
	Answer   JevAnswerRow
}

NamedJevAnswerRow — 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 JevResponseAnswersAdd 

func JevResponseAnswersAdd(worker *TableWorker, holder *TableList[NamedJevAnswerRow]) *NamedJevAnswerRow

func NamedJevAnswerAt 

func NamedJevAnswerAt(slot *int64, arena ...*TableArena) *NamedJevAnswerRow

NamedJevAnswerAt 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 NamedQuestion 

type NamedQuestion = NamedQuestionRow

func NamedQuestionLoad 

func NamedQuestionLoad(region, wire []byte, report *TableReport) *NamedQuestion

func NamedQuestionLoadRetain 

func NamedQuestionLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NamedQuestion

func NamedQuestionLoadText 

func NamedQuestionLoadText(text string, report *TableReport) (*NamedQuestion, error)

NamedQuestionLoadText reads one NamedQuestion 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 NamedQuestionReadStrict 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 NamedQuestionReadStrict 

func NamedQuestionReadStrict(wire []byte) (*NamedQuestion, error)

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

type NamedQuestionBuilder 

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

func (*NamedQuestionBuilder) AsConst 

func (b *NamedQuestionBuilder) AsConst() *NamedQuestion

func (*NamedQuestionBuilder) GetRoot 

func (b *NamedQuestionBuilder) GetRoot() *NamedQuestion

func (*NamedQuestionBuilder) Init 

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

func (*NamedQuestionBuilder) Lock 

func (b *NamedQuestionBuilder) Lock() bool

func (*NamedQuestionBuilder) PackMeasure 

func (b *NamedQuestionBuilder) PackMeasure() int64

func (*NamedQuestionBuilder) PackMeasureReason 

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

func (*NamedQuestionBuilder) Region 

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

func (*NamedQuestionBuilder) Shutdown 

func (b *NamedQuestionBuilder) Shutdown()

type NamedQuestionCook 

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

NamedQuestionCook is NamedQuestion'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 — NamedQuestionOpen, NamedQuestionAt — 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 (*NamedQuestionCook) Open 

func (cook *NamedQuestionCook) 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 (NamedQuestionCook) RegionAlignment 

func (c NamedQuestionCook) 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 (NamedQuestionCook) Root 

func (c NamedQuestionCook) Root() *NamedQuestionRow

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 (NamedQuestionCook) RootAlign 

func (c NamedQuestionCook) RootAlign() int64

func (NamedQuestionCook) RootSize 

func (c NamedQuestionCook) RootSize() int64

func (NamedQuestionCook) Type 

func (c NamedQuestionCook) Type() *TableCookInfo

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

type NamedQuestionRow 

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

NamedQuestionRow — 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 DecideSchemaQuestionsAdd 

func DecideSchemaQuestionsAdd(worker *TableWorker, holder *TableList[NamedQuestionRow]) *NamedQuestionRow

func JevRequestQuestionsAdd 

func JevRequestQuestionsAdd(worker *TableWorker, holder *TableList[NamedQuestionRow]) *NamedQuestionRow

func NamedQuestionAt 

func NamedQuestionAt(slot *int64, arena ...*TableArena) *NamedQuestionRow

NamedQuestionAt 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 OptionP 

type OptionP = OptionPRow

func OptionPLoad 

func OptionPLoad(region, wire []byte, report *TableReport) *OptionP

func OptionPLoadRetain 

func OptionPLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *OptionP

func OptionPLoadText 

func OptionPLoadText(text string, report *TableReport) (*OptionP, error)

OptionPLoadText reads one OptionP 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 OptionPReadStrict 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 OptionPReadStrict 

func OptionPReadStrict(wire []byte) (*OptionP, error)

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

type OptionPBuilder 

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

func (*OptionPBuilder) AsConst 

func (b *OptionPBuilder) AsConst() *OptionP

func (*OptionPBuilder) GetRoot 

func (b *OptionPBuilder) GetRoot() *OptionP

func (*OptionPBuilder) Init 

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

func (*OptionPBuilder) Lock 

func (b *OptionPBuilder) Lock() bool

func (*OptionPBuilder) PackMeasure 

func (b *OptionPBuilder) PackMeasure() int64

func (*OptionPBuilder) PackMeasureReason 

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

func (*OptionPBuilder) Region 

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

func (*OptionPBuilder) Shutdown 

func (b *OptionPBuilder) Shutdown()

type OptionPCook 

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

OptionPCook is OptionP'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 — OptionPOpen, OptionPAt — 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 (*OptionPCook) Open 

func (cook *OptionPCook) 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 (OptionPCook) RegionAlignment 

func (c OptionPCook) 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 (OptionPCook) Root 

func (c OptionPCook) Root() *OptionPRow

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 (OptionPCook) RootAlign 

func (c OptionPCook) RootAlign() int64

func (OptionPCook) RootSize 

func (c OptionPCook) RootSize() int64

func (OptionPCook) Type 

func (c OptionPCook) Type() *TableCookInfo

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

type OptionPRow 

type OptionPRow struct {
	Option int64 // *: signed self-relative delta, zero is null (§6.3)
	P      float64
}

OptionPRow — 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 AnswerPAdd 

func AnswerPAdd(worker *TableWorker, holder *TableList[OptionPRow]) *OptionPRow

func FixedAnswerPAdd 

func FixedAnswerPAdd(worker *TableWorker, holder *TableList[OptionPRow]) *OptionPRow

func JevAnswerProbabilitiesAdd 

func JevAnswerProbabilitiesAdd(worker *TableWorker, holder *TableList[OptionPRow]) *OptionPRow

func OptionPAt 

func OptionPAt(slot *int64, arena ...*TableArena) *OptionPRow

OptionPAt 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 Outcome 

type Outcome = OutcomeRow

func OutcomeEmplace 

func OutcomeEmplace(worker *TableWorker, slot *TableRef) *Outcome

func OutcomeLoad 

func OutcomeLoad(region, wire []byte, report *TableReport) *Outcome

func OutcomeLoadRetain 

func OutcomeLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Outcome

func OutcomeLoadText 

func OutcomeLoadText(text string, report *TableReport) (*Outcome, error)

OutcomeLoadText reads one Outcome 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 OutcomeReadStrict 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 OutcomeReadStrict 

func OutcomeReadStrict(wire []byte) (*Outcome, error)

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

type OutcomeBuilder 

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

func (*OutcomeBuilder) AsConst 

func (b *OutcomeBuilder) AsConst() *Outcome

func (*OutcomeBuilder) GetRoot 

func (b *OutcomeBuilder) GetRoot() *Outcome

func (*OutcomeBuilder) Init 

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

func (*OutcomeBuilder) Lock 

func (b *OutcomeBuilder) Lock() bool

func (*OutcomeBuilder) PackMeasure 

func (b *OutcomeBuilder) PackMeasure() int64

func (*OutcomeBuilder) PackMeasureReason 

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

func (*OutcomeBuilder) Region 

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

func (*OutcomeBuilder) Shutdown 

func (b *OutcomeBuilder) Shutdown()

type OutcomeCook 

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

OutcomeCook is Outcome'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 — OutcomeOpen, OutcomeAt — 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 (*OutcomeCook) Open 

func (cook *OutcomeCook) 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 (OutcomeCook) RegionAlignment 

func (c OutcomeCook) 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 (OutcomeCook) Root 

func (c OutcomeCook) Root() *OutcomeRow

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 (OutcomeCook) RootAlign 

func (c OutcomeCook) RootAlign() int64

func (OutcomeCook) RootSize 

func (c OutcomeCook) RootSize() int64

func (OutcomeCook) Type 

func (c OutcomeCook) Type() *TableCookInfo

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

type OutcomeRow 

type OutcomeRow struct {
	Id    int64 // *: signed self-relative delta, zero is null (§6.3)
	Label int64 // *: signed self-relative delta, zero is null (§6.3)
	Note  int64 // *: signed self-relative delta, zero is null (§6.3)
	At    int64 // *: signed self-relative delta, zero is null (§6.3)
}

OutcomeRow — 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 OutcomeAt 

func OutcomeAt(slot *int64, arena ...*TableArena) *OutcomeRow

OutcomeAt 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 Question 

type Question = QuestionRow

func QuestionLoad 

func QuestionLoad(region, wire []byte, report *TableReport) *Question

func QuestionLoadRetain 

func QuestionLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Question

func QuestionLoadText 

func QuestionLoadText(text string, report *TableReport) (*Question, error)

QuestionLoadText reads one Question 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 QuestionReadStrict 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 QuestionReadStrict 

func QuestionReadStrict(wire []byte) (*Question, error)

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

type QuestionBuilder 

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

func (*QuestionBuilder) AsConst 

func (b *QuestionBuilder) AsConst() *Question

func (*QuestionBuilder) GetRoot 

func (b *QuestionBuilder) GetRoot() *Question

func (*QuestionBuilder) Init 

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

func (*QuestionBuilder) Lock 

func (b *QuestionBuilder) Lock() bool

func (*QuestionBuilder) PackMeasure 

func (b *QuestionBuilder) PackMeasure() int64

func (*QuestionBuilder) PackMeasureReason 

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

func (*QuestionBuilder) Region 

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

func (*QuestionBuilder) Shutdown 

func (b *QuestionBuilder) Shutdown()

type QuestionCook 

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

QuestionCook is Question'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 — QuestionOpen, QuestionAt — 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 (*QuestionCook) Open 

func (cook *QuestionCook) 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 (QuestionCook) RegionAlignment 

func (c QuestionCook) 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 (QuestionCook) Root 

func (c QuestionCook) Root() *QuestionRow

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 (QuestionCook) RootAlign 

func (c QuestionCook) RootAlign() int64

func (QuestionCook) RootSize 

func (c QuestionCook) RootSize() int64

func (QuestionCook) Type 

func (c QuestionCook) Type() *TableCookInfo

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

type QuestionRow 

type QuestionRow struct {
	Kind AnswerType

	Instructions int64 // *: signed self-relative delta, zero is null (§6.3)
	Criteria     TableList[CriterionRow]
	// contains filtered or unexported fields
}

QuestionRow — 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 QuestionAt 

func QuestionAt(slot *int64, arena ...*TableArena) *QuestionRow

QuestionAt 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 RawRecord 

type RawRecord = RawRecordRow

func RawRecordLoad 

func RawRecordLoad(region, wire []byte, report *TableReport) *RawRecord

func RawRecordLoadRetain 

func RawRecordLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *RawRecord

func RawRecordLoadText 

func RawRecordLoadText(text string, report *TableReport) (*RawRecord, error)

RawRecordLoadText reads one RawRecord 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 RawRecordReadStrict 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 RawRecordReadStrict 

func RawRecordReadStrict(wire []byte) (*RawRecord, error)

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

type RawRecordBuilder 

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

func (*RawRecordBuilder) AsConst 

func (b *RawRecordBuilder) AsConst() *RawRecord

func (*RawRecordBuilder) GetRoot 

func (b *RawRecordBuilder) GetRoot() *RawRecord

func (*RawRecordBuilder) Init 

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

func (*RawRecordBuilder) Lock 

func (b *RawRecordBuilder) Lock() bool

func (*RawRecordBuilder) PackMeasure 

func (b *RawRecordBuilder) PackMeasure() int64

func (*RawRecordBuilder) PackMeasureReason 

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

func (*RawRecordBuilder) Region 

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

func (*RawRecordBuilder) Shutdown 

func (b *RawRecordBuilder) Shutdown()

type RawRecordCook 

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

RawRecordCook is RawRecord'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 — RawRecordOpen, RawRecordAt — 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 (*RawRecordCook) Open 

func (cook *RawRecordCook) 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 (RawRecordCook) RegionAlignment 

func (c RawRecordCook) 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 (RawRecordCook) Root 

func (c RawRecordCook) Root() *RawRecordRow

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 (RawRecordCook) RootAlign 

func (c RawRecordCook) RootAlign() int64

func (RawRecordCook) RootSize 

func (c RawRecordCook) RootSize() int64

func (RawRecordCook) Type 

func (c RawRecordCook) Type() *TableCookInfo

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

type RawRecordRow 

type RawRecordRow struct {
	Harness         int64 // *: signed self-relative delta, zero is null (§6.3)
	Execution       int64 // *: signed self-relative delta, zero is null (§6.3)
	SourceSchema    int64 // *: signed self-relative delta, zero is null (§6.3)
	ProducerVersion int64 // *: signed self-relative delta, zero is null (§6.3)
	Billing         Billing

	Tokens RawTokensRow
	// contains filtered or unexported fields
}

RawRecordRow — 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 RawRecordAt 

func RawRecordAt(slot *int64, arena ...*TableArena) *RawRecordRow

RawRecordAt 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.

func RawUsageRecordsAdd 

func RawUsageRecordsAdd(worker *TableWorker, holder *TableList[RawRecordRow]) *RawRecordRow

type RawTokens 

type RawTokens = RawTokensRow

func RawTokensLoadText 

func RawTokensLoadText(text string, report *TableReport) (*RawTokens, error)

RawTokensLoadText fills one RawTokens from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8). It is the STRICT read (§6.5) over the decoded wire: it refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant Load 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 RawTokensReadStrict 

func RawTokensReadStrict(wire []byte) (*RawTokens, error)

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

type RawTokensBlock 

type RawTokensBlock struct {
	Base       unsafe.Pointer            // the extent's base, 64-byte aligned
	Projection *RawTokensBlockProjection // the projection, at offset 0
	Bytes      int64                     // the extent in use
}

RawTokensBlock is RawTokens's block: a pointer and a length, and then rows in place. Opening one is ONE check and no copy; reading a row is one add (§19.2).

The bytes belong to the CONSUMER — a []byte it owns, an mmap, or memory a producer handed across. Nothing here allocates.

A block is valid until the next fill over the SAME storage, which invalidates every block over it and every row pointer taken from one.

func (*RawTokensBlock) Open 

func (block *RawTokensBlock) Open(base unsafe.Pointer, bytes int64) error

Open reads all prologue and layout words bytewise before the final base alignment check. Every refusal names the first failed clause in SPEC §19.2.

func (*RawTokensBlock) Type 

func (b *RawTokensBlock) Type() *TableBlockInfo

Type is this block's descriptors: constant data, so a reflective read costs a lookup and not a parse. The row layouts hang off the element column rather than taking names of their own, so a walker reaches every record through the graph.

type RawTokensBlockProjection 

type RawTokensBlockProjection struct {
	Magic              uint64 // generated: identifies a schema block
	BuildVersion       uint64 // generated: the unit's build version (mas-bandwidth/schema docs/SPEC-TABLES.md §20)
	ByteOrder          uint64 // generated: 1 little, 2 big
	InputTokens        int64
	InputTokensPresent bool // ?: one byte, in Go's model as in C++

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

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

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

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

	ReasoningTokens        int64
	ReasoningTokensPresent bool // ?: one byte, in Go's model as in C++
	// contains filtered or unexported fields
}

RawTokensBlockProjection — the block PROJECTION: the table's own instance as it sits at the front of a block, opening with the generated PROLOGUE and carrying, per out-of-line array, the triple that says where its rows are. It is a record like any other and follows the same C ABI rule (§19.3).

It is a SEPARATE record from RawTokensRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type RawTokensBlockStorage 

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

RawTokensBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*RawTokensBlockStorage) Create 

func (s *RawTokensBlockStorage) Create(a TableBlockAllocator) bool

func (*RawTokensBlockStorage) Destroy 

func (s *RawTokensBlockStorage) Destroy()

type RawTokensCook 

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

RawTokensCook is RawTokens'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 — RawTokensOpen, RawTokensAt — 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 (*RawTokensCook) Open 

func (cook *RawTokensCook) 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 (RawTokensCook) RegionAlignment 

func (c RawTokensCook) 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 (RawTokensCook) Root 

func (c RawTokensCook) Root() *RawTokensRow

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 (RawTokensCook) RootAlign 

func (c RawTokensCook) RootAlign() int64

func (RawTokensCook) RootSize 

func (c RawTokensCook) RootSize() int64

func (RawTokensCook) Type 

func (c RawTokensCook) Type() *TableCookInfo

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

type RawTokensCounts 

type RawTokensCounts struct {
}

RawTokensCounts is gathered before Begin; clamping is the caller's policy.

type RawTokensRow 

type RawTokensRow struct {
	InputTokens        int64
	InputTokensPresent bool // ?: one byte, in Go's model as in C++

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

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

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

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

	ReasoningTokens        int64
	ReasoningTokensPresent bool // ?: one byte, in Go's model as in C++
	// contains filtered or unexported fields
}

RawTokensRow — 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 RawTokensAt 

func RawTokensAt(slot *int64, arena ...*TableArena) *RawTokensRow

RawTokensAt 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 RawUsage 

type RawUsage = RawUsageRow

func RawUsageLoad 

func RawUsageLoad(region, wire []byte, report *TableReport) *RawUsage

func RawUsageLoadRetain 

func RawUsageLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *RawUsage

func RawUsageLoadText 

func RawUsageLoadText(text string, report *TableReport) (*RawUsage, error)

RawUsageLoadText reads one RawUsage 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 RawUsageReadStrict 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 RawUsageReadStrict 

func RawUsageReadStrict(wire []byte) (*RawUsage, error)

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

type RawUsageBuilder 

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

func (*RawUsageBuilder) AsConst 

func (b *RawUsageBuilder) AsConst() *RawUsage

func (*RawUsageBuilder) GetRoot 

func (b *RawUsageBuilder) GetRoot() *RawUsage

func (*RawUsageBuilder) Init 

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

func (*RawUsageBuilder) Lock 

func (b *RawUsageBuilder) Lock() bool

func (*RawUsageBuilder) PackMeasure 

func (b *RawUsageBuilder) PackMeasure() int64

func (*RawUsageBuilder) PackMeasureReason 

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

func (*RawUsageBuilder) Region 

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

func (*RawUsageBuilder) Shutdown 

func (b *RawUsageBuilder) Shutdown()

type RawUsageCook 

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

RawUsageCook is RawUsage'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 — RawUsageOpen, RawUsageAt — 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 (*RawUsageCook) Open 

func (cook *RawUsageCook) 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 (RawUsageCook) RegionAlignment 

func (c RawUsageCook) 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 (RawUsageCook) Root 

func (c RawUsageCook) Root() *RawUsageRow

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 (RawUsageCook) RootAlign 

func (c RawUsageCook) RootAlign() int64

func (RawUsageCook) RootSize 

func (c RawUsageCook) RootSize() int64

func (RawUsageCook) Type 

func (c RawUsageCook) Type() *TableCookInfo

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

type RawUsageRow 

type RawUsageRow struct {
	Version uint32

	Records TableList[RawRecordRow]
	// contains filtered or unexported fields
}

RawUsageRow — 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 RawUsageAt 

func RawUsageAt(slot *int64, arena ...*TableArena) *RawUsageRow

RawUsageAt 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 RecordLine 

type RecordLine = RecordLineRow

func RecordLineLoad 

func RecordLineLoad(region, wire []byte, report *TableReport) *RecordLine

func RecordLineLoadRetain 

func RecordLineLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *RecordLine

func RecordLineLoadText 

func RecordLineLoadText(text string, report *TableReport) (*RecordLine, error)

RecordLineLoadText reads one RecordLine 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 RecordLineReadStrict 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 RecordLineReadStrict 

func RecordLineReadStrict(wire []byte) (*RecordLine, error)

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

type RecordLineBuilder 

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

func (*RecordLineBuilder) AsConst 

func (b *RecordLineBuilder) AsConst() *RecordLine

func (*RecordLineBuilder) GetRoot 

func (b *RecordLineBuilder) GetRoot() *RecordLine

func (*RecordLineBuilder) Init 

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

func (*RecordLineBuilder) Lock 

func (b *RecordLineBuilder) Lock() bool

func (*RecordLineBuilder) PackMeasure 

func (b *RecordLineBuilder) PackMeasure() int64

func (*RecordLineBuilder) PackMeasureReason 

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

func (*RecordLineBuilder) Region 

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

func (*RecordLineBuilder) Shutdown 

func (b *RecordLineBuilder) Shutdown()

type RecordLineCook 

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

RecordLineCook is RecordLine'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 — RecordLineOpen, RecordLineAt — 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 (*RecordLineCook) Open 

func (cook *RecordLineCook) 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 (RecordLineCook) RegionAlignment 

func (c RecordLineCook) 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 (RecordLineCook) Root 

func (c RecordLineCook) Root() *RecordLineRow

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 (RecordLineCook) RootAlign 

func (c RecordLineCook) RootAlign() int64

func (RecordLineCook) RootSize 

func (c RecordLineCook) RootSize() int64

func (RecordLineCook) Type 

func (c RecordLineCook) Type() *TableCookInfo

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

type RecordLineRow 

type RecordLineRow struct {
	Kind LineKind

	AsDecision int64 // *Decision: signed self-relative delta, zero is null (§6.3)
	AsOutcome  int64 // *Outcome: signed self-relative delta, zero is null (§6.3)
	AsAct      int64 // *Act: signed self-relative delta, zero is null (§6.3)
	// contains filtered or unexported fields
}

RecordLineRow — 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 RecordLineAt 

func RecordLineAt(slot *int64, arena ...*TableArena) *RecordLineRow

RecordLineAt 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 SetEntry 

type SetEntry = SetEntryRow

func SetEntryLoad 

func SetEntryLoad(region, wire []byte, report *TableReport) *SetEntry

func SetEntryLoadRetain 

func SetEntryLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *SetEntry

func SetEntryLoadText 

func SetEntryLoadText(text string, report *TableReport) (*SetEntry, error)

SetEntryLoadText reads one SetEntry 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 SetEntryReadStrict 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 SetEntryReadStrict 

func SetEntryReadStrict(wire []byte) (*SetEntry, error)

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

type SetEntryBuilder 

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

func (*SetEntryBuilder) AsConst 

func (b *SetEntryBuilder) AsConst() *SetEntry

func (*SetEntryBuilder) GetRoot 

func (b *SetEntryBuilder) GetRoot() *SetEntry

func (*SetEntryBuilder) Init 

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

func (*SetEntryBuilder) Lock 

func (b *SetEntryBuilder) Lock() bool

func (*SetEntryBuilder) PackMeasure 

func (b *SetEntryBuilder) PackMeasure() int64

func (*SetEntryBuilder) PackMeasureReason 

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

func (*SetEntryBuilder) Region 

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

func (*SetEntryBuilder) Shutdown 

func (b *SetEntryBuilder) Shutdown()

type SetEntryCook 

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

SetEntryCook is SetEntry'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 — SetEntryOpen, SetEntryAt — 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 (*SetEntryCook) Open 

func (cook *SetEntryCook) 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 (SetEntryCook) RegionAlignment 

func (c SetEntryCook) 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 (SetEntryCook) Root 

func (c SetEntryCook) Root() *SetEntryRow

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 (SetEntryCook) RootAlign 

func (c SetEntryCook) RootAlign() int64

func (SetEntryCook) RootSize 

func (c SetEntryCook) RootSize() int64

func (SetEntryCook) Type 

func (c SetEntryCook) Type() *TableCookInfo

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

type SetEntryRow 

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

SetEntryRow — 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 LogLineSetAdd 

func LogLineSetAdd(worker *TableWorker, holder *TableList[SetEntryRow]) *SetEntryRow

func SetEntryAt 

func SetEntryAt(slot *int64, arena ...*TableArena) *SetEntryRow

SetEntryAt 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 StagePath 

type StagePath = StagePathRow

func StagePathLoad 

func StagePathLoad(region, wire []byte, report *TableReport) *StagePath

func StagePathLoadRetain 

func StagePathLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *StagePath

func StagePathLoadText 

func StagePathLoadText(text string, report *TableReport) (*StagePath, error)

StagePathLoadText reads one StagePath 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 StagePathReadStrict 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 StagePathReadStrict 

func StagePathReadStrict(wire []byte) (*StagePath, error)

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

type StagePathBuilder 

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

func (*StagePathBuilder) AsConst 

func (b *StagePathBuilder) AsConst() *StagePath

func (*StagePathBuilder) GetRoot 

func (b *StagePathBuilder) GetRoot() *StagePath

func (*StagePathBuilder) Init 

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

func (*StagePathBuilder) Lock 

func (b *StagePathBuilder) Lock() bool

func (*StagePathBuilder) PackMeasure 

func (b *StagePathBuilder) PackMeasure() int64

func (*StagePathBuilder) PackMeasureReason 

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

func (*StagePathBuilder) Region 

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

func (*StagePathBuilder) Shutdown 

func (b *StagePathBuilder) Shutdown()

type StagePathCook 

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

StagePathCook is StagePath'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 — StagePathOpen, StagePathAt — 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 (*StagePathCook) Open 

func (cook *StagePathCook) 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 (StagePathCook) RegionAlignment 

func (c StagePathCook) 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 (StagePathCook) Root 

func (c StagePathCook) Root() *StagePathRow

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 (StagePathCook) RootAlign 

func (c StagePathCook) RootAlign() int64

func (StagePathCook) RootSize 

func (c StagePathCook) RootSize() int64

func (StagePathCook) Type 

func (c StagePathCook) Type() *TableCookInfo

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

type StagePathRow 

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

StagePathRow — 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 FrameStageAdd 

func FrameStageAdd(worker *TableWorker, holder *TableList[StagePathRow]) *StagePathRow

func StagePathAt 

func StagePathAt(slot *int64, arena ...*TableArena) *StagePathRow

StagePathAt 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 TableBlockAllocator 

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

TableBlockAllocator supplies exactly one allocation per storage lifetime. Both functions are required; the free receives the original, unsliced buffer.

func TableBlockDefaultAllocator 

func TableBlockDefaultAllocator() TableBlockAllocator

type TableBlockFieldInfo 

type TableBlockFieldInfo struct {
	Name           string
	Offset         uint32 // the field's offset in the record this descriptor describes
	Size           uint32 // its size there
	Kind           uint8  // the table-wire kind, as TableFieldInfo carries it
	OutOfLine      bool   // an out-of-line array: the triple's three members are live
	OffsetOfOffset uint32 // the triple's OffsetOf member, or 0xffffffff
	// The COUNT COMPANION, and it is one column doing one job in both
	// spellings: the triple's Count member for an out-of-line array, the int32
	// used length of a string or a bytes inline, 0xffffffff when the field has
	// none.
	CountOffset  uint32
	StrideOffset uint32 // the triple's Stride member, or 0xffffffff
	Stride       uint32 // THIS BUILD's pitch, to assert against — never to index with (§19.2)

	// ---- what a GENERIC ROW WALK needs, in the vocabulary TableFieldInfo
	// already uses (mas-bandwidth/schema docs/SPEC-TABLES.md §8.1), so ONE walker reads a cooked
	// node and a block row without learning a second one. Where the field
	// starts is the pair above; this is everything after it.
	IsArray       bool   // inline storage of ArrayBound slots at ElemSize (bytes included)
	Counted       bool   // CountOffset names a used-length companion
	Optional      bool   // PresentOffset names a bool presence companion
	ArrayBound    int32  // inline slots, or a string's declared maximum; 0 for a plain scalar
	ElemSize      uint32 // ONE slot's size; the field's own when it holds one value
	PresentOffset uint32 // the presence companion, or 0xffffffff

	// Element is the ELEMENT's or the nested record's own layout, behind a
	// function so a descriptor graph needs no initialisation order. nil when
	// the field is a scalar. Following it is how a walker DESCENDS: an
	// out-of-line array's rows, and a nested record's fields, are both reached
	// through this one column.
	Element func() *TableBlockInfo
}

TableBlockFieldInfo is one field's position in the record this descriptor describes, and everything a GENERIC ROW WALK needs after that.

type TableBlockInfo 

type TableBlockInfo struct {
	Name         string
	BuildVersion uint64 // the unit's (mas-bandwidth/schema docs/SPEC-TABLES.md §20)
	Size         uint32 // the record's own size: a projection's, or a row's
	Align        uint32
	NumFields    int32
	Fields       []TableBlockFieldInfo
}

TableBlockInfo is one record's layout as DATA — the whole mechanism behind the block form's read side. A block-form table's own descriptor describes its PROJECTION; the element descriptor of each out-of-line array describes that array's ROW, and so on down.

type TableBlockRefusal 

type TableBlockRefusal struct {
	Array          string
	Count, Maximum int64
}

TableBlockRefusal names the producer count that violates its declared bound.

type TableBlockRows 

type TableBlockRows[T any] struct {
	Base   unsafe.Pointer
	Count  int32
	Stride int32
}

TableBlockRows is one array's rows, ITERATED at the pitch the INSTANCE gives (§19.2). A call site never spells the pitch arithmetic itself, for the same reason a keyed array's call sites should not re-derive their own slot rule.

func (TableBlockRows[T]) At 

func (r TableBlockRows[T]) At(i int32) *T

At points at one row where it lies, at the pitch the instance gives. It copies nothing.

func (TableBlockRows[T]) Len 

func (r TableBlockRows[T]) Len() int32

---- block fill path: begin ---- Len is the row count the instance carries.

type TableBlockTriple 

type TableBlockTriple struct {
	OffsetOf uint64 // block-relative: the block relocates by plain copy
	Count    uint32 // rows the producer filled; rows past it are not part of the block
	Stride   uint32 // the pitch the consumer indexes with, from the data
}

TableBlockTriple is what a table knows about ONE of its out-of-line arrays: where the rows start, how many there are, and how far apart they sit. Sixteen bytes with no interior padding, sitting at the array field's own position in the projection (§2.7). A consumer reads all three FROM THE INSTANCE, never from its own constants — that is the difference between a generated pair of structs and an ABI (§19.2).

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 

func (m TableBuildVersionMismatch) Error() string

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 (r *TableRetainReader) Body() (TableRetainReader, bool)

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 ActTableInfo TableTypeInfo

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

var AnswerTableInfo TableTypeInfo

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

var BarsTableInfo TableTypeInfo

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

var ChosenTableInfo TableTypeInfo

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

var ClusterCardTableInfo TableTypeInfo

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

var ClusterTableInfo TableTypeInfo

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

var CriterionTableInfo TableTypeInfo

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

var DecideSchemaTableInfo TableTypeInfo

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

var DecidedTableInfo TableTypeInfo

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

var DecisionTableInfo TableTypeInfo

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

var ExampleTableInfo TableTypeInfo

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

var FailureTableInfo TableTypeInfo

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

var FixedAnswerTableInfo TableTypeInfo

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

var FixedTableTableInfo TableTypeInfo

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

var FrameTableInfo TableTypeInfo

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

var GateBarsTableInfo TableTypeInfo

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

var GateLineTableInfo TableTypeInfo

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

var ImportExportTableInfo TableTypeInfo

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

var ImportLogLineTableInfo TableTypeInfo

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

var InputTableInfo TableTypeInfo

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

var JevAnswerTableInfo TableTypeInfo

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

var JevRequestTableInfo TableTypeInfo

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

var JevResponseTableInfo TableTypeInfo

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

var JudgmentIdTableInfo TableTypeInfo

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

var LogExportTableInfo TableTypeInfo

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

var LogLineTableInfo TableTypeInfo

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

var NamedAnswerTableInfo TableTypeInfo

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

var NamedFixedAnswerTableInfo TableTypeInfo

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

var NamedJevAnswerTableInfo TableTypeInfo

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

var NamedQuestionTableInfo TableTypeInfo

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

var OptionPTableInfo TableTypeInfo

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

var OutcomeTableInfo TableTypeInfo

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

var QuestionTableInfo TableTypeInfo

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

var RawRecordTableInfo TableTypeInfo

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

var RawTokensTableInfo TableTypeInfo

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

var RawUsageTableInfo TableTypeInfo

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

var RecordLineTableInfo TableTypeInfo

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

var SetEntryTableInfo TableTypeInfo

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

var StagePathTableInfo TableTypeInfo

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

var UsageTableInfo TableTypeInfo

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

func ActTableType 

func ActTableType() *TableTypeInfo

ActTableType returns Act's reflection descriptor.

func AnswerTableType 

func AnswerTableType() *TableTypeInfo

AnswerTableType returns Answer's reflection descriptor.

func BarsTableType 

func BarsTableType() *TableTypeInfo

BarsTableType returns Bars's reflection descriptor.

func ChosenTableType 

func ChosenTableType() *TableTypeInfo

ChosenTableType returns Chosen's reflection descriptor.

func ClusterCardTableType 

func ClusterCardTableType() *TableTypeInfo

ClusterCardTableType returns ClusterCard's reflection descriptor.

func ClusterTableType 

func ClusterTableType() *TableTypeInfo

ClusterTableType returns Cluster's reflection descriptor.

func CriterionTableType 

func CriterionTableType() *TableTypeInfo

CriterionTableType returns Criterion's reflection descriptor.

func DecideSchemaTableType 

func DecideSchemaTableType() *TableTypeInfo

DecideSchemaTableType returns DecideSchema's reflection descriptor.

func DecidedTableType 

func DecidedTableType() *TableTypeInfo

DecidedTableType returns Decided's reflection descriptor.

func DecisionTableType 

func DecisionTableType() *TableTypeInfo

DecisionTableType returns Decision's reflection descriptor.

func ExampleTableType 

func ExampleTableType() *TableTypeInfo

ExampleTableType returns Example's reflection descriptor.

func FailureTableType 

func FailureTableType() *TableTypeInfo

FailureTableType returns Failure's reflection descriptor.

func FixedAnswerTableType 

func FixedAnswerTableType() *TableTypeInfo

FixedAnswerTableType returns FixedAnswer's reflection descriptor.

func FixedTableTableType 

func FixedTableTableType() *TableTypeInfo

FixedTableTableType returns FixedTable's reflection descriptor.

func FrameTableType 

func FrameTableType() *TableTypeInfo

FrameTableType returns Frame's reflection descriptor.

func GateBarsTableType 

func GateBarsTableType() *TableTypeInfo

GateBarsTableType returns GateBars's reflection descriptor.

func GateLineTableType 

func GateLineTableType() *TableTypeInfo

GateLineTableType returns GateLine's reflection descriptor.

func ImportExportTableType 

func ImportExportTableType() *TableTypeInfo

ImportExportTableType returns ImportExport's reflection descriptor.

func ImportLogLineTableType 

func ImportLogLineTableType() *TableTypeInfo

ImportLogLineTableType returns ImportLogLine's reflection descriptor.

func InputTableType 

func InputTableType() *TableTypeInfo

InputTableType returns Input's reflection descriptor.

func JevAnswerTableType 

func JevAnswerTableType() *TableTypeInfo

JevAnswerTableType returns JevAnswer's reflection descriptor.

func JevRequestTableType 

func JevRequestTableType() *TableTypeInfo

JevRequestTableType returns JevRequest's reflection descriptor.

func JevResponseTableType 

func JevResponseTableType() *TableTypeInfo

JevResponseTableType returns JevResponse's reflection descriptor.

func JudgmentIdTableType 

func JudgmentIdTableType() *TableTypeInfo

JudgmentIdTableType returns JudgmentId's reflection descriptor.

func LogExportTableType 

func LogExportTableType() *TableTypeInfo

LogExportTableType returns LogExport's reflection descriptor.

func LogLineTableType 

func LogLineTableType() *TableTypeInfo

LogLineTableType returns LogLine's reflection descriptor.

func NamedAnswerTableType 

func NamedAnswerTableType() *TableTypeInfo

NamedAnswerTableType returns NamedAnswer's reflection descriptor.

func NamedFixedAnswerTableType 

func NamedFixedAnswerTableType() *TableTypeInfo

NamedFixedAnswerTableType returns NamedFixedAnswer's reflection descriptor.

func NamedJevAnswerTableType 

func NamedJevAnswerTableType() *TableTypeInfo

NamedJevAnswerTableType returns NamedJevAnswer's reflection descriptor.

func NamedQuestionTableType 

func NamedQuestionTableType() *TableTypeInfo

NamedQuestionTableType returns NamedQuestion's reflection descriptor.

func OptionPTableType 

func OptionPTableType() *TableTypeInfo

OptionPTableType returns OptionP's reflection descriptor.

func OutcomeTableType 

func OutcomeTableType() *TableTypeInfo

OutcomeTableType returns Outcome's reflection descriptor.

func QuestionTableType 

func QuestionTableType() *TableTypeInfo

QuestionTableType returns Question's reflection descriptor.

func RawRecordTableType 

func RawRecordTableType() *TableTypeInfo

RawRecordTableType returns RawRecord's reflection descriptor.

func RawTokensTableType 

func RawTokensTableType() *TableTypeInfo

RawTokensTableType returns RawTokens's reflection descriptor.

func RawUsageTableType 

func RawUsageTableType() *TableTypeInfo

RawUsageTableType returns RawUsage's reflection descriptor.

func RecordLineTableType 

func RecordLineTableType() *TableTypeInfo

RecordLineTableType returns RecordLine's reflection descriptor.

func SetEntryTableType 

func SetEntryTableType() *TableTypeInfo

SetEntryTableType returns SetEntry's reflection descriptor.

func StagePathTableType 

func StagePathTableType() *TableTypeInfo

StagePathTableType returns StagePath's reflection descriptor.

func UsageTableType 

func UsageTableType() *TableTypeInfo

UsageTableType returns Usage'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 Usage 

type Usage = UsageRow

func UsageLoadText 

func UsageLoadText(text string, report *TableReport) (*Usage, error)

UsageLoadText fills one Usage from a base64 wire text (mas-bandwidth/schema docs/SPEC-TABLES.md §16.8). It is the STRICT read (§6.5) over the decoded wire: it refuses whenever the read's report holds an error (TableReport.Err), whatever the tolerant Load 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 UsageReadStrict 

func UsageReadStrict(wire []byte) (*Usage, error)

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

type UsageBlock 

type UsageBlock struct {
	Base       unsafe.Pointer        // the extent's base, 64-byte aligned
	Projection *UsageBlockProjection // the projection, at offset 0
	Bytes      int64                 // the extent in use
}

UsageBlock is Usage's block: a pointer and a length, and then rows in place. Opening one is ONE check and no copy; reading a row is one add (§19.2).

The bytes belong to the CONSUMER — a []byte it owns, an mmap, or memory a producer handed across. Nothing here allocates.

A block is valid until the next fill over the SAME storage, which invalidates every block over it and every row pointer taken from one.

func (*UsageBlock) Open 

func (block *UsageBlock) Open(base unsafe.Pointer, bytes int64) error

Open reads all prologue and layout words bytewise before the final base alignment check. Every refusal names the first failed clause in SPEC §19.2.

func (*UsageBlock) Type 

func (b *UsageBlock) Type() *TableBlockInfo

Type is this block's descriptors: constant data, so a reflective read costs a lookup and not a parse. The row layouts hang off the element column rather than taking names of their own, so a walker reaches every record through the graph.

type UsageBlockProjection 

type UsageBlockProjection struct {
	Magic        uint64 // generated: identifies a schema block
	BuildVersion uint64 // generated: the unit's build version (mas-bandwidth/schema docs/SPEC-TABLES.md §20)
	ByteOrder    uint64 // generated: 1 little, 2 big
	InputTokens  int64
	OutputTokens int64
}

UsageBlockProjection — the block PROJECTION: the table's own instance as it sits at the front of a block, opening with the generated PROLOGUE and carrying, per out-of-line array, the triple that says where its rows are. It is a record like any other and follows the same C ABI rule (§19.3).

It is a SEPARATE record from UsageRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type UsageBlockStorage 

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

UsageBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*UsageBlockStorage) Create 

func (s *UsageBlockStorage) Create(a TableBlockAllocator) bool

func (*UsageBlockStorage) Destroy 

func (s *UsageBlockStorage) Destroy()

type UsageCook 

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

UsageCook is Usage'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 — UsageOpen, UsageAt — 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 (*UsageCook) Open 

func (cook *UsageCook) 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 (UsageCook) RegionAlignment 

func (c UsageCook) 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 (UsageCook) Root 

func (c UsageCook) Root() *UsageRow

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 (UsageCook) RootAlign 

func (c UsageCook) RootAlign() int64

func (UsageCook) RootSize 

func (c UsageCook) RootSize() int64

func (UsageCook) Type 

func (c UsageCook) Type() *TableCookInfo

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

type UsageCounts 

type UsageCounts struct {
}

UsageCounts is gathered before Begin; clamping is the caller's policy.

type UsageRow 

type UsageRow struct {
	InputTokens  int64
	OutputTokens int64
}

UsageRow — 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 UsageAt 

func UsageAt(slot *int64, arena ...*TableArena) *UsageRow

UsageAt 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 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
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.