configwire

package
v1.5.0 Latest Latest
Warning

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

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

Documentation

Overview

Package configwire is the nova-config area's table wire, generated by the schema compiler from schemas/config/config.schema: the config row and its change (the history), the file twin's header, the machine and loop views, the inventory and its hosts, the canonical kind words and the Redis view of a machine's beat (the member beat, the bench hash and the merged beat). Every table is a fixed table (schemas/README.md, rule S1). Every other .go file here is generated: edit the .schema and run go generate ./pkg/configwire, 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 BenchBeatBlockMaxBytes int64 = 384

BenchBeatBlockMaxBytes 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 BenchBeatFixedBodyBytes = 284
View Source
const BenchBeatFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const BenchBeatFixedHash = 0x3270a7fa5f15f992
View Source
const BenchBeatFixedRecordBytes = 8 + BenchBeatFixedBodyBytes
View Source
const BenchBeatLoadRetain = "BenchBeat: retention requires a variable root and its region directory"
View Source
const BenchBeatLoadRetainBuilder = "BenchBeat: retention requires a region round trip through the VARIABLE form"
View Source
const BenchBeatLoadRetainMessages = "BenchBeat: retention requires a region round trip through the VARIABLE form"
View Source
const BenchBeatMeasureRetain = "BenchBeat: retention requires a variable root and its region directory"
View Source
const BenchBeatSaveRetain = "BenchBeat: retention requires a variable root and its region directory"
View Source
const BenchBeatSaveRetainMessages = "BenchBeat: retention requires a region round trip through the VARIABLE form"
View Source
const BuildVersion uint64 = 0xb5cd24f03d11f6e6

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 CanonicalWordBlockMaxBytes int64 = 64

CanonicalWordBlockMaxBytes 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 CanonicalWordFixedBodyBytes = 4
View Source
const CanonicalWordFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const CanonicalWordFixedHash = 0xdf248f40299c85cb
View Source
const CanonicalWordFixedRecordBytes = 8 + CanonicalWordFixedBodyBytes
View Source
const CanonicalWordLoadRetain = "CanonicalWord: retention requires a variable root and its region directory"
View Source
const CanonicalWordLoadRetainBuilder = "CanonicalWord: retention requires a region round trip through the VARIABLE form"
View Source
const CanonicalWordLoadRetainMessages = "CanonicalWord: retention requires a region round trip through the VARIABLE form"
View Source
const CanonicalWordMeasureRetain = "CanonicalWord: retention requires a variable root and its region directory"
View Source
const CanonicalWordSaveRetain = "CanonicalWord: retention requires a variable root and its region directory"
View Source
const CanonicalWordSaveRetainMessages = "CanonicalWord: retention requires a region round trip through the VARIABLE form"
View Source
const ConfigChangeBlockMaxBytes int64 = 4992

ConfigChangeBlockMaxBytes 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 ConfigChangeFixedBodyBytes = 4924
View Source
const ConfigChangeFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const ConfigChangeFixedHash = 0x43fd6b70156eec19
View Source
const ConfigChangeFixedRecordBytes = 8 + ConfigChangeFixedBodyBytes
View Source
const ConfigChangeLoadRetain = "ConfigChange: retention requires a variable root and its region directory"
View Source
const ConfigChangeLoadRetainBuilder = "ConfigChange: retention requires a region round trip through the VARIABLE form"
View Source
const ConfigChangeLoadRetainMessages = "ConfigChange: retention requires a region round trip through the VARIABLE form"
View Source
const ConfigChangeMeasureRetain = "ConfigChange: retention requires a variable root and its region directory"
View Source
const ConfigChangeSaveRetain = "ConfigChange: retention requires a variable root and its region directory"
View Source
const ConfigChangeSaveRetainMessages = "ConfigChange: retention requires a region round trip through the VARIABLE form"
View Source
const ConfigRowBlockMaxBytes int64 = 60800

ConfigRowBlockMaxBytes 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 ConfigRowFixedBodyBytes = 60565
View Source
const ConfigRowFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const ConfigRowFixedHash = 0x4b9cd5e2f62b3812
View Source
const ConfigRowFixedRecordBytes = 8 + ConfigRowFixedBodyBytes
View Source
const ConfigRowLoadRetain = "ConfigRow: retention requires a variable root and its region directory"
View Source
const ConfigRowLoadRetainBuilder = "ConfigRow: retention requires a region round trip through the VARIABLE form"
View Source
const ConfigRowLoadRetainMessages = "ConfigRow: retention requires a region round trip through the VARIABLE form"
View Source
const ConfigRowMeasureRetain = "ConfigRow: retention requires a variable root and its region directory"
View Source
const ConfigRowSaveRetain = "ConfigRow: retention requires a variable root and its region directory"
View Source
const ConfigRowSaveRetainMessages = "ConfigRow: retention requires a region round trip through the VARIABLE form"
View Source
const EnvNameBlockMaxBytes int64 = 192

EnvNameBlockMaxBytes 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 EnvNameFixedBodyBytes = 132
View Source
const EnvNameFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const EnvNameFixedHash = 0xd291706d77de7597
View Source
const EnvNameFixedRecordBytes = 8 + EnvNameFixedBodyBytes
View Source
const EnvNameLoadRetain = "EnvName: retention requires a variable root and its region directory"
View Source
const EnvNameLoadRetainBuilder = "EnvName: retention requires a region round trip through the VARIABLE form"
View Source
const EnvNameLoadRetainMessages = "EnvName: retention requires a region round trip through the VARIABLE form"
View Source
const EnvNameMeasureRetain = "EnvName: retention requires a variable root and its region directory"
View Source
const EnvNameSaveRetain = "EnvName: retention requires a variable root and its region directory"
View Source
const EnvNameSaveRetainMessages = "EnvName: retention requires a region round trip through the VARIABLE form"
View Source
const FieldPairBlockMaxBytes int64 = 2432

FieldPairBlockMaxBytes 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 FieldPairFixedBodyBytes = 2344
View Source
const FieldPairFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const FieldPairFixedHash = 0xded9aea60cab908a
View Source
const FieldPairFixedRecordBytes = 8 + FieldPairFixedBodyBytes
View Source
const FieldPairLoadRetain = "FieldPair: retention requires a variable root and its region directory"
View Source
const FieldPairLoadRetainBuilder = "FieldPair: retention requires a region round trip through the VARIABLE form"
View Source
const FieldPairLoadRetainMessages = "FieldPair: retention requires a region round trip through the VARIABLE form"
View Source
const FieldPairMeasureRetain = "FieldPair: retention requires a variable root and its region directory"
View Source
const FieldPairSaveRetain = "FieldPair: retention requires a variable root and its region directory"
View Source
const FieldPairSaveRetainMessages = "FieldPair: retention requires a region round trip through the VARIABLE form"
View Source
const FileHeaderBlockMaxBytes int64 = 64

FileHeaderBlockMaxBytes 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 FileHeaderFixedBodyBytes = 4
View Source
const FileHeaderFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const FileHeaderFixedHash = 0xe4def5308f9deda4
View Source
const FileHeaderFixedRecordBytes = 8 + FileHeaderFixedBodyBytes
View Source
const FileHeaderLoadRetain = "FileHeader: retention requires a variable root and its region directory"
View Source
const FileHeaderLoadRetainBuilder = "FileHeader: retention requires a region round trip through the VARIABLE form"
View Source
const FileHeaderLoadRetainMessages = "FileHeader: retention requires a region round trip through the VARIABLE form"
View Source
const FileHeaderMeasureRetain = "FileHeader: retention requires a variable root and its region directory"
View Source
const FileHeaderSaveRetain = "FileHeader: retention requires a variable root and its region directory"
View Source
const FileHeaderSaveRetainMessages = "FileHeader: retention requires a region round trip through the VARIABLE form"
View Source
const HostGroupBlockMaxBytes int64 = 6592

HostGroupBlockMaxBytes 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 HostGroupFixedBodyBytes = 6340
View Source
const HostGroupFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const HostGroupFixedHash = 0x44490979b82a12f3
View Source
const HostGroupFixedRecordBytes = 8 + HostGroupFixedBodyBytes
View Source
const HostGroupLoadRetain = "HostGroup: retention requires a variable root and its region directory"
View Source
const HostGroupLoadRetainBuilder = "HostGroup: retention requires a region round trip through the VARIABLE form"
View Source
const HostGroupLoadRetainMessages = "HostGroup: retention requires a region round trip through the VARIABLE form"
View Source
const HostGroupMeasureRetain = "HostGroup: retention requires a variable root and its region directory"
View Source
const HostGroupSaveRetain = "HostGroup: retention requires a variable root and its region directory"
View Source
const HostGroupSaveRetainMessages = "HostGroup: retention requires a region round trip through the VARIABLE form"
View Source
const HostNameBlockMaxBytes int64 = 192

HostNameBlockMaxBytes 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 HostNameFixedBodyBytes = 132
View Source
const HostNameFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const HostNameFixedHash = 0x381421630c0a0c0c
View Source
const HostNameFixedRecordBytes = 8 + HostNameFixedBodyBytes
View Source
const HostNameLoadRetain = "HostName: retention requires a variable root and its region directory"
View Source
const HostNameLoadRetainBuilder = "HostName: retention requires a region round trip through the VARIABLE form"
View Source
const HostNameLoadRetainMessages = "HostName: retention requires a region round trip through the VARIABLE form"
View Source
const HostNameMeasureRetain = "HostName: retention requires a variable root and its region directory"
View Source
const HostNameSaveRetain = "HostName: retention requires a variable root and its region directory"
View Source
const HostNameSaveRetainMessages = "HostName: retention requires a region round trip through the VARIABLE form"
View Source
const HostViewBlockMaxBytes int64 = 14272

HostViewBlockMaxBytes 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 HostViewFixedBodyBytes = 14149
View Source
const HostViewFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const HostViewFixedHash = 0x14a68d9c82ada3bc
View Source
const HostViewFixedRecordBytes = 8 + HostViewFixedBodyBytes
View Source
const HostViewLoadRetain = "HostView: retention requires a variable root and its region directory"
View Source
const HostViewLoadRetainBuilder = "HostView: retention requires a region round trip through the VARIABLE form"
View Source
const HostViewLoadRetainMessages = "HostView: retention requires a region round trip through the VARIABLE form"
View Source
const HostViewMeasureRetain = "HostView: retention requires a variable root and its region directory"
View Source
const HostViewSaveRetain = "HostView: retention requires a variable root and its region directory"
View Source
const HostViewSaveRetainMessages = "HostView: retention requires a region round trip through the VARIABLE form"
View Source
const InventoryBlockMaxBytes int64 = 54784

InventoryBlockMaxBytes 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 InventoryFixedBodyBytes = 53104
View Source
const InventoryFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const InventoryFixedHash = 0x5c098637ac4585c0
View Source
const InventoryFixedRecordBytes = 8 + InventoryFixedBodyBytes
View Source
const InventoryLoadRetain = "Inventory: retention requires a variable root and its region directory"
View Source
const InventoryLoadRetainBuilder = "Inventory: retention requires a region round trip through the VARIABLE form"
View Source
const InventoryLoadRetainMessages = "Inventory: retention requires a region round trip through the VARIABLE form"
View Source
const InventoryLoopBlockMaxBytes int64 = 13440

InventoryLoopBlockMaxBytes 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 InventoryLoopFixedBodyBytes = 13214
View Source
const InventoryLoopFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const InventoryLoopFixedHash = 0x277405565f5378f6
View Source
const InventoryLoopFixedRecordBytes = 8 + InventoryLoopFixedBodyBytes
View Source
const InventoryLoopLoadRetain = "InventoryLoop: retention requires a variable root and its region directory"
View Source
const InventoryLoopLoadRetainBuilder = "InventoryLoop: retention requires a region round trip through the VARIABLE form"
View Source
const InventoryLoopLoadRetainMessages = "InventoryLoop: retention requires a region round trip through the VARIABLE form"
View Source
const InventoryLoopMeasureRetain = "InventoryLoop: retention requires a variable root and its region directory"
View Source
const InventoryLoopSaveRetain = "InventoryLoop: retention requires a variable root and its region directory"
View Source
const InventoryLoopSaveRetainMessages = "InventoryLoop: retention requires a region round trip through the VARIABLE form"
View Source
const InventoryMeasureRetain = "Inventory: retention requires a variable root and its region directory"
View Source
const InventorySaveRetain = "Inventory: retention requires a variable root and its region directory"
View Source
const InventorySaveRetainMessages = "Inventory: retention requires a region round trip through the VARIABLE form"
View Source
const KindRevBlockMaxBytes int64 = 64

KindRevBlockMaxBytes 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 KindRevFixedBodyBytes = 9
View Source
const KindRevFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const KindRevFixedHash = 0x75cf084800611cb4
View Source
const KindRevFixedRecordBytes = 8 + KindRevFixedBodyBytes
View Source
const KindRevLoadRetain = "KindRev: retention requires a variable root and its region directory"
View Source
const KindRevLoadRetainBuilder = "KindRev: retention requires a region round trip through the VARIABLE form"
View Source
const KindRevLoadRetainMessages = "KindRev: retention requires a region round trip through the VARIABLE form"
View Source
const KindRevMeasureRetain = "KindRev: retention requires a variable root and its region directory"
View Source
const KindRevSaveRetain = "KindRev: retention requires a variable root and its region directory"
View Source
const KindRevSaveRetainMessages = "KindRev: retention requires a region round trip through the VARIABLE form"
View Source
const MachineBeatBlockMaxBytes int64 = 192

MachineBeatBlockMaxBytes 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 MachineBeatFixedBodyBytes = 140
View Source
const MachineBeatFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const MachineBeatFixedHash = 0x11a1afff1ee664ab
View Source
const MachineBeatFixedRecordBytes = 8 + MachineBeatFixedBodyBytes
View Source
const MachineBeatLoadRetain = "MachineBeat: retention requires a variable root and its region directory"
View Source
const MachineBeatLoadRetainBuilder = "MachineBeat: retention requires a region round trip through the VARIABLE form"
View Source
const MachineBeatLoadRetainMessages = "MachineBeat: retention requires a region round trip through the VARIABLE form"
View Source
const MachineBeatMeasureRetain = "MachineBeat: retention requires a variable root and its region directory"
View Source
const MachineBeatSaveRetain = "MachineBeat: retention requires a variable root and its region directory"
View Source
const MachineBeatSaveRetainMessages = "MachineBeat: retention requires a region round trip through the VARIABLE form"
View Source
const MachineViewBlockMaxBytes int64 = 4928

MachineViewBlockMaxBytes 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 MachineViewFixedBodyBytes = 4830
View Source
const MachineViewFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const MachineViewFixedHash = 0x85ddbb56a7ea3eaf
View Source
const MachineViewFixedRecordBytes = 8 + MachineViewFixedBodyBytes
View Source
const MachineViewLoadRetain = "MachineView: retention requires a variable root and its region directory"
View Source
const MachineViewLoadRetainBuilder = "MachineView: retention requires a region round trip through the VARIABLE form"
View Source
const MachineViewLoadRetainMessages = "MachineView: retention requires a region round trip through the VARIABLE form"
View Source
const MachineViewMeasureRetain = "MachineView: retention requires a variable root and its region directory"
View Source
const MachineViewSaveRetain = "MachineView: retention requires a variable root and its region directory"
View Source
const MachineViewSaveRetainMessages = "MachineView: retention requires a region round trip through the VARIABLE form"
View Source
const MaxActor = 128

MaxActor is the longest actor of a change, in bytes (pkg/config MaxActor, refused by ValidateChangeMeta in the CLI verbs and in every store write): it is the name bound; the longest live actor is 14 bytes.

View Source
const MaxArgvBytes = 4096

MaxArgvBytes is the longest argv in its canonical JSON spelling (pkg/config MaxArgvBytes: at most 64 words and 4096 bytes).

View Source
const MaxEnvName = 128

MaxEnvName is the longest environment variable name in a loop keys list (pkg/config MaxEnvName, the same two refusals): the longest live name is 31 bytes.

View Source
const MaxFieldName = 32

MaxFieldName is the longest field name: the longest today is 28 bytes (the sprint kind).

View Source
const MaxFieldValue = 2304

MaxFieldValue is the longest canonical field value but the argv, in bytes (pkg/config MaxFieldValue, refused by Field.Canonical for every type but argv, which has its own bound below): the longest live value is 575 bytes (a tier's route list). A row's 24 pairs at this bound stay under the 65536 byte record, and a change holds its two rows as two such records.

View Source
const MaxHosts = 48

MaxHosts is the most hosts an inventory group lists (pkg/config MaxHosts, refused by BuildInventory and the fixture reader): the fleet has 11 machines. Eight groups of 48 names of 128 bytes stay under the record limit.

View Source
const MaxKeys = 32

MaxKeys is the most secret names a loop lists (pkg/config MaxKeys, refused by Field.Canonical for a keys field and by the inventory's loop parse): the most a live loop lists is 5.

View Source
const MaxName = 128

MaxName is the longest row, machine, host and friend name, in bytes (pkg/config MaxName, refused by ValidateName and the inventory's name checks): the shape is NamePattern (lower-case letters, digits and dashes) and the length is at most 128; the longest live name is 29 bytes.

View Source
const MaxReason = 4608

MaxReason is the longest reason of a change, in bytes (pkg/config MaxReason, the same two refusals): the longest live reason is about 1050 bytes, so the bound is over four times that.

View Source
const MaxRevs = 8

MaxRevs is the most kinds config:decl carries a revision for (one per kind, eight today).

View Source
const MaxRowFields = 24

MaxRowFields is the most fields a row carries: the widest kind today is the route kind with 23 fields (pkg/config Kinds); one slot is spare.

View Source
const MemberBeatBlockMaxBytes int64 = 64

MemberBeatBlockMaxBytes 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 MemberBeatFixedBodyBytes = 12
View Source
const MemberBeatFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const MemberBeatFixedHash = 0x6f474342f125f54e
View Source
const MemberBeatFixedRecordBytes = 8 + MemberBeatFixedBodyBytes
View Source
const MemberBeatLoadRetain = "MemberBeat: retention requires a variable root and its region directory"
View Source
const MemberBeatLoadRetainBuilder = "MemberBeat: retention requires a region round trip through the VARIABLE form"
View Source
const MemberBeatLoadRetainMessages = "MemberBeat: retention requires a region round trip through the VARIABLE form"
View Source
const MemberBeatMeasureRetain = "MemberBeat: retention requires a variable root and its region directory"
View Source
const MemberBeatSaveRetain = "MemberBeat: retention requires a variable root and its region directory"
View Source
const MemberBeatSaveRetainMessages = "MemberBeat: retention requires a region round trip through the VARIABLE form"
View Source
const ProtocolId uint64 = 0x367dceb63e6664bb

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 RowFieldsBlockMaxBytes int64 = 60608

RowFieldsBlockMaxBytes 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 RowFieldsFixedBodyBytes = 60360
View Source
const RowFieldsFixedFloor = 0

The floor: below it a layout this build once served is retired, and the answer is layout_unsupported rather than layout_unknown (§5.2).

View Source
const RowFieldsFixedHash = 0x8b0bf6aaa436a802
View Source
const RowFieldsFixedRecordBytes = 8 + RowFieldsFixedBodyBytes
View Source
const RowFieldsLoadRetain = "RowFields: retention requires a variable root and its region directory"
View Source
const RowFieldsLoadRetainBuilder = "RowFields: retention requires a region round trip through the VARIABLE form"
View Source
const RowFieldsLoadRetainMessages = "RowFields: retention requires a region round trip through the VARIABLE form"
View Source
const RowFieldsMeasureRetain = "RowFields: retention requires a variable root and its region directory"
View Source
const RowFieldsSaveRetain = "RowFields: retention requires a variable root and its region directory"
View Source
const RowFieldsSaveRetainMessages = "RowFields: 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 = 112
View Source
const TableMessageRefBitsHere = 7

Variables

View Source
var BenchBeatFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(BenchBeat{}.HostLength)), 0, uint32(unsafe.Offsetof(BenchBeat{}.Host)), 0, 1, 1},
	{uint32(unsafe.Offsetof(BenchBeat{}.AtMs)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(BenchBeat{}.Load1Length)), 0, uint32(unsafe.Offsetof(BenchBeat{}.Load1)), 0, 1, 1},
	{uint32(unsafe.Offsetof(BenchBeat{}.NcpuLength)), 0, uint32(unsafe.Offsetof(BenchBeat{}.Ncpu)), 0, 1, 1},
	{uint32(unsafe.Offsetof(BenchBeat{}.CpuLength)), 0, uint32(unsafe.Offsetof(BenchBeat{}.Cpu)), 0, 1, 1},
	{uint32(unsafe.Offsetof(BenchBeat{}.OsLength)), 0, uint32(unsafe.Offsetof(BenchBeat{}.Os)), 0, 1, 1},
	{uint32(unsafe.Offsetof(BenchBeat{}.ArchLength)), 0, uint32(unsafe.Offsetof(BenchBeat{}.Arch)), 0, 1, 1},
	{uint32(unsafe.Offsetof(BenchBeat{}.MemoryGbLength)), 0, uint32(unsafe.Offsetof(BenchBeat{}.MemoryGb)), 0, 1, 1},
}
View Source
var BenchBeatFixedHoles = tableFixedHoles(BenchBeatFixedPlan.Entries, BenchBeatFixedPlan.Count, uint32(len(BenchBeatFixedResetImage)))
View Source
var BenchBeatFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x3270a7fa5f15f992,
		LayoutBytes: 157,
		Record:      292,
		Layout: []byte{
			0x09, 0x00, 0x00, 0x00, 0x59, 0xc4, 0xc2, 0x56, 0x36, 0x3a, 0x3e, 0x83, 0x0d, 0x1c, 0x01, 0x00,
			0x00, 0x08, 0x00, 0x00, 0x00, 0x6f, 0x4d, 0xaf, 0x7e, 0xcc, 0xf8, 0x77, 0x40, 0x0c, 0x84, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0xfd, 0x00, 0xbf, 0x81, 0xbf, 0xfd, 0x41, 0x05, 0x08,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x72, 0xf7, 0xeb, 0xb6, 0x02, 0xce, 0x15, 0x0c,
			0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc5, 0x43, 0x97, 0x98, 0xba, 0x0f, 0x86, 0xd6,
			0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc9, 0x14, 0xb3, 0x0c, 0x19, 0xfa, 0xa8,
			0xf5, 0x0c, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57, 0x5e, 0x56, 0xb5, 0x07, 0x55,
			0xb0, 0x08, 0x0c, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0x33, 0xb2, 0x3e, 0x84,
			0x43, 0x3c, 0x89, 0x0c, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x31, 0x9a, 0x05,
			0x2e, 0xc4, 0x07, 0xb8, 0x0c, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var BenchBeatFixedLayout = []byte{}/* 157 elements not displayed */
View Source
var BenchBeatFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(BenchBeatFixedLineagePlans))
	for i := range BenchBeatFixedLineagePlans {
		lane := &BenchBeatFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(BenchBeatFixedResetImage)))
		}
	}
	return out
}()
View Source
var BenchBeatFixedLineagePlans = tableFixedLineagePlans(BenchBeatFixedKnown, BenchBeatFixedLayout, BenchBeatFixedDst, BenchBeatFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var BenchBeatFixedPlan = tableFixedBuildPlan(BenchBeatFixedLeaves, 8)
View Source
var BenchBeatFixedPlanMax = func() int32 {
	m := BenchBeatFixedPlan.Count
	for _, lane := range BenchBeatFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

BenchBeatFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var BenchBeatFixedResetImage = func() []byte {
	var def BenchBeat
	BenchBeatReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var BenchBeatTableFields = []TableFieldInfo{
	{Name: "host", Json: "host", TypeName: "string", DeclaredTypeName: "string", Id: 0x4077f8cc7eaf4d6f, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(BenchBeat{}.Host)), ElemSize: uint32(unsafe.Sizeof(BenchBeat{}.Host)), CountOffset: uint32(unsafe.Offsetof(BenchBeat{}.HostLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 132, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "at_ms", Json: "at_ms", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x41fdbf81bf00fdc1, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(BenchBeat{}.AtMs)), ElemSize: uint32(unsafe.Sizeof(BenchBeat{}.AtMs)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 136, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 2.53402300799999e+14, 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: "load1", Json: "load1", TypeName: "string", DeclaredTypeName: "string", Id: 0x15ce02b6ebf77208, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 16, Offset: uint32(unsafe.Offsetof(BenchBeat{}.Load1)), ElemSize: uint32(unsafe.Sizeof(BenchBeat{}.Load1)), CountOffset: uint32(unsafe.Offsetof(BenchBeat{}.Load1Length)), PresentOffset: 0xffffffff,
		CookOffset: 144, CookElemSize: 1, CookCountOffset: 164, 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: "ncpu", Json: "ncpu", TypeName: "string", DeclaredTypeName: "string", Id: 0xd6860fba989743c5, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 8, Offset: uint32(unsafe.Offsetof(BenchBeat{}.Ncpu)), ElemSize: uint32(unsafe.Sizeof(BenchBeat{}.Ncpu)), CountOffset: uint32(unsafe.Offsetof(BenchBeat{}.NcpuLength)), PresentOffset: 0xffffffff,
		CookOffset: 168, CookElemSize: 1, CookCountOffset: 180, 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: "cpu", Json: "cpu", TypeName: "string", DeclaredTypeName: "string", Id: 0xf5a8fa190cb314c9, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 16, Offset: uint32(unsafe.Offsetof(BenchBeat{}.Cpu)), ElemSize: uint32(unsafe.Sizeof(BenchBeat{}.Cpu)), CountOffset: uint32(unsafe.Offsetof(BenchBeat{}.CpuLength)), PresentOffset: 0xffffffff,
		CookOffset: 184, CookElemSize: 1, CookCountOffset: 204, 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: "os", Json: "os", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b05507b5565e57, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(BenchBeat{}.Os)), ElemSize: uint32(unsafe.Sizeof(BenchBeat{}.Os)), CountOffset: uint32(unsafe.Offsetof(BenchBeat{}.OsLength)), PresentOffset: 0xffffffff,
		CookOffset: 208, CookElemSize: 1, CookCountOffset: 244, 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: "arch", Json: "arch", TypeName: "string", DeclaredTypeName: "string", Id: 0x893c43843eb23369, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(BenchBeat{}.Arch)), ElemSize: uint32(unsafe.Sizeof(BenchBeat{}.Arch)), CountOffset: uint32(unsafe.Offsetof(BenchBeat{}.ArchLength)), PresentOffset: 0xffffffff,
		CookOffset: 248, CookElemSize: 1, CookCountOffset: 284, 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: "memory_gb", Json: "memory_gb", TypeName: "string", DeclaredTypeName: "string", Id: 0xb807c42e059a310a, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 16, Offset: uint32(unsafe.Offsetof(BenchBeat{}.MemoryGb)), ElemSize: uint32(unsafe.Sizeof(BenchBeat{}.MemoryGb)), CountOffset: uint32(unsafe.Offsetof(BenchBeat{}.MemoryGbLength)), PresentOffset: 0xffffffff,
		CookOffset: 288, CookElemSize: 1, CookCountOffset: 308, 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},
}

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

View Source
var CanonicalWordFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(CanonicalWord{}.Kind)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(CanonicalWord{}.FieldType)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(CanonicalWord{}.Op)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(CanonicalWord{}.Singleton)), 0, 0, 0, 0, 0},
}
View Source
var CanonicalWordFixedHoles = tableFixedHoles(CanonicalWordFixedPlan.Entries, CanonicalWordFixedPlan.Count, uint32(len(CanonicalWordFixedResetImage)))
View Source
var CanonicalWordFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0xdf248f40299c85cb,
		LayoutBytes: 463,
		Record:      12,
		Layout: []byte{
			0x1b, 0x00, 0x00, 0x00, 0x9d, 0x15, 0x86, 0x3d, 0xd9, 0x34, 0x4f, 0x1d, 0x0d, 0x04, 0x00, 0x00,
			0x00, 0x04, 0x00, 0x00, 0x00, 0x43, 0x32, 0x67, 0x21, 0xd7, 0x96, 0x9c, 0xef, 0x1e, 0x01, 0x00,
			0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xce, 0x46, 0xc6, 0x6b, 0x87, 0x22, 0xd6, 0x5d, 0x20, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x79, 0xa2, 0xfb, 0x0a, 0xe0, 0x53, 0x0a, 0x20,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x7e, 0x8a, 0x1b, 0x66, 0xa2, 0x57, 0x9f,
			0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x16, 0x61, 0xb2, 0x24, 0x5f, 0xb6,
			0xf3, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x93, 0x45, 0x8a, 0xb4, 0xe5,
			0xfe, 0x4e, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0x7c, 0x4d, 0xd1, 0xb3,
			0x69, 0x58, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x6a, 0x4d, 0x26,
			0xa8, 0xe2, 0x06, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0xcd, 0x26,
			0x30, 0xfb, 0x85, 0xfd, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x11,
			0x1d, 0x70, 0x83, 0x7b, 0xe0, 0x6a, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x5e,
			0xb4, 0x05, 0x1b, 0xfb, 0xf5, 0x92, 0x24, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x9e, 0xd4, 0x8d, 0xc9, 0x19, 0x1f, 0xa9, 0x41, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x60, 0xd1, 0x31, 0x5f, 0x6c, 0xa7, 0xec, 0xbb, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x21, 0x21, 0x03, 0x80, 0xb4, 0x9b, 0x24, 0x3d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0xaf, 0xf7, 0x98, 0x61, 0x66, 0x10, 0x10, 0x6c, 0x20, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0xe2, 0x1e, 0xac, 0xfe, 0x19, 0xe0, 0xf1, 0x9f, 0x20, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x9d, 0x88, 0x20, 0xc8, 0xa7, 0xd5, 0xbd, 0xf7, 0x20, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0xde, 0x4b, 0x73, 0xde, 0x88, 0xc6, 0xd5, 0x20, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x38, 0x4b, 0x55, 0x8b, 0x2e, 0xf6, 0x06, 0x20,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0x1f, 0x9b, 0xfa, 0x19, 0xaa, 0x44, 0x98,
			0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xac, 0x72, 0x1b, 0xa4, 0x9a, 0x30, 0x65,
			0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x60, 0x56, 0xb5, 0x07, 0x56,
			0xb0, 0x08, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xb4, 0xc9, 0x06, 0xa0, 0x19,
			0xe3, 0xae, 0xf9, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x1a, 0x9b, 0xfa,
			0x19, 0xa7, 0x44, 0x98, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0xf1, 0xb8,
			0x0b, 0x11, 0x08, 0x4f, 0xea, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x95,
			0x29, 0x16, 0x3c, 0x7b, 0x41, 0xbe, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var CanonicalWordFixedLayout = []byte{}/* 463 elements not displayed */
View Source
var CanonicalWordFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(CanonicalWordFixedLineagePlans))
	for i := range CanonicalWordFixedLineagePlans {
		lane := &CanonicalWordFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(CanonicalWordFixedResetImage)))
		}
	}
	return out
}()
View Source
var CanonicalWordFixedLineagePlans = tableFixedLineagePlans(CanonicalWordFixedKnown, CanonicalWordFixedLayout, CanonicalWordFixedDst, CanonicalWordFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var CanonicalWordFixedPlan = tableFixedBuildPlan(CanonicalWordFixedLeaves, 4)
View Source
var CanonicalWordFixedPlanMax = func() int32 {
	m := CanonicalWordFixedPlan.Count
	for _, lane := range CanonicalWordFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

CanonicalWordFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var CanonicalWordFixedResetImage = func() []byte {
	var def CanonicalWord
	CanonicalWordReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var CanonicalWordTableFields = []TableFieldInfo{
	{Name: "kind", Json: "kind", TypeName: "ConfigKind", DeclaredTypeName: "ConfigKind", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(CanonicalWord{}.Kind)), ElemSize: uint32(unsafe.Sizeof(CanonicalWord{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameConfigKind(ConfigKind(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := ConfigKind(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "field_type", Json: "field_type", TypeName: "FieldType", DeclaredTypeName: "FieldType", Id: 0x6ae07b83701d11a0, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(CanonicalWord{}.FieldType)), ElemSize: uint32(unsafe.Sizeof(CanonicalWord{}.FieldType)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 1, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 11,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameFieldType(FieldType(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := FieldType(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "op", Json: "op", TypeName: "ChangeOp", DeclaredTypeName: "ChangeOp", Id: 0x8b05607b556600a, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(CanonicalWord{}.Op)), ElemSize: uint32(unsafe.Sizeof(CanonicalWord{}.Op)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 2, 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 EnumNameChangeOp(ChangeOp(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := ChangeOp(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "singleton", Json: "singleton", TypeName: "bool", DeclaredTypeName: "bool", Id: 0xbe417b3c16299522, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(CanonicalWord{}.Singleton)), ElemSize: uint32(unsafe.Sizeof(CanonicalWord{}.Singleton)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 3, 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},
}

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

View Source
var ConfigChangeFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(ConfigChange{}.Id)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(ConfigChange{}.Kind)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(ConfigChange{}.NameLength)), 0, uint32(unsafe.Offsetof(ConfigChange{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(ConfigChange{}.Op)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(ConfigChange{}.HasBefore)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(ConfigChange{}.HasAfter)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(ConfigChange{}.ActorLength)), 0, uint32(unsafe.Offsetof(ConfigChange{}.Actor)), 0, 1, 1},
	{uint32(unsafe.Offsetof(ConfigChange{}.ReasonLength)), 0, uint32(unsafe.Offsetof(ConfigChange{}.Reason)), 0, 1, 1},
	{uint32(unsafe.Offsetof(ConfigChange{}.AtLength)), 0, uint32(unsafe.Offsetof(ConfigChange{}.At)), 0, 1, 1},
}
View Source
var ConfigChangeFixedHoles = tableFixedHoles(ConfigChangeFixedPlan.Entries, ConfigChangeFixedPlan.Count, uint32(len(ConfigChangeFixedResetImage)))
View Source
var ConfigChangeFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x43fd6b70156eec19,
		LayoutBytes: 361,
		Record:      4932,
		Layout: []byte{
			0x15, 0x00, 0x00, 0x00, 0xa3, 0xd3, 0x35, 0x4b, 0x72, 0x52, 0x8e, 0xe2, 0x0d, 0x3c, 0x13, 0x00,
			0x00, 0x09, 0x00, 0x00, 0x00, 0xc0, 0x3a, 0x5c, 0xb5, 0x07, 0x2e, 0xb7, 0x08, 0x05, 0x08, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x32, 0x67, 0x21, 0xd7, 0x96, 0x9c, 0xef, 0x1e, 0x01,
			0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xce, 0x46, 0xc6, 0x6b, 0x87, 0x22, 0xd6, 0x5d, 0x20,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x79, 0xa2, 0xfb, 0x0a, 0xe0, 0x53, 0x0a,
			0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x7e, 0x8a, 0x1b, 0x66, 0xa2, 0x57,
			0x9f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x16, 0x61, 0xb2, 0x24, 0x5f,
			0xb6, 0xf3, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x93, 0x45, 0x8a, 0xb4,
			0xe5, 0xfe, 0x4e, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0x7c, 0x4d, 0xd1,
			0xb3, 0x69, 0x58, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x6a, 0x4d,
			0x26, 0xa8, 0xe2, 0x06, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0xcd,
			0x26, 0x30, 0xfb, 0x85, 0xfd, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86,
			0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x0a, 0x60, 0x56, 0xb5, 0x07, 0x56, 0xb0, 0x08, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
			0x00, 0xb4, 0xc9, 0x06, 0xa0, 0x19, 0xe3, 0xae, 0xf9, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x83, 0x1a, 0x9b, 0xfa, 0x19, 0xa7, 0x44, 0x98, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x5d, 0xf1, 0xb8, 0x0b, 0x11, 0x08, 0x4f, 0xea, 0x20, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x2f, 0xaf, 0xc3, 0x09, 0xef, 0x33, 0x1f, 0x51, 0x01, 0x01, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xd4, 0x21, 0xf2, 0x9a, 0x52, 0x0f, 0x0b, 0x01, 0x01, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xda, 0xd4, 0x47, 0x1c, 0x39, 0xc5, 0xcc, 0xdc, 0x0c, 0x84,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, 0x26, 0x4f, 0x47, 0xf3, 0xd7, 0xe8, 0x65, 0x0c,
			0x04, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xa9, 0x45, 0xb5, 0x07, 0x4e, 0x9c, 0x08,
			0x0c, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var ConfigChangeFixedLayout = []byte{}/* 361 elements not displayed */
View Source
var ConfigChangeFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(ConfigChangeFixedLineagePlans))
	for i := range ConfigChangeFixedLineagePlans {
		lane := &ConfigChangeFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(ConfigChangeFixedResetImage)))
		}
	}
	return out
}()
View Source
var ConfigChangeFixedLineagePlans = tableFixedLineagePlans(ConfigChangeFixedKnown, ConfigChangeFixedLayout, ConfigChangeFixedDst, ConfigChangeFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var ConfigChangeFixedPlan = tableFixedBuildPlan(ConfigChangeFixedLeaves, 9)
View Source
var ConfigChangeFixedPlanMax = func() int32 {
	m := ConfigChangeFixedPlan.Count
	for _, lane := range ConfigChangeFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

ConfigChangeFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var ConfigChangeFixedResetImage = func() []byte {
	var def ConfigChange
	ConfigChangeReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var ConfigChangeTableFields = []TableFieldInfo{
	{Name: "id", Json: "id", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x8b72e07b55c3ac0, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ConfigChange{}.Id)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.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: false, TargetId: 0x0000000000000000,
		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: "ConfigKind", DeclaredTypeName: "ConfigKind", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ConfigChange{}.Kind)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameConfigKind(ConfigKind(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := ConfigKind(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "name", Json: "name", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4bcadba8e631b86, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(ConfigChange{}.Name)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.Name)), CountOffset: uint32(unsafe.Offsetof(ConfigChange{}.NameLength)), PresentOffset: 0xffffffff,
		CookOffset: 9, CookElemSize: 1, CookCountOffset: 140, 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: "ChangeOp", DeclaredTypeName: "ChangeOp", Id: 0x8b05607b556600a, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ConfigChange{}.Op)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.Op)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 144, 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 EnumNameChangeOp(ChangeOp(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := ChangeOp(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "has_before", Json: "has_before", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x511f33ef09c3af2f, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ConfigChange{}.HasBefore)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.HasBefore)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 145, 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: "has_after", Json: "has_after", TypeName: "bool", DeclaredTypeName: "bool", Id: 0xb0f529af221d41e, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ConfigChange{}.HasAfter)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.HasAfter)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 146, 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: "actor", Json: "actor", TypeName: "string", DeclaredTypeName: "string", Id: 0xdcccc5391c47d4da, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(ConfigChange{}.Actor)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.Actor)), CountOffset: uint32(unsafe.Offsetof(ConfigChange{}.ActorLength)), PresentOffset: 0xffffffff,
		CookOffset: 147, CookElemSize: 1, CookCountOffset: 276, 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: "reason", Json: "reason", TypeName: "string", DeclaredTypeName: "string", Id: 0x65e8d7f3474f2639, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 4608, Offset: uint32(unsafe.Offsetof(ConfigChange{}.Reason)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.Reason)), CountOffset: uint32(unsafe.Offsetof(ConfigChange{}.ReasonLength)), PresentOffset: 0xffffffff,
		CookOffset: 280, CookElemSize: 1, CookCountOffset: 4892, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "at", Json: "at", TypeName: "string", DeclaredTypeName: "string", Id: 0x89c4e07b545a968, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(ConfigChange{}.At)), ElemSize: uint32(unsafe.Sizeof(ConfigChange{}.At)), CountOffset: uint32(unsafe.Offsetof(ConfigChange{}.AtLength)), PresentOffset: 0xffffffff,
		CookOffset: 4896, CookElemSize: 1, CookCountOffset: 4932, 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},
}

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

View Source
var ConfigRowFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(ConfigRow{}.Kind)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(ConfigRow{}.NameLength)), 0, uint32(unsafe.Offsetof(ConfigRow{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(ConfigRow{}.Fields)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(RowFields{}.Pairs)), uint32(unsafe.Sizeof(FieldPair{})), uint32(unsafe.Offsetof(RowFields{}.PairsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(FieldPair{}.NameLength)), 0, uint32(unsafe.Offsetof(FieldPair{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(FieldPair{}.ValueLength)), 0, uint32(unsafe.Offsetof(FieldPair{}.Value)), 0, 1, 1},
	{uint32(unsafe.Offsetof(RowFields{}.ArgvLength)), 0, uint32(unsafe.Offsetof(RowFields{}.Argv)), 0, 1, 1},
	{uint32(unsafe.Offsetof(ConfigRow{}.CreatedAtLength)), 0, uint32(unsafe.Offsetof(ConfigRow{}.CreatedAt)), 0, 1, 1},
	{uint32(unsafe.Offsetof(ConfigRow{}.UpdatedAtLength)), 0, uint32(unsafe.Offsetof(ConfigRow{}.UpdatedAt)), 0, 1, 1},
}
View Source
var ConfigRowFixedHoles = tableFixedHoles(ConfigRowFixedPlan.Entries, ConfigRowFixedPlan.Count, uint32(len(ConfigRowFixedResetImage)))
View Source
var ConfigRowFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x4b9cd5e2f62b3812,
		LayoutBytes: 327,
		Record:      60573,
		Layout: []byte{
			0x13, 0x00, 0x00, 0x00, 0x35, 0x53, 0xd9, 0x4c, 0xbb, 0x76, 0x0d, 0xe0, 0x0d, 0x95, 0xec, 0x00,
			0x00, 0x05, 0x00, 0x00, 0x00, 0x43, 0x32, 0x67, 0x21, 0xd7, 0x96, 0x9c, 0xef, 0x1e, 0x01, 0x00,
			0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xce, 0x46, 0xc6, 0x6b, 0x87, 0x22, 0xd6, 0x5d, 0x20, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x79, 0xa2, 0xfb, 0x0a, 0xe0, 0x53, 0x0a, 0x20,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x7e, 0x8a, 0x1b, 0x66, 0xa2, 0x57, 0x9f,
			0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x16, 0x61, 0xb2, 0x24, 0x5f, 0xb6,
			0xf3, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x93, 0x45, 0x8a, 0xb4, 0xe5,
			0xfe, 0x4e, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0x7c, 0x4d, 0xd1, 0xb3,
			0x69, 0x58, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x6a, 0x4d, 0x26,
			0xa8, 0xe2, 0x06, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0xcd, 0x26,
			0x30, 0xfb, 0x85, 0xfd, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x1b,
			0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc,
			0x7e, 0x84, 0x24, 0x6d, 0x59, 0x0e, 0x49, 0x0d, 0xc8, 0xeb, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
			0x26, 0x1e, 0x1e, 0x39, 0xa7, 0x38, 0x44, 0x54, 0x0e, 0xc4, 0xdb, 0x00, 0x00, 0x01, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x28, 0x09, 0x00, 0x00, 0x02, 0x00,
			0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x24, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0xea, 0x0c, 0xe8, 0x30, 0x94, 0xfd, 0xe4, 0x7c, 0x0c, 0x04, 0x09, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x63, 0x98, 0xbc, 0x3e, 0x84, 0x2d, 0x49, 0x89, 0x0c, 0x04, 0x10, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x79, 0x39, 0xf1, 0xbf, 0xd1, 0xb6, 0x68, 0xd4, 0x0c, 0x24, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x74, 0x03, 0xef, 0x68, 0x29, 0xd1, 0xca, 0x0c, 0x24,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var ConfigRowFixedLayout = []byte{}/* 327 elements not displayed */
View Source
var ConfigRowFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(ConfigRowFixedLineagePlans))
	for i := range ConfigRowFixedLineagePlans {
		lane := &ConfigRowFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(ConfigRowFixedResetImage)))
		}
	}
	return out
}()
View Source
var ConfigRowFixedLineagePlans = tableFixedLineagePlans(ConfigRowFixedKnown, ConfigRowFixedLayout, ConfigRowFixedDst, ConfigRowFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var ConfigRowFixedPlan = tableFixedBuildPlan(ConfigRowFixedLeaves, 54)
View Source
var ConfigRowFixedPlanMax = func() int32 {
	m := ConfigRowFixedPlan.Count
	for _, lane := range ConfigRowFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

ConfigRowFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var ConfigRowFixedResetImage = func() []byte {
	var def ConfigRow
	ConfigRowReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var ConfigRowTableFields = []TableFieldInfo{
	{Name: "kind", Json: "kind", TypeName: "ConfigKind", DeclaredTypeName: "ConfigKind", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ConfigRow{}.Kind)), ElemSize: uint32(unsafe.Sizeof(ConfigRow{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameConfigKind(ConfigKind(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := ConfigKind(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "name", Json: "name", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4bcadba8e631b86, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(ConfigRow{}.Name)), ElemSize: uint32(unsafe.Sizeof(ConfigRow{}.Name)), CountOffset: uint32(unsafe.Offsetof(ConfigRow{}.NameLength)), PresentOffset: 0xffffffff,
		CookOffset: 1, CookElemSize: 1, CookCountOffset: 132, 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: "fields", Json: "fields", TypeName: "RowFields", DeclaredTypeName: "RowFields", Id: 0x490e596d24847edc, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(ConfigRow{}.Fields)), ElemSize: uint32(unsafe.Sizeof(ConfigRow{}.Fields)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 136, CookElemSize: 60556, 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: RowFieldsTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "created_at", Json: "created_at", TypeName: "string", DeclaredTypeName: "string", Id: 0xd468b6d1bff13979, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(ConfigRow{}.CreatedAt)), ElemSize: uint32(unsafe.Sizeof(ConfigRow{}.CreatedAt)), CountOffset: uint32(unsafe.Offsetof(ConfigRow{}.CreatedAtLength)), PresentOffset: 0xffffffff,
		CookOffset: 60692, CookElemSize: 1, CookCountOffset: 60728, 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: "updated_at", Json: "updated_at", TypeName: "string", DeclaredTypeName: "string", Id: 0xcad12968ef0374e0, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(ConfigRow{}.UpdatedAt)), ElemSize: uint32(unsafe.Sizeof(ConfigRow{}.UpdatedAt)), CountOffset: uint32(unsafe.Offsetof(ConfigRow{}.UpdatedAtLength)), PresentOffset: 0xffffffff,
		CookOffset: 60732, CookElemSize: 1, CookCountOffset: 60768, 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},
}

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

View Source
var EnvNameFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(EnvName{}.NameLength)), 0, uint32(unsafe.Offsetof(EnvName{}.Name)), 0, 1, 1},
}
View Source
var EnvNameFixedHoles = tableFixedHoles(EnvNameFixedPlan.Entries, EnvNameFixedPlan.Count, uint32(len(EnvNameFixedResetImage)))
View Source
var EnvNameFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0xd291706d77de7597,
		LayoutBytes: 38,
		Record:      140,
		Layout: []byte{
			0x02, 0x00, 0x00, 0x00, 0xcf, 0x77, 0x40, 0x1b, 0x4f, 0x59, 0xe1, 0xeb, 0x0d, 0x84, 0x00, 0x00,
			0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var EnvNameFixedLayout = []byte{
	0x02, 0x00, 0x00, 0x00, 0xcf, 0x77, 0x40, 0x1b, 0x4f, 0x59, 0xe1, 0xeb, 0x0d, 0x84, 0x00, 0x00,
	0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
View Source
var EnvNameFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(EnvNameFixedLineagePlans))
	for i := range EnvNameFixedLineagePlans {
		lane := &EnvNameFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(EnvNameFixedResetImage)))
		}
	}
	return out
}()
View Source
var EnvNameFixedLineagePlans = tableFixedLineagePlans(EnvNameFixedKnown, EnvNameFixedLayout, EnvNameFixedDst, EnvNameFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var EnvNameFixedPlan = tableFixedBuildPlan(EnvNameFixedLeaves, 1)
View Source
var EnvNameFixedPlanMax = func() int32 {
	m := EnvNameFixedPlan.Count
	for _, lane := range EnvNameFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

EnvNameFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var EnvNameFixedResetImage = func() []byte {
	var def EnvName
	EnvNameReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var EnvNameTableFields = []TableFieldInfo{
	{Name: "name", Json: "name", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4bcadba8e631b86, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(EnvName{}.Name)), ElemSize: uint32(unsafe.Sizeof(EnvName{}.Name)), CountOffset: uint32(unsafe.Offsetof(EnvName{}.NameLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 132, 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},
}

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

View Source
var ErrValidation = errors.New("configwire: 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 FieldPairFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(FieldPair{}.NameLength)), 0, uint32(unsafe.Offsetof(FieldPair{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(FieldPair{}.ValueLength)), 0, uint32(unsafe.Offsetof(FieldPair{}.Value)), 0, 1, 1},
}
View Source
var FieldPairFixedHoles = tableFixedHoles(FieldPairFixedPlan.Entries, FieldPairFixedPlan.Count, uint32(len(FieldPairFixedResetImage)))
View Source
var FieldPairFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0xded9aea60cab908a,
		LayoutBytes: 55,
		Record:      2352,
		Layout: []byte{
			0x03, 0x00, 0x00, 0x00, 0xc7, 0xb8, 0xa9, 0x72, 0x79, 0x6d, 0xca, 0x21, 0x0d, 0x28, 0x09, 0x00,
			0x00, 0x02, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x24, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x0c, 0xe8, 0x30, 0x94, 0xfd, 0xe4, 0x7c, 0x0c, 0x04,
			0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var FieldPairFixedLayout = []byte{
	0x03, 0x00, 0x00, 0x00, 0xc7, 0xb8, 0xa9, 0x72, 0x79, 0x6d, 0xca, 0x21, 0x0d, 0x28, 0x09, 0x00,
	0x00, 0x02, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x24, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x0c, 0xe8, 0x30, 0x94, 0xfd, 0xe4, 0x7c, 0x0c, 0x04,
	0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
View Source
var FieldPairFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(FieldPairFixedLineagePlans))
	for i := range FieldPairFixedLineagePlans {
		lane := &FieldPairFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(FieldPairFixedResetImage)))
		}
	}
	return out
}()
View Source
var FieldPairFixedLineagePlans = tableFixedLineagePlans(FieldPairFixedKnown, FieldPairFixedLayout, FieldPairFixedDst, FieldPairFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var FieldPairFixedPlan = tableFixedBuildPlan(FieldPairFixedLeaves, 2)
View Source
var FieldPairFixedPlanMax = func() int32 {
	m := FieldPairFixedPlan.Count
	for _, lane := range FieldPairFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

FieldPairFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var FieldPairFixedResetImage = func() []byte {
	var def FieldPair
	FieldPairReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var FieldPairTableFields = []TableFieldInfo{
	{Name: "name", Json: "name", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4bcadba8e631b86, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(FieldPair{}.Name)), ElemSize: uint32(unsafe.Sizeof(FieldPair{}.Name)), CountOffset: uint32(unsafe.Offsetof(FieldPair{}.NameLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 36, 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: "value", Json: "value", TypeName: "string", DeclaredTypeName: "string", Id: 0x7ce4fd9430e80cea, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(FieldPair{}.Value)), ElemSize: uint32(unsafe.Sizeof(FieldPair{}.Value)), CountOffset: uint32(unsafe.Offsetof(FieldPair{}.ValueLength)), PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 1, CookCountOffset: 2348, 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},
}

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

View Source
var FileHeaderFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(FileHeader{}.Schema)), 0, 0, 0, 0, 0},
}
View Source
var FileHeaderFixedHoles = tableFixedHoles(FileHeaderFixedPlan.Entries, FileHeaderFixedPlan.Count, uint32(len(FileHeaderFixedResetImage)))
View Source
var FileHeaderFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0xe4def5308f9deda4,
		LayoutBytes: 38,
		Record:      12,
		Layout: []byte{
			0x02, 0x00, 0x00, 0x00, 0x52, 0xf5, 0x43, 0x22, 0x21, 0x0d, 0xb9, 0xfc, 0x0d, 0x04, 0x00, 0x00,
			0x00, 0x01, 0x00, 0x00, 0x00, 0xb6, 0x67, 0x46, 0x76, 0xff, 0x17, 0x8d, 0x75, 0x04, 0x04, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var FileHeaderFixedLayout = []byte{
	0x02, 0x00, 0x00, 0x00, 0x52, 0xf5, 0x43, 0x22, 0x21, 0x0d, 0xb9, 0xfc, 0x0d, 0x04, 0x00, 0x00,
	0x00, 0x01, 0x00, 0x00, 0x00, 0xb6, 0x67, 0x46, 0x76, 0xff, 0x17, 0x8d, 0x75, 0x04, 0x04, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
View Source
var FileHeaderFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(FileHeaderFixedLineagePlans))
	for i := range FileHeaderFixedLineagePlans {
		lane := &FileHeaderFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(FileHeaderFixedResetImage)))
		}
	}
	return out
}()
View Source
var FileHeaderFixedLineagePlans = tableFixedLineagePlans(FileHeaderFixedKnown, FileHeaderFixedLayout, FileHeaderFixedDst, FileHeaderFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var FileHeaderFixedPlan = tableFixedBuildPlan(FileHeaderFixedLeaves, 1)
View Source
var FileHeaderFixedPlanMax = func() int32 {
	m := FileHeaderFixedPlan.Count
	for _, lane := range FileHeaderFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

FileHeaderFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var FileHeaderFixedResetImage = func() []byte {
	var def FileHeader
	FileHeaderReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var FileHeaderTableFields = []TableFieldInfo{
	{Name: "schema", Json: "schema", TypeName: "int32", DeclaredTypeName: "int32", Id: 0x758d17ff764667b6, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FileHeader{}.Schema)), ElemSize: uint32(unsafe.Sizeof(FileHeader{}.Schema)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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},
}

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

View Source
var HostGroupFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
}
View Source
var HostGroupFixedHoles = tableFixedHoles(HostGroupFixedPlan.Entries, HostGroupFixedPlan.Count, uint32(len(HostGroupFixedResetImage)))
View Source
var HostGroupFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x44490979b82a12f3,
		LayoutBytes: 72,
		Record:      6348,
		Layout: []byte{
			0x04, 0x00, 0x00, 0x00, 0xb6, 0xb7, 0x67, 0x61, 0xd1, 0x4f, 0xb7, 0x7c, 0x0d, 0xc4, 0x18, 0x00,
			0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x06, 0xe0, 0x43, 0x7b, 0xdf, 0x28, 0x3b, 0x0e, 0xc4, 0x18,
			0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x84,
			0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c,
			0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var HostGroupFixedLayout = []byte{
	0x04, 0x00, 0x00, 0x00, 0xb6, 0xb7, 0x67, 0x61, 0xd1, 0x4f, 0xb7, 0x7c, 0x0d, 0xc4, 0x18, 0x00,
	0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x06, 0xe0, 0x43, 0x7b, 0xdf, 0x28, 0x3b, 0x0e, 0xc4, 0x18,
	0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x84,
	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c,
	0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
View Source
var HostGroupFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(HostGroupFixedLineagePlans))
	for i := range HostGroupFixedLineagePlans {
		lane := &HostGroupFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(HostGroupFixedResetImage)))
		}
	}
	return out
}()
View Source
var HostGroupFixedLineagePlans = tableFixedLineagePlans(HostGroupFixedKnown, HostGroupFixedLayout, HostGroupFixedDst, HostGroupFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var HostGroupFixedPlan = tableFixedBuildPlan(HostGroupFixedLeaves, 49)
View Source
var HostGroupFixedPlanMax = func() int32 {
	m := HostGroupFixedPlan.Count
	for _, lane := range HostGroupFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

HostGroupFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var HostGroupFixedResetImage = func() []byte {
	var def HostGroup
	HostGroupReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var HostGroupTableFields = []TableFieldInfo{
	{Name: "hosts", Json: "hosts", TypeName: "HostName", DeclaredTypeName: "HostName", Id: 0x3b28df7b43e00694, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 48, Offset: uint32(unsafe.Offsetof(HostGroup{}.Hosts)), ElemSize: uint32(unsafe.Sizeof(HostGroup{}.Hosts[0])), CountOffset: uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 136, CookCountOffset: 6528, 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: HostNameTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source
var HostNameFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
}
View Source
var HostNameFixedHoles = tableFixedHoles(HostNameFixedPlan.Entries, HostNameFixedPlan.Count, uint32(len(HostNameFixedResetImage)))
View Source
var HostNameFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x381421630c0a0c0c,
		LayoutBytes: 38,
		Record:      140,
		Layout: []byte{
			0x02, 0x00, 0x00, 0x00, 0xac, 0xbd, 0xb7, 0xc6, 0x29, 0x6d, 0x89, 0xf3, 0x0d, 0x84, 0x00, 0x00,
			0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var HostNameFixedLayout = []byte{
	0x02, 0x00, 0x00, 0x00, 0xac, 0xbd, 0xb7, 0xc6, 0x29, 0x6d, 0x89, 0xf3, 0x0d, 0x84, 0x00, 0x00,
	0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
View Source
var HostNameFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(HostNameFixedLineagePlans))
	for i := range HostNameFixedLineagePlans {
		lane := &HostNameFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(HostNameFixedResetImage)))
		}
	}
	return out
}()
View Source
var HostNameFixedLineagePlans = tableFixedLineagePlans(HostNameFixedKnown, HostNameFixedLayout, HostNameFixedDst, HostNameFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var HostNameFixedPlan = tableFixedBuildPlan(HostNameFixedLeaves, 1)
View Source
var HostNameFixedPlanMax = func() int32 {
	m := HostNameFixedPlan.Count
	for _, lane := range HostNameFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

HostNameFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var HostNameFixedResetImage = func() []byte {
	var def HostName
	HostNameReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var HostNameTableFields = []TableFieldInfo{
	{Name: "name", Json: "name", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4bcadba8e631b86, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(HostName{}.Name)), ElemSize: uint32(unsafe.Sizeof(HostName{}.Name)), CountOffset: uint32(unsafe.Offsetof(HostName{}.NameLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 132, 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},
}

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

View Source
var HostViewFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.AnsibleHostLength)), 0, uint32(unsafe.Offsetof(HostView{}.AnsibleHost)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.Kind)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.Slots)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.SlotsCapacity)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.Runners)), 0, 0, 0, 0, 0},
	{0, 0, uint32(unsafe.Offsetof(HostView{}.SlotsSharePresent)), 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.SlotsShare)), 0, 0, 0, 0, 0},
	{0, 0, uint32(unsafe.Offsetof(HostView{}.CoresPresent)), 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.Cores)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.BenchOsLength)), 0, uint32(unsafe.Offsetof(HostView{}.BenchOs)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.NovaArchLength)), 0, uint32(unsafe.Offsetof(HostView{}.NovaArch)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.NovaTla)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.RegistrySeatLength)), 0, uint32(unsafe.Offsetof(HostView{}.RegistrySeat)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.RegistryRolesLength)), 0, uint32(unsafe.Offsetof(HostView{}.RegistryRoles)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.AnsibleUserLength)), 0, uint32(unsafe.Offsetof(HostView{}.AnsibleUser)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.NovaSeatLength)), 0, uint32(unsafe.Offsetof(HostView{}.NovaSeat)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.NovaRedisAddrLength)), 0, uint32(unsafe.Offsetof(HostView{}.NovaRedisAddr)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.NovaBusAddrLength)), 0, uint32(unsafe.Offsetof(HostView{}.NovaBusAddr)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.NovaRedisPort)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostView{}.NovaPgDsnLength)), 0, uint32(unsafe.Offsetof(HostView{}.NovaPgDsn)), 0, 1, 1},
	{uint32(unsafe.Offsetof(HostView{}.Local)), 0, 0, 0, 0, 0},
}
View Source
var HostViewFixedHoles = tableFixedHoles(HostViewFixedPlan.Entries, HostViewFixedPlan.Count, uint32(len(HostViewFixedResetImage)))
View Source
var HostViewFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x14a68d9c82ada3bc,
		LayoutBytes: 514,
		Record:      14157,
		Layout: []byte{
			0x1e, 0x00, 0x00, 0x00, 0x7a, 0x4d, 0xdc, 0x41, 0xef, 0xd7, 0x97, 0x5a, 0x0d, 0x45, 0x37, 0x00,
			0x00, 0x13, 0x00, 0x00, 0x00, 0xa6, 0xc6, 0x05, 0x3f, 0xa6, 0xae, 0xc8, 0xb1, 0x0c, 0x84, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x32, 0x67, 0x21, 0xd7, 0x96, 0x9c, 0xef, 0x1e, 0x01,
			0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xce, 0x46, 0xc6, 0x6b, 0x87, 0x22, 0xd6, 0x5d, 0x20,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x79, 0xa2, 0xfb, 0x0a, 0xe0, 0x53, 0x0a,
			0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x7e, 0x8a, 0x1b, 0x66, 0xa2, 0x57,
			0x9f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x16, 0x61, 0xb2, 0x24, 0x5f,
			0xb6, 0xf3, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x93, 0x45, 0x8a, 0xb4,
			0xe5, 0xfe, 0x4e, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0x7c, 0x4d, 0xd1,
			0xb3, 0x69, 0x58, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x6a, 0x4d,
			0x26, 0xa8, 0xe2, 0x06, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0xcd,
			0x26, 0x30, 0xfb, 0x85, 0xfd, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46,
			0x56, 0xee, 0xb1, 0x6b, 0x2e, 0x8c, 0xe6, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x4f, 0xe4, 0x35, 0x5a, 0xb3, 0x24, 0xf3, 0x20, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x38, 0x76, 0xf4, 0x0e, 0xb5, 0x3f, 0xf3, 0x83, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x12, 0x88, 0xb1, 0xe6, 0x55, 0x46, 0xe6, 0x2f, 0x23, 0x05, 0x00, 0x00, 0x00, 0x01,
			0x00, 0x00, 0x00, 0x12, 0x88, 0xb1, 0xe6, 0x55, 0x46, 0xe6, 0x2f, 0x04, 0x04, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0xb7, 0x61, 0x48, 0x55, 0x8e, 0x64, 0x57, 0xce, 0x23, 0x05, 0x00, 0x00,
			0x00, 0x01, 0x00, 0x00, 0x00, 0xb7, 0x61, 0x48, 0x55, 0x8e, 0x64, 0x57, 0xce, 0x04, 0x04, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x81, 0xdb, 0x2d, 0x6b, 0x76, 0x12, 0x20, 0x0c, 0x24,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x62, 0x67, 0xf7, 0xfd, 0xad, 0x46, 0x7c, 0x0c,
			0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa3, 0x04, 0x8e, 0x0d, 0xf1, 0xd8, 0xf8, 0xd8,
			0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9a, 0xf7, 0xd0, 0xa5, 0x9b, 0x32, 0x58,
			0xe9, 0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0xc1, 0x04, 0xca, 0xf1, 0xc9,
			0x2e, 0x05, 0x0c, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0xb7, 0x36, 0x6c, 0xc3,
			0x45, 0xe7, 0xc4, 0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91, 0x98, 0xfa, 0x34,
			0x93, 0xd9, 0x55, 0x48, 0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0x0c, 0x2c,
			0x54, 0xfc, 0x4b, 0x63, 0x05, 0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x2e,
			0xa7, 0x72, 0x1e, 0xe3, 0x86, 0xe9, 0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57,
			0x3d, 0xd0, 0x97, 0x6d, 0x22, 0x1d, 0x9c, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0xeb, 0x23, 0x9c, 0xa5, 0xc3, 0x35, 0xc5, 0xb5, 0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0xe8, 0x80, 0xa6, 0xf3, 0xb6, 0x1f, 0x9f, 0x24, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00,
		},
	},
}
View Source
var HostViewFixedLayout = []byte{}/* 514 elements not displayed */
View Source
var HostViewFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(HostViewFixedLineagePlans))
	for i := range HostViewFixedLineagePlans {
		lane := &HostViewFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(HostViewFixedResetImage)))
		}
	}
	return out
}()
View Source
var HostViewFixedLineagePlans = tableFixedLineagePlans(HostViewFixedKnown, HostViewFixedLayout, HostViewFixedDst, HostViewFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var HostViewFixedPlan = tableFixedBuildPlan(HostViewFixedLeaves, 21)
View Source
var HostViewFixedPlanMax = func() int32 {
	m := HostViewFixedPlan.Count
	for _, lane := range HostViewFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

HostViewFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var HostViewFixedResetImage = func() []byte {
	var def HostView
	HostViewReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var HostViewTableFields = []TableFieldInfo{
	{Name: "ansible_host", Json: "ansible_host", TypeName: "string", DeclaredTypeName: "string", Id: 0xb1c8aea63f05c6a6, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(HostView{}.AnsibleHost)), ElemSize: uint32(unsafe.Sizeof(HostView{}.AnsibleHost)), CountOffset: uint32(unsafe.Offsetof(HostView{}.AnsibleHostLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 132, 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: "kind", Json: "kind", TypeName: "ConfigKind", DeclaredTypeName: "ConfigKind", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.Kind)), ElemSize: uint32(unsafe.Sizeof(HostView{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 136, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameConfigKind(ConfigKind(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := ConfigKind(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "slots", Json: "slots", TypeName: "int32", DeclaredTypeName: "int32", Id: 0xe68c2e6bb1ee5646, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.Slots)), ElemSize: uint32(unsafe.Sizeof(HostView{}.Slots)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 140, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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: "slots_capacity", Json: "slots_capacity", TypeName: "int32", DeclaredTypeName: "int32", Id: 0x20f324b35a35e44f, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.SlotsCapacity)), ElemSize: uint32(unsafe.Sizeof(HostView{}.SlotsCapacity)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 144, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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: "runners", Json: "runners", TypeName: "int32", DeclaredTypeName: "int32", Id: 0x83f33fb50ef47638, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.Runners)), ElemSize: uint32(unsafe.Sizeof(HostView{}.Runners)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 148, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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: "slots_share", Json: "slots_share", TypeName: "int32", DeclaredTypeName: "int32", Id: 0x2fe64655e6b18812, Kind: 4, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.SlotsShare)), ElemSize: uint32(unsafe.Sizeof(HostView{}.SlotsShare)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(HostView{}.SlotsSharePresent)),
		CookOffset: 152, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 156,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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: "cores", Json: "cores", TypeName: "int32", DeclaredTypeName: "int32", Id: 0xce57648e554861b7, Kind: 4, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.Cores)), ElemSize: uint32(unsafe.Sizeof(HostView{}.Cores)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(HostView{}.CoresPresent)),
		CookOffset: 160, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 164,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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: "bench_os", Json: "bench_os", TypeName: "string", DeclaredTypeName: "string", Id: 0x2012766b2ddb813c, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(HostView{}.BenchOs)), ElemSize: uint32(unsafe.Sizeof(HostView{}.BenchOs)), CountOffset: uint32(unsafe.Offsetof(HostView{}.BenchOsLength)), PresentOffset: 0xffffffff,
		CookOffset: 165, CookElemSize: 1, CookCountOffset: 200, 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: "nova_arch", Json: "nova_arch", TypeName: "string", DeclaredTypeName: "string", Id: 0x7c46adfdf7676288, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(HostView{}.NovaArch)), ElemSize: uint32(unsafe.Sizeof(HostView{}.NovaArch)), CountOffset: uint32(unsafe.Offsetof(HostView{}.NovaArchLength)), PresentOffset: 0xffffffff,
		CookOffset: 204, CookElemSize: 1, CookCountOffset: 240, 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: "nova_tla", Json: "nova_tla", TypeName: "bool", DeclaredTypeName: "bool", Id: 0xd8f8d8f10d8e04a3, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.NovaTla)), ElemSize: uint32(unsafe.Sizeof(HostView{}.NovaTla)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 244, 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: "registry_seat", Json: "registry_seat", TypeName: "string", DeclaredTypeName: "string", Id: 0xe958329ba5d0f79a, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(HostView{}.RegistrySeat)), ElemSize: uint32(unsafe.Sizeof(HostView{}.RegistrySeat)), CountOffset: uint32(unsafe.Offsetof(HostView{}.RegistrySeatLength)), PresentOffset: 0xffffffff,
		CookOffset: 245, CookElemSize: 1, CookCountOffset: 2552, 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: "registry_roles", Json: "registry_roles", TypeName: "string", DeclaredTypeName: "string", Id: 0x52ec9f1ca04c1bc, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 64, Offset: uint32(unsafe.Offsetof(HostView{}.RegistryRoles)), ElemSize: uint32(unsafe.Sizeof(HostView{}.RegistryRoles)), CountOffset: uint32(unsafe.Offsetof(HostView{}.RegistryRolesLength)), PresentOffset: 0xffffffff,
		CookOffset: 2556, CookElemSize: 1, CookCountOffset: 2624, 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: "ansible_user", Json: "ansible_user", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4e745c36c36b777, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(HostView{}.AnsibleUser)), ElemSize: uint32(unsafe.Sizeof(HostView{}.AnsibleUser)), CountOffset: uint32(unsafe.Offsetof(HostView{}.AnsibleUserLength)), PresentOffset: 0xffffffff,
		CookOffset: 2628, CookElemSize: 1, CookCountOffset: 4936, 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: "nova_seat", Json: "nova_seat", TypeName: "string", DeclaredTypeName: "string", Id: 0x4855d99334fa9891, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(HostView{}.NovaSeat)), ElemSize: uint32(unsafe.Sizeof(HostView{}.NovaSeat)), CountOffset: uint32(unsafe.Offsetof(HostView{}.NovaSeatLength)), PresentOffset: 0xffffffff,
		CookOffset: 4940, CookElemSize: 1, CookCountOffset: 7248, 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: "nova_redis_addr", Json: "nova_redis_addr", TypeName: "string", DeclaredTypeName: "string", Id: 0x5634bfc542c0cef, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(HostView{}.NovaRedisAddr)), ElemSize: uint32(unsafe.Sizeof(HostView{}.NovaRedisAddr)), CountOffset: uint32(unsafe.Offsetof(HostView{}.NovaRedisAddrLength)), PresentOffset: 0xffffffff,
		CookOffset: 7252, CookElemSize: 1, CookCountOffset: 9560, 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: "nova_bus_addr", Json: "nova_bus_addr", TypeName: "string", DeclaredTypeName: "string", Id: 0xe986e31e72a72e3c, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(HostView{}.NovaBusAddr)), ElemSize: uint32(unsafe.Sizeof(HostView{}.NovaBusAddr)), CountOffset: uint32(unsafe.Offsetof(HostView{}.NovaBusAddrLength)), PresentOffset: 0xffffffff,
		CookOffset: 9564, CookElemSize: 1, CookCountOffset: 11872, 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: "nova_redis_port", Json: "nova_redis_port", TypeName: "int32", DeclaredTypeName: "int32", Id: 0x9c1d226d97d03d57, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.NovaRedisPort)), ElemSize: uint32(unsafe.Sizeof(HostView{}.NovaRedisPort)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 11876, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 65535.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: "nova_pg_dsn", Json: "nova_pg_dsn", TypeName: "string", DeclaredTypeName: "string", Id: 0xb5c535c3a59c23eb, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(HostView{}.NovaPgDsn)), ElemSize: uint32(unsafe.Sizeof(HostView{}.NovaPgDsn)), CountOffset: uint32(unsafe.Offsetof(HostView{}.NovaPgDsnLength)), PresentOffset: 0xffffffff,
		CookOffset: 11880, CookElemSize: 1, CookCountOffset: 14188, 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: "local", Json: "local", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x249f1fb6f3a680e8, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(HostView{}.Local)), ElemSize: uint32(unsafe.Sizeof(HostView{}.Local)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 14192, 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},
}

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

View Source
var InventoryFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(Inventory{}.All)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.Adopt)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.Benches)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.Coordinator)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.Store)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.StoreDeployer)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.Runners)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.Tla)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostGroup{}.Hosts)), uint32(unsafe.Sizeof(HostName{})), uint32(unsafe.Offsetof(HostGroup{}.HostsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(HostName{}.NameLength)), 0, uint32(unsafe.Offsetof(HostName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.NovaStoreLength)), 0, uint32(unsafe.Offsetof(Inventory{}.NovaStore)), 0, 1, 1},
	{uint32(unsafe.Offsetof(Inventory{}.Revs)), uint32(unsafe.Sizeof(KindRev{})), uint32(unsafe.Offsetof(Inventory{}.RevsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(KindRev{}.Kind)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(KindRev{}.Rev)), 0, 0, 0, 0, 0},
}
View Source
var InventoryFixedHoles = tableFixedHoles(InventoryFixedPlan.Entries, InventoryFixedPlan.Count, uint32(len(InventoryFixedResetImage)))
View Source
var InventoryFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x5c098637ac4585c0,
		LayoutBytes: 786,
		Record:      53112,
		Layout: []byte{
			0x2e, 0x00, 0x00, 0x00, 0x3f, 0x0f, 0x0e, 0x8a, 0xeb, 0x05, 0x0d, 0x1f, 0x0d, 0x70, 0xcf, 0x00,
			0x00, 0x0a, 0x00, 0x00, 0x00, 0xa4, 0xda, 0x19, 0x05, 0x19, 0x9b, 0xf0, 0xe6, 0x0d, 0xc4, 0x18,
			0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x06, 0xe0, 0x43, 0x7b, 0xdf, 0x28, 0x3b, 0x0e, 0xc4,
			0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
			0x84, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4,
			0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x76, 0xa6, 0xe4, 0xfd, 0x35, 0xe2,
			0xf7, 0x0d, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x06, 0xe0, 0x43, 0x7b, 0xdf,
			0x28, 0x3b, 0x0e, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x0d, 0x84, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e,
			0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0xfb, 0x39,
			0xfe, 0xd9, 0xfc, 0x23, 0x66, 0x0d, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x06,
			0xe0, 0x43, 0x7b, 0xdf, 0x28, 0x3b, 0x0e, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x84, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
			0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0xf1, 0x13, 0x41, 0x97, 0x8d, 0x03, 0xcd, 0x20, 0x0d, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00,
			0x00, 0x00, 0x94, 0x06, 0xe0, 0x43, 0x7b, 0xdf, 0x28, 0x3b, 0x0e, 0xc4, 0x18, 0x00, 0x00, 0x01,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x84, 0x00, 0x00, 0x00,
			0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x8e, 0xbd, 0xb0, 0x76, 0xad, 0x54, 0xee, 0x44, 0x0d, 0xc4, 0x18,
			0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x06, 0xe0, 0x43, 0x7b, 0xdf, 0x28, 0x3b, 0x0e, 0xc4,
			0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
			0x84, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4,
			0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x3c, 0xcc, 0x03, 0xca, 0x6c, 0x15,
			0xbd, 0x0d, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x06, 0xe0, 0x43, 0x7b, 0xdf,
			0x28, 0x3b, 0x0e, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x0d, 0x84, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e,
			0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x76, 0xf4,
			0x0e, 0xb5, 0x3f, 0xf3, 0x83, 0x0d, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x94, 0x06,
			0xe0, 0x43, 0x7b, 0xdf, 0x28, 0x3b, 0x0e, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x84, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
			0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0xd4, 0x34, 0x6e, 0x44, 0x19, 0xdd, 0x03, 0x57, 0x0d, 0xc4, 0x18, 0x00, 0x00, 0x01, 0x00,
			0x00, 0x00, 0x94, 0x06, 0xe0, 0x43, 0x7b, 0xdf, 0x28, 0x3b, 0x0e, 0xc4, 0x18, 0x00, 0x00, 0x01,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x84, 0x00, 0x00, 0x00,
			0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x86, 0x73, 0xf9, 0xb1, 0xb3, 0x91, 0xae, 0x0c, 0x04, 0x09,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x16, 0xbd, 0xbf, 0x1f, 0x5c, 0xc0, 0x4c, 0x0e, 0x4c,
			0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
			0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x43, 0x32, 0x67, 0x21, 0xd7, 0x96, 0x9c, 0xef,
			0x1e, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xce, 0x46, 0xc6, 0x6b, 0x87, 0x22, 0xd6,
			0x5d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x79, 0xa2, 0xfb, 0x0a, 0xe0,
			0x53, 0x0a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x7e, 0x8a, 0x1b, 0x66,
			0xa2, 0x57, 0x9f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x16, 0x61, 0xb2,
			0x24, 0x5f, 0xb6, 0xf3, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x93, 0x45,
			0x8a, 0xb4, 0xe5, 0xfe, 0x4e, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0x7c,
			0x4d, 0xd1, 0xb3, 0x69, 0x58, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e,
			0x6a, 0x4d, 0x26, 0xa8, 0xe2, 0x06, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x69, 0xcd, 0x26, 0x30, 0xfb, 0x85, 0xfd, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x52, 0xaa, 0xf4, 0x60, 0x19, 0xb0, 0xe9, 0x89, 0x05, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00,
		},
	},
}
View Source
var InventoryFixedLayout = []byte{}/* 786 elements not displayed */
View Source
var InventoryFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(InventoryFixedLineagePlans))
	for i := range InventoryFixedLineagePlans {
		lane := &InventoryFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(InventoryFixedResetImage)))
		}
	}
	return out
}()
View Source
var InventoryFixedLineagePlans = tableFixedLineagePlans(InventoryFixedKnown, InventoryFixedLayout, InventoryFixedDst, InventoryFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var InventoryFixedPlan = tableFixedBuildPlan(InventoryFixedLeaves, 410)
View Source
var InventoryFixedPlanMax = func() int32 {
	m := InventoryFixedPlan.Count
	for _, lane := range InventoryFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

InventoryFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var InventoryFixedResetImage = func() []byte {
	var def Inventory
	InventoryReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var InventoryLoopFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(InventoryLoop{}.MachineLength)), 0, uint32(unsafe.Offsetof(InventoryLoop{}.Machine)), 0, 1, 1},
	{uint32(unsafe.Offsetof(InventoryLoop{}.NameLength)), 0, uint32(unsafe.Offsetof(InventoryLoop{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(InventoryLoop{}.ArgvLength)), 0, uint32(unsafe.Offsetof(InventoryLoop{}.Argv)), 0, 1, 1},
	{uint32(unsafe.Offsetof(InventoryLoop{}.SeatLength)), 0, uint32(unsafe.Offsetof(InventoryLoop{}.Seat)), 0, 1, 1},
	{uint32(unsafe.Offsetof(InventoryLoop{}.Keys)), uint32(unsafe.Sizeof(EnvName{})), uint32(unsafe.Offsetof(InventoryLoop{}.KeysCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(EnvName{}.NameLength)), 0, uint32(unsafe.Offsetof(EnvName{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(InventoryLoop{}.Every)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(InventoryLoop{}.Keepalive)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(InventoryLoop{}.Enabled)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(InventoryLoop{}.LogLength)), 0, uint32(unsafe.Offsetof(InventoryLoop{}.Log)), 0, 1, 1},
}
View Source
var InventoryLoopFixedHoles = tableFixedHoles(InventoryLoopFixedPlan.Entries, InventoryLoopFixedPlan.Count, uint32(len(InventoryLoopFixedResetImage)))
View Source
var InventoryLoopFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x277405565f5378f6,
		LayoutBytes: 208,
		Record:      13222,
		Layout: []byte{
			0x0c, 0x00, 0x00, 0x00, 0x35, 0x9e, 0xe3, 0x74, 0x7b, 0x62, 0x05, 0x6e, 0x0d, 0x9e, 0x33, 0x00,
			0x00, 0x09, 0x00, 0x00, 0x00, 0x6e, 0xbe, 0xd7, 0x98, 0xcb, 0x57, 0x51, 0x38, 0x0c, 0x84, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x98, 0xbc, 0x3e, 0x84, 0x2d, 0x49, 0x89, 0x0c,
			0x04, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x33, 0xf9, 0xd3, 0x18, 0xf1, 0x08, 0x2d,
			0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x3e, 0xbd, 0x5c, 0xd7, 0x87, 0x19,
			0x58, 0x0e, 0x84, 0x10, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x0d, 0x84, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba,
			0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0xc9, 0xd1, 0x79,
			0x00, 0x97, 0x53, 0x11, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa9, 0xf3, 0xa6,
			0xfd, 0xcd, 0x8b, 0xfa, 0x38, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9e, 0x28,
			0x56, 0x6b, 0x80, 0x85, 0xd8, 0x70, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31,
			0x54, 0xaf, 0x1d, 0x19, 0x73, 0x50, 0x12, 0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var InventoryLoopFixedLayout = []byte{}/* 208 elements not displayed */
View Source
var InventoryLoopFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(InventoryLoopFixedLineagePlans))
	for i := range InventoryLoopFixedLineagePlans {
		lane := &InventoryLoopFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(InventoryLoopFixedResetImage)))
		}
	}
	return out
}()
View Source
var InventoryLoopFixedLineagePlans = tableFixedLineagePlans(InventoryLoopFixedKnown, InventoryLoopFixedLayout, InventoryLoopFixedDst, InventoryLoopFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var InventoryLoopFixedPlan = tableFixedBuildPlan(InventoryLoopFixedLeaves, 41)
View Source
var InventoryLoopFixedPlanMax = func() int32 {
	m := InventoryLoopFixedPlan.Count
	for _, lane := range InventoryLoopFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

InventoryLoopFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var InventoryLoopFixedResetImage = func() []byte {
	var def InventoryLoop
	InventoryLoopReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var InventoryLoopTableFields = []TableFieldInfo{
	{Name: "machine", Json: "machine", TypeName: "string", DeclaredTypeName: "string", Id: 0x385157cb98d7be6e, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Machine)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Machine)), CountOffset: uint32(unsafe.Offsetof(InventoryLoop{}.MachineLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 132, 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: "name", Json: "name", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4bcadba8e631b86, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Name)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Name)), CountOffset: uint32(unsafe.Offsetof(InventoryLoop{}.NameLength)), PresentOffset: 0xffffffff,
		CookOffset: 136, CookElemSize: 1, CookCountOffset: 268, 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: "argv", Json: "argv", TypeName: "string", DeclaredTypeName: "string", Id: 0x89492d843ebc9863, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 4096, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Argv)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Argv)), CountOffset: uint32(unsafe.Offsetof(InventoryLoop{}.ArgvLength)), PresentOffset: 0xffffffff,
		CookOffset: 272, CookElemSize: 1, CookCountOffset: 4372, 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: "seat", Json: "seat", TypeName: "string", DeclaredTypeName: "string", Id: 0x2d08f118d3f933e8, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Seat)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Seat)), CountOffset: uint32(unsafe.Offsetof(InventoryLoop{}.SeatLength)), PresentOffset: 0xffffffff,
		CookOffset: 4376, CookElemSize: 1, CookCountOffset: 6684, 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: "keys", Json: "keys", TypeName: "EnvName", DeclaredTypeName: "EnvName", Id: 0x581987d75cbd3e2d, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Keys)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Keys[0])), CountOffset: uint32(unsafe.Offsetof(InventoryLoop{}.KeysCount)), PresentOffset: 0xffffffff,
		CookOffset: 6688, CookElemSize: 136, CookCountOffset: 11040, 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: EnvNameTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "every", Json: "every", TypeName: "int32", DeclaredTypeName: "int32", Id: 0x1153970079d1c964, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Every)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Every)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 11044, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 3.1536e+07, 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: "keepalive", Json: "keepalive", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x38fa8bcdfda6f3a9, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Keepalive)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Keepalive)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 11048, 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: "enabled", Json: "enabled", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x70d885806b56289e, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Enabled)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Enabled)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 11049, 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: "log", Json: "log", TypeName: "string", DeclaredTypeName: "string", Id: 0x125073191daf5431, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(InventoryLoop{}.Log)), ElemSize: uint32(unsafe.Sizeof(InventoryLoop{}.Log)), CountOffset: uint32(unsafe.Offsetof(InventoryLoop{}.LogLength)), PresentOffset: 0xffffffff,
		CookOffset: 11050, CookElemSize: 1, CookCountOffset: 13356, 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},
}

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

View Source
var InventoryTableFields = []TableFieldInfo{
	{Name: "all", Json: "all", TypeName: "HostGroup", DeclaredTypeName: "HostGroup", Id: 0xe6f09b190519daa4, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Inventory{}.All)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.All)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 6532, 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: HostGroupTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "adopt", Json: "adopt", TypeName: "HostGroup", DeclaredTypeName: "HostGroup", Id: 0xf7e235fde4a67611, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Inventory{}.Adopt)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.Adopt)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 6532, CookElemSize: 6532, 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: HostGroupTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "benches", Json: "benches", TypeName: "HostGroup", DeclaredTypeName: "HostGroup", Id: 0x6623fcd9fe39fb45, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Inventory{}.Benches)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.Benches)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 13064, CookElemSize: 6532, 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: HostGroupTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "coordinator", Json: "coordinator", TypeName: "HostGroup", DeclaredTypeName: "HostGroup", Id: 0x20cd038d974113f1, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Inventory{}.Coordinator)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.Coordinator)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 19596, CookElemSize: 6532, 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: HostGroupTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "store", Json: "store", TypeName: "HostGroup", DeclaredTypeName: "HostGroup", Id: 0x44ee54ad76b0bd8e, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Inventory{}.Store)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.Store)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 26128, CookElemSize: 6532, 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: HostGroupTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "store_deployer", Json: "store_deployer", TypeName: "HostGroup", DeclaredTypeName: "HostGroup", Id: 0xbd156cca03cc3c3f, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Inventory{}.StoreDeployer)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.StoreDeployer)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32660, CookElemSize: 6532, 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: HostGroupTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "runners", Json: "runners", TypeName: "HostGroup", DeclaredTypeName: "HostGroup", Id: 0x83f33fb50ef47638, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Inventory{}.Runners)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.Runners)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 39192, CookElemSize: 6532, 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: HostGroupTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "tla", Json: "tla", TypeName: "HostGroup", DeclaredTypeName: "HostGroup", Id: 0x5703dd19446e34d4, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Inventory{}.Tla)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.Tla)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 45724, CookElemSize: 6532, 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: HostGroupTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "nova_store", Json: "nova_store", TypeName: "string", DeclaredTypeName: "string", Id: 0xae91b3b1f9738641, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(Inventory{}.NovaStore)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.NovaStore)), CountOffset: uint32(unsafe.Offsetof(Inventory{}.NovaStoreLength)), PresentOffset: 0xffffffff,
		CookOffset: 52256, CookElemSize: 1, CookCountOffset: 54564, 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: "revs", Json: "revs", TypeName: "KindRev", DeclaredTypeName: "KindRev", Id: 0x4cc05c1fbfbd1613, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 8, Offset: uint32(unsafe.Offsetof(Inventory{}.Revs)), ElemSize: uint32(unsafe.Sizeof(Inventory{}.Revs[0])), CountOffset: uint32(unsafe.Offsetof(Inventory{}.RevsCount)), PresentOffset: 0xffffffff,
		CookOffset: 54568, CookElemSize: 16, CookCountOffset: 54696, 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: KindRevTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source
var KindRevFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(KindRev{}.Kind)), 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(KindRev{}.Rev)), 0, 0, 0, 0, 0},
}
View Source
var KindRevFixedHoles = tableFixedHoles(KindRevFixedPlan.Entries, KindRevFixedPlan.Count, uint32(len(KindRevFixedResetImage)))
View Source
var KindRevFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x75cf084800611cb4,
		LayoutBytes: 191,
		Record:      17,
		Layout: []byte{
			0x0b, 0x00, 0x00, 0x00, 0x2c, 0x9d, 0x7e, 0x40, 0x8d, 0xfc, 0x23, 0xc8, 0x0d, 0x09, 0x00, 0x00,
			0x00, 0x02, 0x00, 0x00, 0x00, 0x43, 0x32, 0x67, 0x21, 0xd7, 0x96, 0x9c, 0xef, 0x1e, 0x01, 0x00,
			0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xce, 0x46, 0xc6, 0x6b, 0x87, 0x22, 0xd6, 0x5d, 0x20, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x79, 0xa2, 0xfb, 0x0a, 0xe0, 0x53, 0x0a, 0x20,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x7e, 0x8a, 0x1b, 0x66, 0xa2, 0x57, 0x9f,
			0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x16, 0x61, 0xb2, 0x24, 0x5f, 0xb6,
			0xf3, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x93, 0x45, 0x8a, 0xb4, 0xe5,
			0xfe, 0x4e, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0x7c, 0x4d, 0xd1, 0xb3,
			0x69, 0x58, 0x7f, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x6a, 0x4d, 0x26,
			0xa8, 0xe2, 0x06, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0xcd, 0x26,
			0x30, 0xfb, 0x85, 0xfd, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xaa,
			0xf4, 0x60, 0x19, 0xb0, 0xe9, 0x89, 0x05, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var KindRevFixedLayout = []byte{}/* 191 elements not displayed */
View Source
var KindRevFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(KindRevFixedLineagePlans))
	for i := range KindRevFixedLineagePlans {
		lane := &KindRevFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(KindRevFixedResetImage)))
		}
	}
	return out
}()
View Source
var KindRevFixedLineagePlans = tableFixedLineagePlans(KindRevFixedKnown, KindRevFixedLayout, KindRevFixedDst, KindRevFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var KindRevFixedPlan = tableFixedBuildPlan(KindRevFixedLeaves, 2)
View Source
var KindRevFixedPlanMax = func() int32 {
	m := KindRevFixedPlan.Count
	for _, lane := range KindRevFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

KindRevFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var KindRevFixedResetImage = func() []byte {
	var def KindRev
	KindRevReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var KindRevTableFields = []TableFieldInfo{
	{Name: "kind", Json: "kind", TypeName: "ConfigKind", DeclaredTypeName: "ConfigKind", Id: 0xef9c96d721673243, Kind: 30, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(KindRev{}.Kind)), ElemSize: uint32(unsafe.Sizeof(KindRev{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    func(v uint64) string { return EnumNameConfigKind(ConfigKind(v)) },
		VariantId:   func(v uint64) uint64 { id, _ := ConfigKind(v).TableEnumId(); return id },
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "rev", Json: "rev", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x89e9b01960f4aa52, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(KindRev{}.Rev)), ElemSize: uint32(unsafe.Sizeof(KindRev{}.Rev)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 9.007199254740991e+15, 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},
}

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

View Source
var MachineBeatFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(MachineBeat{}.OsLength)), 0, uint32(unsafe.Offsetof(MachineBeat{}.Os)), 0, 1, 1},
	{uint32(unsafe.Offsetof(MachineBeat{}.ArchLength)), 0, uint32(unsafe.Offsetof(MachineBeat{}.Arch)), 0, 1, 1},
	{uint32(unsafe.Offsetof(MachineBeat{}.CoresLength)), 0, uint32(unsafe.Offsetof(MachineBeat{}.Cores)), 0, 1, 1},
	{uint32(unsafe.Offsetof(MachineBeat{}.MemoryGbLength)), 0, uint32(unsafe.Offsetof(MachineBeat{}.MemoryGb)), 0, 1, 1},
	{uint32(unsafe.Offsetof(MachineBeat{}.AtLength)), 0, uint32(unsafe.Offsetof(MachineBeat{}.At)), 0, 1, 1},
}
View Source
var MachineBeatFixedHoles = tableFixedHoles(MachineBeatFixedPlan.Entries, MachineBeatFixedPlan.Count, uint32(len(MachineBeatFixedResetImage)))
View Source
var MachineBeatFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x11a1afff1ee664ab,
		LayoutBytes: 106,
		Record:      148,
		Layout: []byte{
			0x06, 0x00, 0x00, 0x00, 0xc6, 0x72, 0xba, 0x64, 0xf7, 0xc6, 0x11, 0x21, 0x0d, 0x8c, 0x00, 0x00,
			0x00, 0x05, 0x00, 0x00, 0x00, 0x57, 0x5e, 0x56, 0xb5, 0x07, 0x55, 0xb0, 0x08, 0x0c, 0x24, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0x33, 0xb2, 0x3e, 0x84, 0x43, 0x3c, 0x89, 0x0c, 0x24,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7, 0x61, 0x48, 0x55, 0x8e, 0x64, 0x57, 0xce, 0x0c,
			0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x31, 0x9a, 0x05, 0x2e, 0xc4, 0x07, 0xb8,
			0x0c, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xa9, 0x45, 0xb5, 0x07, 0x4e, 0x9c,
			0x08, 0x0c, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var MachineBeatFixedLayout = []byte{}/* 106 elements not displayed */
View Source
var MachineBeatFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(MachineBeatFixedLineagePlans))
	for i := range MachineBeatFixedLineagePlans {
		lane := &MachineBeatFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(MachineBeatFixedResetImage)))
		}
	}
	return out
}()
View Source
var MachineBeatFixedLineagePlans = tableFixedLineagePlans(MachineBeatFixedKnown, MachineBeatFixedLayout, MachineBeatFixedDst, MachineBeatFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var MachineBeatFixedPlan = tableFixedBuildPlan(MachineBeatFixedLeaves, 5)
View Source
var MachineBeatFixedPlanMax = func() int32 {
	m := MachineBeatFixedPlan.Count
	for _, lane := range MachineBeatFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

MachineBeatFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var MachineBeatFixedResetImage = func() []byte {
	var def MachineBeat
	MachineBeatReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var MachineBeatTableFields = []TableFieldInfo{
	{Name: "os", Json: "os", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b05507b5565e57, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(MachineBeat{}.Os)), ElemSize: uint32(unsafe.Sizeof(MachineBeat{}.Os)), CountOffset: uint32(unsafe.Offsetof(MachineBeat{}.OsLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 36, 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: "arch", Json: "arch", TypeName: "string", DeclaredTypeName: "string", Id: 0x893c43843eb23369, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(MachineBeat{}.Arch)), ElemSize: uint32(unsafe.Sizeof(MachineBeat{}.Arch)), CountOffset: uint32(unsafe.Offsetof(MachineBeat{}.ArchLength)), PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 1, CookCountOffset: 76, 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: "cores", Json: "cores", TypeName: "string", DeclaredTypeName: "string", Id: 0xce57648e554861b7, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 8, Offset: uint32(unsafe.Offsetof(MachineBeat{}.Cores)), ElemSize: uint32(unsafe.Sizeof(MachineBeat{}.Cores)), CountOffset: uint32(unsafe.Offsetof(MachineBeat{}.CoresLength)), PresentOffset: 0xffffffff,
		CookOffset: 80, CookElemSize: 1, CookCountOffset: 92, 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: "memory_gb", Json: "memory_gb", TypeName: "string", DeclaredTypeName: "string", Id: 0xb807c42e059a310a, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 16, Offset: uint32(unsafe.Offsetof(MachineBeat{}.MemoryGb)), ElemSize: uint32(unsafe.Sizeof(MachineBeat{}.MemoryGb)), CountOffset: uint32(unsafe.Offsetof(MachineBeat{}.MemoryGbLength)), PresentOffset: 0xffffffff,
		CookOffset: 96, CookElemSize: 1, CookCountOffset: 116, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "at", Json: "at", TypeName: "string", DeclaredTypeName: "string", Id: 0x89c4e07b545a968, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 32, Offset: uint32(unsafe.Offsetof(MachineBeat{}.At)), ElemSize: uint32(unsafe.Sizeof(MachineBeat{}.At)), CountOffset: uint32(unsafe.Offsetof(MachineBeat{}.AtLength)), PresentOffset: 0xffffffff,
		CookOffset: 120, CookElemSize: 1, CookCountOffset: 156, 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},
}

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

View Source
var MachineViewFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(MachineView{}.NameLength)), 0, uint32(unsafe.Offsetof(MachineView{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(MachineView{}.UserLength)), 0, uint32(unsafe.Offsetof(MachineView{}.User)), 0, 1, 1},
	{uint32(unsafe.Offsetof(MachineView{}.SeatLength)), 0, uint32(unsafe.Offsetof(MachineView{}.Seat)), 0, 1, 1},
	{uint32(unsafe.Offsetof(MachineView{}.Slots)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(MachineView{}.Runners)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(MachineView{}.RolesLength)), 0, uint32(unsafe.Offsetof(MachineView{}.Roles)), 0, 1, 1},
	{uint32(unsafe.Offsetof(MachineView{}.Tla)), 0, 0, 0, 0, 0},
	{0, 0, uint32(unsafe.Offsetof(MachineView{}.WidthPresent)), 0, 0, 0},
	{uint32(unsafe.Offsetof(MachineView{}.Width)), 0, 0, 0, 0, 0},
}
View Source
var MachineViewFixedHoles = tableFixedHoles(MachineViewFixedPlan.Entries, MachineViewFixedPlan.Count, uint32(len(MachineViewFixedResetImage)))
View Source
var MachineViewFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x85ddbb56a7ea3eaf,
		LayoutBytes: 174,
		Record:      4838,
		Layout: []byte{
			0x0a, 0x00, 0x00, 0x00, 0x4f, 0x6c, 0x64, 0x96, 0x5c, 0x6a, 0x72, 0xa9, 0x0d, 0xde, 0x12, 0x00,
			0x00, 0x08, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c, 0x84, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf2, 0x48, 0x2b, 0x03, 0xe4, 0x80, 0x67, 0x7d, 0x0c, 0x04,
			0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x33, 0xf9, 0xd3, 0x18, 0xf1, 0x08, 0x2d, 0x0c,
			0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x56, 0xee, 0xb1, 0x6b, 0x2e, 0x8c, 0xe6,
			0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x76, 0xf4, 0x0e, 0xb5, 0x3f, 0xf3,
			0x83, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x30, 0x24, 0x46, 0x04,
			0x4d, 0x58, 0x0c, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd4, 0x34, 0x6e, 0x44, 0x19,
			0xdd, 0x03, 0x57, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xe9, 0xd1, 0x2f,
			0x93, 0xcd, 0xda, 0xdb, 0x23, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xbf, 0xe9, 0xd1,
			0x2f, 0x93, 0xcd, 0xda, 0xdb, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var MachineViewFixedLayout = []byte{}/* 174 elements not displayed */
View Source
var MachineViewFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(MachineViewFixedLineagePlans))
	for i := range MachineViewFixedLineagePlans {
		lane := &MachineViewFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(MachineViewFixedResetImage)))
		}
	}
	return out
}()
View Source
var MachineViewFixedLineagePlans = tableFixedLineagePlans(MachineViewFixedKnown, MachineViewFixedLayout, MachineViewFixedDst, MachineViewFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var MachineViewFixedPlan = tableFixedBuildPlan(MachineViewFixedLeaves, 9)
View Source
var MachineViewFixedPlanMax = func() int32 {
	m := MachineViewFixedPlan.Count
	for _, lane := range MachineViewFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

MachineViewFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var MachineViewFixedResetImage = func() []byte {
	var def MachineView
	MachineViewReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var MachineViewTableFields = []TableFieldInfo{
	{Name: "name", Json: "name", TypeName: "string", DeclaredTypeName: "string", Id: 0xc4bcadba8e631b86, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(MachineView{}.Name)), ElemSize: uint32(unsafe.Sizeof(MachineView{}.Name)), CountOffset: uint32(unsafe.Offsetof(MachineView{}.NameLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 132, 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: "user", Json: "user", TypeName: "string", DeclaredTypeName: "string", Id: 0x7d6780e4032b48f2, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(MachineView{}.User)), ElemSize: uint32(unsafe.Sizeof(MachineView{}.User)), CountOffset: uint32(unsafe.Offsetof(MachineView{}.UserLength)), PresentOffset: 0xffffffff,
		CookOffset: 136, CookElemSize: 1, CookCountOffset: 2444, 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: "seat", Json: "seat", TypeName: "string", DeclaredTypeName: "string", Id: 0x2d08f118d3f933e8, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 2304, Offset: uint32(unsafe.Offsetof(MachineView{}.Seat)), ElemSize: uint32(unsafe.Sizeof(MachineView{}.Seat)), CountOffset: uint32(unsafe.Offsetof(MachineView{}.SeatLength)), PresentOffset: 0xffffffff,
		CookOffset: 2448, CookElemSize: 1, CookCountOffset: 4756, 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: "slots", Json: "slots", TypeName: "int32", DeclaredTypeName: "int32", Id: 0xe68c2e6bb1ee5646, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(MachineView{}.Slots)), ElemSize: uint32(unsafe.Sizeof(MachineView{}.Slots)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 4760, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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: "runners", Json: "runners", TypeName: "int32", DeclaredTypeName: "int32", Id: 0x83f33fb50ef47638, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(MachineView{}.Runners)), ElemSize: uint32(unsafe.Sizeof(MachineView{}.Runners)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 4764, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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: "roles", Json: "roles", TypeName: "string", DeclaredTypeName: "string", Id: 0x584d04462430003e, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 64, Offset: uint32(unsafe.Offsetof(MachineView{}.Roles)), ElemSize: uint32(unsafe.Sizeof(MachineView{}.Roles)), CountOffset: uint32(unsafe.Offsetof(MachineView{}.RolesLength)), PresentOffset: 0xffffffff,
		CookOffset: 4768, CookElemSize: 1, CookCountOffset: 4836, 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: "tla", Json: "tla", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x5703dd19446e34d4, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(MachineView{}.Tla)), ElemSize: uint32(unsafe.Sizeof(MachineView{}.Tla)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 4840, 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: "width", Json: "width", TypeName: "int32", DeclaredTypeName: "int32", Id: 0xdbdacd932fd1e9bf, Kind: 4, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(MachineView{}.Width)), ElemSize: uint32(unsafe.Sizeof(MachineView{}.Width)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(MachineView{}.WidthPresent)),
		CookOffset: 4844, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4848,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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},
}

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

View Source
var MemberBeatFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(MemberBeat{}.AtMs)), 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(MemberBeat{}.Cores)), 0, 0, 0, 0, 0},
}
View Source
var MemberBeatFixedHoles = tableFixedHoles(MemberBeatFixedPlan.Entries, MemberBeatFixedPlan.Count, uint32(len(MemberBeatFixedResetImage)))
View Source
var MemberBeatFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x6f474342f125f54e,
		LayoutBytes: 55,
		Record:      20,
		Layout: []byte{
			0x03, 0x00, 0x00, 0x00, 0x17, 0xbb, 0xb0, 0x0a, 0xf3, 0x77, 0x3c, 0xa2, 0x0d, 0x0c, 0x00, 0x00,
			0x00, 0x02, 0x00, 0x00, 0x00, 0xc1, 0xfd, 0x00, 0xbf, 0x81, 0xbf, 0xfd, 0x41, 0x05, 0x08, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7, 0x61, 0x48, 0x55, 0x8e, 0x64, 0x57, 0xce, 0x04, 0x04,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var MemberBeatFixedLayout = []byte{
	0x03, 0x00, 0x00, 0x00, 0x17, 0xbb, 0xb0, 0x0a, 0xf3, 0x77, 0x3c, 0xa2, 0x0d, 0x0c, 0x00, 0x00,
	0x00, 0x02, 0x00, 0x00, 0x00, 0xc1, 0xfd, 0x00, 0xbf, 0x81, 0xbf, 0xfd, 0x41, 0x05, 0x08, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7, 0x61, 0x48, 0x55, 0x8e, 0x64, 0x57, 0xce, 0x04, 0x04,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
View Source
var MemberBeatFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(MemberBeatFixedLineagePlans))
	for i := range MemberBeatFixedLineagePlans {
		lane := &MemberBeatFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(MemberBeatFixedResetImage)))
		}
	}
	return out
}()
View Source
var MemberBeatFixedLineagePlans = tableFixedLineagePlans(MemberBeatFixedKnown, MemberBeatFixedLayout, MemberBeatFixedDst, MemberBeatFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var MemberBeatFixedPlan = tableFixedBuildPlan(MemberBeatFixedLeaves, 2)
View Source
var MemberBeatFixedPlanMax = func() int32 {
	m := MemberBeatFixedPlan.Count
	for _, lane := range MemberBeatFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

MemberBeatFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var MemberBeatFixedResetImage = func() []byte {
	var def MemberBeat
	MemberBeatReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var MemberBeatTableFields = []TableFieldInfo{
	{Name: "at_ms", Json: "at_ms", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x41fdbf81bf00fdc1, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(MemberBeat{}.AtMs)), ElemSize: uint32(unsafe.Sizeof(MemberBeat{}.AtMs)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 2.53402300799999e+14, 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: "cores", Json: "cores", TypeName: "int32", DeclaredTypeName: "int32", Id: 0xce57648e554861b7, Kind: 4, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(MemberBeat{}.Cores)), ElemSize: uint32(unsafe.Sizeof(MemberBeat{}.Cores)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 4, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: true, RangeMin: 0.0, RangeMax: 100000.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},
}

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

View Source
var RowFieldsFixedDst = []TableFixedDst{
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(RowFields{}.Pairs)), uint32(unsafe.Sizeof(FieldPair{})), uint32(unsafe.Offsetof(RowFields{}.PairsCount)), 1, 0, 0},
	{0, 0, 0, 0, 0, 0},
	{uint32(unsafe.Offsetof(FieldPair{}.NameLength)), 0, uint32(unsafe.Offsetof(FieldPair{}.Name)), 0, 1, 1},
	{uint32(unsafe.Offsetof(FieldPair{}.ValueLength)), 0, uint32(unsafe.Offsetof(FieldPair{}.Value)), 0, 1, 1},
	{uint32(unsafe.Offsetof(RowFields{}.ArgvLength)), 0, uint32(unsafe.Offsetof(RowFields{}.Argv)), 0, 1, 1},
}
View Source
var RowFieldsFixedHoles = tableFixedHoles(RowFieldsFixedPlan.Entries, RowFieldsFixedPlan.Count, uint32(len(RowFieldsFixedResetImage)))
View Source
var RowFieldsFixedKnown = []TableFixedKnownLayout{
	{
		Hash:        0x8b0bf6aaa436a802,
		LayoutBytes: 106,
		Record:      60368,
		Layout: []byte{
			0x06, 0x00, 0x00, 0x00, 0x82, 0x54, 0x73, 0x3e, 0x04, 0x75, 0xfe, 0x8c, 0x0d, 0xc8, 0xeb, 0x00,
			0x00, 0x02, 0x00, 0x00, 0x00, 0x26, 0x1e, 0x1e, 0x39, 0xa7, 0x38, 0x44, 0x54, 0x0e, 0xc4, 0xdb,
			0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x28,
			0x09, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x86, 0x1b, 0x63, 0x8e, 0xba, 0xad, 0xbc, 0xc4, 0x0c,
			0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x0c, 0xe8, 0x30, 0x94, 0xfd, 0xe4, 0x7c,
			0x0c, 0x04, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x98, 0xbc, 0x3e, 0x84, 0x2d, 0x49,
			0x89, 0x0c, 0x04, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
}
View Source
var RowFieldsFixedLayout = []byte{}/* 106 elements not displayed */
View Source
var RowFieldsFixedLineageHoles = func() [][]tableFixedHole {
	out := make([][]tableFixedHole, len(RowFieldsFixedLineagePlans))
	for i := range RowFieldsFixedLineagePlans {
		lane := &RowFieldsFixedLineagePlans[i]
		if lane.Why == "" {
			out[i] = tableFixedHoles(lane.Entries, lane.Count, uint32(len(RowFieldsFixedResetImage)))
		}
	}
	return out
}()
View Source
var RowFieldsFixedLineagePlans = tableFixedLineagePlans(RowFieldsFixedKnown, RowFieldsFixedLayout, RowFieldsFixedDst, RowFieldsFixedHash)

One plan per lineage entry, laid down from THE LOCK's bytes: nothing compiles on the load path (§5.8 row 3).

View Source
var RowFieldsFixedPlan = tableFixedBuildPlan(RowFieldsFixedLeaves, 50)
View Source
var RowFieldsFixedPlanMax = func() int32 {
	m := RowFieldsFixedPlan.Count
	for _, lane := range RowFieldsFixedLineagePlans {
		if lane.Count > m {
			m = lane.Count
		}
	}
	return m
}()

RowFieldsFixedPlanMax is the plan capacity every layout this build reads needs: the largest entry count over the identity plan and every lineage plan (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §5.2). A plan slice of this length never refuses plan_too_large for a layout the lineage holds.

View Source
var RowFieldsFixedResetImage = func() []byte {
	var def RowFields
	RowFieldsReset(&def)
	return tableFixedOverlay(unsafe.Pointer(&def), unsafe.Sizeof(def))
}()
View Source
var RowFieldsTableFields = []TableFieldInfo{
	{Name: "pairs", Json: "pairs", TypeName: "FieldPair", DeclaredTypeName: "FieldPair", Id: 0x544438a7391e1e26, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 24, Offset: uint32(unsafe.Offsetof(RowFields{}.Pairs)), ElemSize: uint32(unsafe.Sizeof(RowFields{}.Pairs[0])), CountOffset: uint32(unsafe.Offsetof(RowFields{}.PairsCount)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 2352, CookCountOffset: 56448, 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: FieldPairTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "argv", Json: "argv", TypeName: "string", DeclaredTypeName: "string", Id: 0x89492d843ebc9863, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 4096, Offset: uint32(unsafe.Offsetof(RowFields{}.Argv)), ElemSize: uint32(unsafe.Sizeof(RowFields{}.Argv)), CountOffset: uint32(unsafe.Offsetof(RowFields{}.ArgvLength)), PresentOffset: 0xffffffff,
		CookOffset: 56452, CookElemSize: 1, CookCountOffset: 60552, 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},
}

RowFieldsTableFields is RowFields'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.

Functions

func Announce

func Announce(buffer []byte) int64

func AnnounceMeasure

func AnnounceMeasure() int64

func AnnounceRead

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

func BenchBeatBlockBegin

func BenchBeatBlockBegin(b *BenchBeatBlock, s *BenchBeatBlockStorage, c BenchBeatCounts, refusal *TableBlockRefusal) bool

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

func BenchBeatBlockBytes

func BenchBeatBlockBytes(b *BenchBeatBlock) int64

func BenchBeatBlockOpen

func BenchBeatBlockOpen(block *BenchBeatBlock, base unsafe.Pointer, bytes int64) bool

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

func BenchBeatCookFrom

func BenchBeatCookFrom(value *BenchBeat, buffer []byte, order TableByteOrder) bool

func BenchBeatCookMeasure

func BenchBeatCookMeasure(value *BenchBeat) int64

func BenchBeatCookMeasureReason

func BenchBeatCookMeasureReason(value *BenchBeat) (int64, error)

func BenchBeatFixedCheckBody

func BenchBeatFixedCheckBody(value *BenchBeat) bool

BenchBeat's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func BenchBeatFixedCheckBodyExact

func BenchBeatFixedCheckBodyExact(value *BenchBeat) bool

BenchBeatFixedCheckBodyExact is BenchBeatFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func BenchBeatFixedClamp

func BenchBeatFixedClamp(value *BenchBeat, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func BenchBeatFixedClampBody

func BenchBeatFixedClampBody(value *BenchBeat, clamped *int32)

BenchBeat's read-side bounds.

func BenchBeatFixedLeaves

func BenchBeatFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func BenchBeatFixedLoad

func BenchBeatFixedLoad(values []BenchBeat, data []byte, plan []TableFixedEntry, report *TableReport) int64

func BenchBeatFixedMeasure

func BenchBeatFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func BenchBeatFixedSave

func BenchBeatFixedSave(values []BenchBeat, buffer []byte) int64

BenchBeatFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func BenchBeatFixedSaveReason

func BenchBeatFixedSaveReason(values []BenchBeat, buffer []byte) (int64, error)

func BenchBeatFixedWriteBody

func BenchBeatFixedWriteBody(b []byte, value *BenchBeat)

func BenchBeatFromJson

func BenchBeatFromJson(value *BenchBeat, text []byte, report *TableReport) bool

BenchBeatFromJson fills one BenchBeat 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 BenchBeatLoad

func BenchBeatLoad(value *BenchBeat, data []byte, report *TableReport) bool

BenchBeat also carries the FIXED form (form 3): BenchBeatFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func BenchBeatLoadBody

func BenchBeatLoadBody(r *TableReader, value *BenchBeat) bool

func BenchBeatLoadMessageBody

func BenchBeatLoadMessageBody(r *TableMessageReader, value *BenchBeat) bool

func BenchBeatLoadMessages

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

func BenchBeatMeasure

func BenchBeatMeasure(value *BenchBeat) int64

func BenchBeatMeasureBody

func BenchBeatMeasureBody(value *BenchBeat, ids *TableIds) int64

func BenchBeatMeasureMessages

func BenchBeatMeasureMessages(values []*BenchBeat, report *TableReport) int64

func BenchBeatMeasureReason

func BenchBeatMeasureReason(value *BenchBeat) (int64, error)

func BenchBeatOpen

func BenchBeatOpen(cook *BenchBeatCook, base unsafe.Pointer, length int64) bool

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

func BenchBeatReset

func BenchBeatReset(value *BenchBeat)

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

func BenchBeatSave

func BenchBeatSave(value *BenchBeat, buffer []byte) int64

func BenchBeatSaveBody

func BenchBeatSaveBody(w *TableWriter, value *BenchBeat) bool

func BenchBeatSaveMessageBody

func BenchBeatSaveMessageBody(w *TableMessageWriter, value *BenchBeat) bool

func BenchBeatSaveMessages

func BenchBeatSaveMessages(values []*BenchBeat, buffer []byte, report *TableReport) int64

func BenchBeatSaveText

func BenchBeatSaveText(value *BenchBeat) (string, error)

BenchBeatSaveText returns the base64 of BenchBeat'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 BenchBeatToJson

func BenchBeatToJson(value *BenchBeat, buffer []byte) int64

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

func BenchBeatToJsonMeasure

func BenchBeatToJsonMeasure(value *BenchBeat) int64

BenchBeatToJsonMeasure is the exact size of BenchBeat's JSON text, writing nothing.

func CanonicalWordBlockBegin

func CanonicalWordBlockBegin(b *CanonicalWordBlock, s *CanonicalWordBlockStorage, c CanonicalWordCounts, refusal *TableBlockRefusal) bool

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

func CanonicalWordBlockBytes

func CanonicalWordBlockBytes(b *CanonicalWordBlock) int64

func CanonicalWordBlockOpen

func CanonicalWordBlockOpen(block *CanonicalWordBlock, base unsafe.Pointer, bytes int64) bool

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

func CanonicalWordCookFrom

func CanonicalWordCookFrom(value *CanonicalWord, buffer []byte, order TableByteOrder) bool

func CanonicalWordCookMeasure

func CanonicalWordCookMeasure(value *CanonicalWord) int64

func CanonicalWordCookMeasureReason

func CanonicalWordCookMeasureReason(value *CanonicalWord) (int64, error)

func CanonicalWordFixedCheckBody

func CanonicalWordFixedCheckBody(value *CanonicalWord) bool

CanonicalWord's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func CanonicalWordFixedClamp

func CanonicalWordFixedClamp(value *CanonicalWord, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func CanonicalWordFixedClampBody

func CanonicalWordFixedClampBody(value *CanonicalWord, clamped *int32)

CanonicalWord's read-side bounds.

func CanonicalWordFixedLeaves

func CanonicalWordFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func CanonicalWordFixedLoad

func CanonicalWordFixedLoad(values []CanonicalWord, data []byte, plan []TableFixedEntry, report *TableReport) int64

func CanonicalWordFixedMeasure

func CanonicalWordFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func CanonicalWordFixedSave

func CanonicalWordFixedSave(values []CanonicalWord, buffer []byte) int64

CanonicalWordFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func CanonicalWordFixedSaveReason

func CanonicalWordFixedSaveReason(values []CanonicalWord, buffer []byte) (int64, error)

func CanonicalWordFixedWriteBody

func CanonicalWordFixedWriteBody(b []byte, value *CanonicalWord)

func CanonicalWordFromJson

func CanonicalWordFromJson(value *CanonicalWord, text []byte, report *TableReport) bool

CanonicalWordFromJson fills one CanonicalWord 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 CanonicalWordLoad

func CanonicalWordLoad(value *CanonicalWord, data []byte, report *TableReport) bool

CanonicalWord also carries the FIXED form (form 3): CanonicalWordFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func CanonicalWordLoadBody

func CanonicalWordLoadBody(r *TableReader, value *CanonicalWord) bool

func CanonicalWordLoadMessageBody

func CanonicalWordLoadMessageBody(r *TableMessageReader, value *CanonicalWord) bool

func CanonicalWordLoadMessages

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

func CanonicalWordMeasure

func CanonicalWordMeasure(value *CanonicalWord) int64

func CanonicalWordMeasureBody

func CanonicalWordMeasureBody(value *CanonicalWord, ids *TableIds) int64

func CanonicalWordMeasureMessages

func CanonicalWordMeasureMessages(values []*CanonicalWord, report *TableReport) int64

func CanonicalWordMeasureReason

func CanonicalWordMeasureReason(value *CanonicalWord) (int64, error)

func CanonicalWordOpen

func CanonicalWordOpen(cook *CanonicalWordCook, base unsafe.Pointer, length int64) bool

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

func CanonicalWordReset

func CanonicalWordReset(value *CanonicalWord)

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

func CanonicalWordSave

func CanonicalWordSave(value *CanonicalWord, buffer []byte) int64

func CanonicalWordSaveBody

func CanonicalWordSaveBody(w *TableWriter, value *CanonicalWord) bool

func CanonicalWordSaveMessageBody

func CanonicalWordSaveMessageBody(w *TableMessageWriter, value *CanonicalWord) bool

func CanonicalWordSaveMessages

func CanonicalWordSaveMessages(values []*CanonicalWord, buffer []byte, report *TableReport) int64

func CanonicalWordSaveText

func CanonicalWordSaveText(value *CanonicalWord) (string, error)

CanonicalWordSaveText returns the base64 of CanonicalWord'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 CanonicalWordToJson

func CanonicalWordToJson(value *CanonicalWord, buffer []byte) int64

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

func CanonicalWordToJsonMeasure

func CanonicalWordToJsonMeasure(value *CanonicalWord) int64

CanonicalWordToJsonMeasure is the exact size of CanonicalWord's JSON text, writing nothing.

func ConfigChangeBlockBegin

func ConfigChangeBlockBegin(b *ConfigChangeBlock, s *ConfigChangeBlockStorage, c ConfigChangeCounts, refusal *TableBlockRefusal) bool

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

func ConfigChangeBlockBytes

func ConfigChangeBlockBytes(b *ConfigChangeBlock) int64

func ConfigChangeBlockOpen

func ConfigChangeBlockOpen(block *ConfigChangeBlock, base unsafe.Pointer, bytes int64) bool

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

func ConfigChangeCookFrom

func ConfigChangeCookFrom(value *ConfigChange, buffer []byte, order TableByteOrder) bool

func ConfigChangeCookMeasure

func ConfigChangeCookMeasure(value *ConfigChange) int64

func ConfigChangeCookMeasureReason

func ConfigChangeCookMeasureReason(value *ConfigChange) (int64, error)

func ConfigChangeFixedCheckBody

func ConfigChangeFixedCheckBody(value *ConfigChange) bool

ConfigChange's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func ConfigChangeFixedCheckBodyExact

func ConfigChangeFixedCheckBodyExact(value *ConfigChange) bool

ConfigChangeFixedCheckBodyExact is ConfigChangeFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func ConfigChangeFixedClamp

func ConfigChangeFixedClamp(value *ConfigChange, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func ConfigChangeFixedClampBody

func ConfigChangeFixedClampBody(value *ConfigChange, clamped *int32)

ConfigChange's read-side bounds.

func ConfigChangeFixedLeaves

func ConfigChangeFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func ConfigChangeFixedLoad

func ConfigChangeFixedLoad(values []ConfigChange, data []byte, plan []TableFixedEntry, report *TableReport) int64

func ConfigChangeFixedMeasure

func ConfigChangeFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func ConfigChangeFixedSave

func ConfigChangeFixedSave(values []ConfigChange, buffer []byte) int64

ConfigChangeFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func ConfigChangeFixedSaveReason

func ConfigChangeFixedSaveReason(values []ConfigChange, buffer []byte) (int64, error)

func ConfigChangeFixedWriteBody

func ConfigChangeFixedWriteBody(b []byte, value *ConfigChange)

func ConfigChangeFromJson

func ConfigChangeFromJson(value *ConfigChange, text []byte, report *TableReport) bool

ConfigChangeFromJson fills one ConfigChange 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 ConfigChangeLoad

func ConfigChangeLoad(value *ConfigChange, data []byte, report *TableReport) bool

ConfigChange also carries the FIXED form (form 3): ConfigChangeFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func ConfigChangeLoadBody

func ConfigChangeLoadBody(r *TableReader, value *ConfigChange) bool

func ConfigChangeLoadMessageBody

func ConfigChangeLoadMessageBody(r *TableMessageReader, value *ConfigChange) bool

func ConfigChangeLoadMessages

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

func ConfigChangeMeasure

func ConfigChangeMeasure(value *ConfigChange) int64

func ConfigChangeMeasureBody

func ConfigChangeMeasureBody(value *ConfigChange, ids *TableIds) int64

func ConfigChangeMeasureMessages

func ConfigChangeMeasureMessages(values []*ConfigChange, report *TableReport) int64

func ConfigChangeMeasureReason

func ConfigChangeMeasureReason(value *ConfigChange) (int64, error)

func ConfigChangeOpen

func ConfigChangeOpen(cook *ConfigChangeCook, base unsafe.Pointer, length int64) bool

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

func ConfigChangeReset

func ConfigChangeReset(value *ConfigChange)

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

func ConfigChangeSave

func ConfigChangeSave(value *ConfigChange, buffer []byte) int64

func ConfigChangeSaveBody

func ConfigChangeSaveBody(w *TableWriter, value *ConfigChange) bool

func ConfigChangeSaveMessageBody

func ConfigChangeSaveMessageBody(w *TableMessageWriter, value *ConfigChange) bool

func ConfigChangeSaveMessages

func ConfigChangeSaveMessages(values []*ConfigChange, buffer []byte, report *TableReport) int64

func ConfigChangeSaveText

func ConfigChangeSaveText(value *ConfigChange) (string, error)

ConfigChangeSaveText returns the base64 of ConfigChange'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 ConfigChangeToJson

func ConfigChangeToJson(value *ConfigChange, buffer []byte) int64

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

func ConfigChangeToJsonMeasure

func ConfigChangeToJsonMeasure(value *ConfigChange) int64

ConfigChangeToJsonMeasure is the exact size of ConfigChange's JSON text, writing nothing.

func ConfigRowBlockBegin

func ConfigRowBlockBegin(b *ConfigRowBlock, s *ConfigRowBlockStorage, c ConfigRowCounts, refusal *TableBlockRefusal) bool

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

func ConfigRowBlockBytes

func ConfigRowBlockBytes(b *ConfigRowBlock) int64

func ConfigRowBlockOpen

func ConfigRowBlockOpen(block *ConfigRowBlock, base unsafe.Pointer, bytes int64) bool

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

func ConfigRowCookFrom

func ConfigRowCookFrom(value *ConfigRow, buffer []byte, order TableByteOrder) bool

func ConfigRowCookMeasure

func ConfigRowCookMeasure(value *ConfigRow) int64

func ConfigRowCookMeasureReason

func ConfigRowCookMeasureReason(value *ConfigRow) (int64, error)

func ConfigRowFixedCheckBody

func ConfigRowFixedCheckBody(value *ConfigRow) bool

ConfigRow's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func ConfigRowFixedCheckBodyExact

func ConfigRowFixedCheckBodyExact(value *ConfigRow) bool

ConfigRowFixedCheckBodyExact is ConfigRowFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func ConfigRowFixedClamp

func ConfigRowFixedClamp(value *ConfigRow, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func ConfigRowFixedClampBody

func ConfigRowFixedClampBody(value *ConfigRow, clamped *int32)

ConfigRow's read-side bounds.

func ConfigRowFixedLeaves

func ConfigRowFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func ConfigRowFixedLoad

func ConfigRowFixedLoad(values []ConfigRow, data []byte, plan []TableFixedEntry, report *TableReport) int64

func ConfigRowFixedMeasure

func ConfigRowFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func ConfigRowFixedSave

func ConfigRowFixedSave(values []ConfigRow, buffer []byte) int64

ConfigRowFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func ConfigRowFixedSaveReason

func ConfigRowFixedSaveReason(values []ConfigRow, buffer []byte) (int64, error)

func ConfigRowFixedWriteBody

func ConfigRowFixedWriteBody(b []byte, value *ConfigRow)

func ConfigRowFromJson

func ConfigRowFromJson(value *ConfigRow, text []byte, report *TableReport) bool

ConfigRowFromJson fills one ConfigRow 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 ConfigRowLoad

func ConfigRowLoad(value *ConfigRow, data []byte, report *TableReport) bool

ConfigRow also carries the FIXED form (form 3): ConfigRowFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func ConfigRowLoadBody

func ConfigRowLoadBody(r *TableReader, value *ConfigRow) bool

func ConfigRowLoadMessageBody

func ConfigRowLoadMessageBody(r *TableMessageReader, value *ConfigRow) bool

func ConfigRowLoadMessages

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

func ConfigRowMeasure

func ConfigRowMeasure(value *ConfigRow) int64

func ConfigRowMeasureBody

func ConfigRowMeasureBody(value *ConfigRow, ids *TableIds) int64

func ConfigRowMeasureMessages

func ConfigRowMeasureMessages(values []*ConfigRow, report *TableReport) int64

func ConfigRowMeasureReason

func ConfigRowMeasureReason(value *ConfigRow) (int64, error)

func ConfigRowOpen

func ConfigRowOpen(cook *ConfigRowCook, base unsafe.Pointer, length int64) bool

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

func ConfigRowReset

func ConfigRowReset(value *ConfigRow)

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

func ConfigRowSave

func ConfigRowSave(value *ConfigRow, buffer []byte) int64

func ConfigRowSaveBody

func ConfigRowSaveBody(w *TableWriter, value *ConfigRow) bool

func ConfigRowSaveMessageBody

func ConfigRowSaveMessageBody(w *TableMessageWriter, value *ConfigRow) bool

func ConfigRowSaveMessages

func ConfigRowSaveMessages(values []*ConfigRow, buffer []byte, report *TableReport) int64

func ConfigRowSaveText

func ConfigRowSaveText(value *ConfigRow) (string, error)

ConfigRowSaveText returns the base64 of ConfigRow'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 ConfigRowToJson

func ConfigRowToJson(value *ConfigRow, buffer []byte) int64

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

func ConfigRowToJsonMeasure

func ConfigRowToJsonMeasure(value *ConfigRow) int64

ConfigRowToJsonMeasure is the exact size of ConfigRow's JSON text, writing nothing.

func EnumNameChangeOp

func EnumNameChangeOp(value ChangeOp) string

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

func EnumNameConfigKind

func EnumNameConfigKind(value ConfigKind) string

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

func EnumNameFieldType

func EnumNameFieldType(value FieldType) string

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

func EnvNameBlockBegin

func EnvNameBlockBegin(b *EnvNameBlock, s *EnvNameBlockStorage, c EnvNameCounts, refusal *TableBlockRefusal) bool

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

func EnvNameBlockBytes

func EnvNameBlockBytes(b *EnvNameBlock) int64

func EnvNameBlockOpen

func EnvNameBlockOpen(block *EnvNameBlock, base unsafe.Pointer, bytes int64) bool

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

func EnvNameCookFrom

func EnvNameCookFrom(value *EnvName, buffer []byte, order TableByteOrder) bool

func EnvNameCookMeasure

func EnvNameCookMeasure(value *EnvName) int64

func EnvNameCookMeasureReason

func EnvNameCookMeasureReason(value *EnvName) (int64, error)

func EnvNameFixedCheckBody

func EnvNameFixedCheckBody(value *EnvName) bool

EnvName's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func EnvNameFixedCheckBodyExact

func EnvNameFixedCheckBodyExact(value *EnvName) bool

EnvNameFixedCheckBodyExact is EnvNameFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func EnvNameFixedClamp

func EnvNameFixedClamp(value *EnvName, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func EnvNameFixedClampBody

func EnvNameFixedClampBody(value *EnvName, clamped *int32)

EnvName's read-side bounds.

func EnvNameFixedLeaves

func EnvNameFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func EnvNameFixedLoad

func EnvNameFixedLoad(values []EnvName, data []byte, plan []TableFixedEntry, report *TableReport) int64

func EnvNameFixedMeasure

func EnvNameFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func EnvNameFixedSave

func EnvNameFixedSave(values []EnvName, buffer []byte) int64

EnvNameFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func EnvNameFixedSaveReason

func EnvNameFixedSaveReason(values []EnvName, buffer []byte) (int64, error)

func EnvNameFixedWriteBody

func EnvNameFixedWriteBody(b []byte, value *EnvName)

func EnvNameFromJson

func EnvNameFromJson(value *EnvName, text []byte, report *TableReport) bool

EnvNameFromJson fills one EnvName 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 EnvNameLoad

func EnvNameLoad(value *EnvName, data []byte, report *TableReport) bool

EnvName also carries the FIXED form (form 3): EnvNameFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func EnvNameLoadBody

func EnvNameLoadBody(r *TableReader, value *EnvName) bool

func EnvNameLoadMessageBody

func EnvNameLoadMessageBody(r *TableMessageReader, value *EnvName) bool

func EnvNameLoadMessages

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

func EnvNameMeasure

func EnvNameMeasure(value *EnvName) int64

func EnvNameMeasureBody

func EnvNameMeasureBody(value *EnvName, ids *TableIds) int64

func EnvNameMeasureMessages

func EnvNameMeasureMessages(values []*EnvName, report *TableReport) int64

func EnvNameMeasureReason

func EnvNameMeasureReason(value *EnvName) (int64, error)

func EnvNameOpen

func EnvNameOpen(cook *EnvNameCook, base unsafe.Pointer, length int64) bool

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

func EnvNameReset

func EnvNameReset(value *EnvName)

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

func EnvNameSave

func EnvNameSave(value *EnvName, buffer []byte) int64

func EnvNameSaveBody

func EnvNameSaveBody(w *TableWriter, value *EnvName) bool

func EnvNameSaveMessageBody

func EnvNameSaveMessageBody(w *TableMessageWriter, value *EnvName) bool

func EnvNameSaveMessages

func EnvNameSaveMessages(values []*EnvName, buffer []byte, report *TableReport) int64

func EnvNameSaveText

func EnvNameSaveText(value *EnvName) (string, error)

EnvNameSaveText returns the base64 of EnvName'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 EnvNameToJson

func EnvNameToJson(value *EnvName, buffer []byte) int64

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

func EnvNameToJsonMeasure

func EnvNameToJsonMeasure(value *EnvName) int64

EnvNameToJsonMeasure is the exact size of EnvName's JSON text, writing nothing.

func FieldPairBlockBegin

func FieldPairBlockBegin(b *FieldPairBlock, s *FieldPairBlockStorage, c FieldPairCounts, refusal *TableBlockRefusal) bool

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

func FieldPairBlockBytes

func FieldPairBlockBytes(b *FieldPairBlock) int64

func FieldPairBlockOpen

func FieldPairBlockOpen(block *FieldPairBlock, base unsafe.Pointer, bytes int64) bool

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

func FieldPairCookFrom

func FieldPairCookFrom(value *FieldPair, buffer []byte, order TableByteOrder) bool

func FieldPairCookMeasure

func FieldPairCookMeasure(value *FieldPair) int64

func FieldPairCookMeasureReason

func FieldPairCookMeasureReason(value *FieldPair) (int64, error)

func FieldPairFixedCheckBody

func FieldPairFixedCheckBody(value *FieldPair) bool

FieldPair's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func FieldPairFixedCheckBodyExact

func FieldPairFixedCheckBodyExact(value *FieldPair) bool

FieldPairFixedCheckBodyExact is FieldPairFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func FieldPairFixedClamp

func FieldPairFixedClamp(value *FieldPair, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func FieldPairFixedClampBody

func FieldPairFixedClampBody(value *FieldPair, clamped *int32)

FieldPair's read-side bounds.

func FieldPairFixedLeaves

func FieldPairFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func FieldPairFixedLoad

func FieldPairFixedLoad(values []FieldPair, data []byte, plan []TableFixedEntry, report *TableReport) int64

func FieldPairFixedMeasure

func FieldPairFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func FieldPairFixedSave

func FieldPairFixedSave(values []FieldPair, buffer []byte) int64

FieldPairFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func FieldPairFixedSaveReason

func FieldPairFixedSaveReason(values []FieldPair, buffer []byte) (int64, error)

func FieldPairFixedWriteBody

func FieldPairFixedWriteBody(b []byte, value *FieldPair)

func FieldPairFromJson

func FieldPairFromJson(value *FieldPair, text []byte, report *TableReport) bool

FieldPairFromJson fills one FieldPair 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 FieldPairLoad

func FieldPairLoad(value *FieldPair, data []byte, report *TableReport) bool

FieldPair also carries the FIXED form (form 3): FieldPairFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func FieldPairLoadBody

func FieldPairLoadBody(r *TableReader, value *FieldPair) bool

func FieldPairLoadMessageBody

func FieldPairLoadMessageBody(r *TableMessageReader, value *FieldPair) bool

func FieldPairLoadMessages

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

func FieldPairMeasure

func FieldPairMeasure(value *FieldPair) int64

func FieldPairMeasureBody

func FieldPairMeasureBody(value *FieldPair, ids *TableIds) int64

func FieldPairMeasureMessages

func FieldPairMeasureMessages(values []*FieldPair, report *TableReport) int64

func FieldPairMeasureReason

func FieldPairMeasureReason(value *FieldPair) (int64, error)

func FieldPairOpen

func FieldPairOpen(cook *FieldPairCook, base unsafe.Pointer, length int64) bool

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

func FieldPairReset

func FieldPairReset(value *FieldPair)

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

func FieldPairSave

func FieldPairSave(value *FieldPair, buffer []byte) int64

func FieldPairSaveBody

func FieldPairSaveBody(w *TableWriter, value *FieldPair) bool

func FieldPairSaveMessageBody

func FieldPairSaveMessageBody(w *TableMessageWriter, value *FieldPair) bool

func FieldPairSaveMessages

func FieldPairSaveMessages(values []*FieldPair, buffer []byte, report *TableReport) int64

func FieldPairSaveText

func FieldPairSaveText(value *FieldPair) (string, error)

FieldPairSaveText returns the base64 of FieldPair'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 FieldPairToJson

func FieldPairToJson(value *FieldPair, buffer []byte) int64

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

func FieldPairToJsonMeasure

func FieldPairToJsonMeasure(value *FieldPair) int64

FieldPairToJsonMeasure is the exact size of FieldPair's JSON text, writing nothing.

func FileHeaderBlockBegin

func FileHeaderBlockBegin(b *FileHeaderBlock, s *FileHeaderBlockStorage, c FileHeaderCounts, refusal *TableBlockRefusal) bool

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

func FileHeaderBlockBytes

func FileHeaderBlockBytes(b *FileHeaderBlock) int64

func FileHeaderBlockOpen

func FileHeaderBlockOpen(block *FileHeaderBlock, base unsafe.Pointer, bytes int64) bool

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

func FileHeaderCookFrom

func FileHeaderCookFrom(value *FileHeader, buffer []byte, order TableByteOrder) bool

func FileHeaderCookMeasure

func FileHeaderCookMeasure(value *FileHeader) int64

func FileHeaderCookMeasureReason

func FileHeaderCookMeasureReason(value *FileHeader) (int64, error)

func FileHeaderFixedCheckBody

func FileHeaderFixedCheckBody(value *FileHeader) bool

FileHeader's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func FileHeaderFixedClamp

func FileHeaderFixedClamp(value *FileHeader, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func FileHeaderFixedClampBody

func FileHeaderFixedClampBody(value *FileHeader, clamped *int32)

FileHeader's read-side bounds.

func FileHeaderFixedLeaves

func FileHeaderFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func FileHeaderFixedLoad

func FileHeaderFixedLoad(values []FileHeader, data []byte, plan []TableFixedEntry, report *TableReport) int64

func FileHeaderFixedMeasure

func FileHeaderFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func FileHeaderFixedSave

func FileHeaderFixedSave(values []FileHeader, buffer []byte) int64

FileHeaderFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func FileHeaderFixedSaveReason

func FileHeaderFixedSaveReason(values []FileHeader, buffer []byte) (int64, error)

func FileHeaderFixedWriteBody

func FileHeaderFixedWriteBody(b []byte, value *FileHeader)

func FileHeaderFromJson

func FileHeaderFromJson(value *FileHeader, text []byte, report *TableReport) bool

FileHeaderFromJson fills one FileHeader 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 FileHeaderLoad

func FileHeaderLoad(value *FileHeader, data []byte, report *TableReport) bool

FileHeader also carries the FIXED form (form 3): FileHeaderFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func FileHeaderLoadBody

func FileHeaderLoadBody(r *TableReader, value *FileHeader) bool

func FileHeaderLoadMessageBody

func FileHeaderLoadMessageBody(r *TableMessageReader, value *FileHeader) bool

func FileHeaderLoadMessages

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

func FileHeaderMeasure

func FileHeaderMeasure(value *FileHeader) int64

func FileHeaderMeasureBody

func FileHeaderMeasureBody(value *FileHeader, ids *TableIds) int64

func FileHeaderMeasureMessages

func FileHeaderMeasureMessages(values []*FileHeader, report *TableReport) int64

func FileHeaderMeasureReason

func FileHeaderMeasureReason(value *FileHeader) (int64, error)

func FileHeaderOpen

func FileHeaderOpen(cook *FileHeaderCook, base unsafe.Pointer, length int64) bool

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

func FileHeaderReset

func FileHeaderReset(value *FileHeader)

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

func FileHeaderSave

func FileHeaderSave(value *FileHeader, buffer []byte) int64

func FileHeaderSaveBody

func FileHeaderSaveBody(w *TableWriter, value *FileHeader) bool

func FileHeaderSaveMessageBody

func FileHeaderSaveMessageBody(w *TableMessageWriter, value *FileHeader) bool

func FileHeaderSaveMessages

func FileHeaderSaveMessages(values []*FileHeader, buffer []byte, report *TableReport) int64

func FileHeaderSaveText

func FileHeaderSaveText(value *FileHeader) (string, error)

FileHeaderSaveText returns the base64 of FileHeader'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 FileHeaderToJson

func FileHeaderToJson(value *FileHeader, buffer []byte) int64

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

func FileHeaderToJsonMeasure

func FileHeaderToJsonMeasure(value *FileHeader) int64

FileHeaderToJsonMeasure is the exact size of FileHeader's JSON text, writing nothing.

func HostGroupBlockBegin

func HostGroupBlockBegin(b *HostGroupBlock, s *HostGroupBlockStorage, c HostGroupCounts, refusal *TableBlockRefusal) bool

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

func HostGroupBlockBytes

func HostGroupBlockBytes(b *HostGroupBlock) int64

func HostGroupBlockOpen

func HostGroupBlockOpen(block *HostGroupBlock, base unsafe.Pointer, bytes int64) bool

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

func HostGroupCookFrom

func HostGroupCookFrom(value *HostGroup, buffer []byte, order TableByteOrder) bool

func HostGroupCookMeasure

func HostGroupCookMeasure(value *HostGroup) int64

func HostGroupCookMeasureReason

func HostGroupCookMeasureReason(value *HostGroup) (int64, error)

func HostGroupFixedCheckBody

func HostGroupFixedCheckBody(value *HostGroup) bool

HostGroup's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func HostGroupFixedClamp

func HostGroupFixedClamp(value *HostGroup, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func HostGroupFixedClampBody

func HostGroupFixedClampBody(value *HostGroup, clamped *int32)

HostGroup's read-side bounds.

func HostGroupFixedLeaves

func HostGroupFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func HostGroupFixedLoad

func HostGroupFixedLoad(values []HostGroup, data []byte, plan []TableFixedEntry, report *TableReport) int64

func HostGroupFixedMeasure

func HostGroupFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func HostGroupFixedSave

func HostGroupFixedSave(values []HostGroup, buffer []byte) int64

HostGroupFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func HostGroupFixedSaveReason

func HostGroupFixedSaveReason(values []HostGroup, buffer []byte) (int64, error)

func HostGroupFixedWriteBody

func HostGroupFixedWriteBody(b []byte, value *HostGroup)

func HostGroupFromJson

func HostGroupFromJson(value *HostGroup, text []byte, report *TableReport) bool

HostGroupFromJson fills one HostGroup 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 HostGroupLoad

func HostGroupLoad(value *HostGroup, data []byte, report *TableReport) bool

HostGroup also carries the FIXED form (form 3): HostGroupFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func HostGroupLoadBody

func HostGroupLoadBody(r *TableReader, value *HostGroup) bool

func HostGroupLoadMessageBody

func HostGroupLoadMessageBody(r *TableMessageReader, value *HostGroup) bool

func HostGroupLoadMessages

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

func HostGroupMeasure

func HostGroupMeasure(value *HostGroup) int64

func HostGroupMeasureBody

func HostGroupMeasureBody(value *HostGroup, ids *TableIds) int64

func HostGroupMeasureMessages

func HostGroupMeasureMessages(values []*HostGroup, report *TableReport) int64

func HostGroupMeasureReason

func HostGroupMeasureReason(value *HostGroup) (int64, error)

func HostGroupOpen

func HostGroupOpen(cook *HostGroupCook, base unsafe.Pointer, length int64) bool

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

func HostGroupReset

func HostGroupReset(value *HostGroup)

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

func HostGroupSave

func HostGroupSave(value *HostGroup, buffer []byte) int64

func HostGroupSaveBody

func HostGroupSaveBody(w *TableWriter, value *HostGroup) bool

func HostGroupSaveMessageBody

func HostGroupSaveMessageBody(w *TableMessageWriter, value *HostGroup) bool

func HostGroupSaveMessages

func HostGroupSaveMessages(values []*HostGroup, buffer []byte, report *TableReport) int64

func HostGroupSaveText

func HostGroupSaveText(value *HostGroup) (string, error)

HostGroupSaveText returns the base64 of HostGroup'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 HostGroupToJson

func HostGroupToJson(value *HostGroup, buffer []byte) int64

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

func HostGroupToJsonMeasure

func HostGroupToJsonMeasure(value *HostGroup) int64

HostGroupToJsonMeasure is the exact size of HostGroup's JSON text, writing nothing.

func HostNameBlockBegin

func HostNameBlockBegin(b *HostNameBlock, s *HostNameBlockStorage, c HostNameCounts, refusal *TableBlockRefusal) bool

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

func HostNameBlockBytes

func HostNameBlockBytes(b *HostNameBlock) int64

func HostNameBlockOpen

func HostNameBlockOpen(block *HostNameBlock, base unsafe.Pointer, bytes int64) bool

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

func HostNameCookFrom

func HostNameCookFrom(value *HostName, buffer []byte, order TableByteOrder) bool

func HostNameCookMeasure

func HostNameCookMeasure(value *HostName) int64

func HostNameCookMeasureReason

func HostNameCookMeasureReason(value *HostName) (int64, error)

func HostNameFixedCheckBody

func HostNameFixedCheckBody(value *HostName) bool

HostName's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func HostNameFixedCheckBodyExact

func HostNameFixedCheckBodyExact(value *HostName) bool

HostNameFixedCheckBodyExact is HostNameFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func HostNameFixedClamp

func HostNameFixedClamp(value *HostName, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func HostNameFixedClampBody

func HostNameFixedClampBody(value *HostName, clamped *int32)

HostName's read-side bounds.

func HostNameFixedLeaves

func HostNameFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func HostNameFixedLoad

func HostNameFixedLoad(values []HostName, data []byte, plan []TableFixedEntry, report *TableReport) int64

func HostNameFixedMeasure

func HostNameFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func HostNameFixedSave

func HostNameFixedSave(values []HostName, buffer []byte) int64

HostNameFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func HostNameFixedSaveReason

func HostNameFixedSaveReason(values []HostName, buffer []byte) (int64, error)

func HostNameFixedWriteBody

func HostNameFixedWriteBody(b []byte, value *HostName)

func HostNameFromJson

func HostNameFromJson(value *HostName, text []byte, report *TableReport) bool

HostNameFromJson fills one HostName 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 HostNameLoad

func HostNameLoad(value *HostName, data []byte, report *TableReport) bool

HostName also carries the FIXED form (form 3): HostNameFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func HostNameLoadBody

func HostNameLoadBody(r *TableReader, value *HostName) bool

func HostNameLoadMessageBody

func HostNameLoadMessageBody(r *TableMessageReader, value *HostName) bool

func HostNameLoadMessages

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

func HostNameMeasure

func HostNameMeasure(value *HostName) int64

func HostNameMeasureBody

func HostNameMeasureBody(value *HostName, ids *TableIds) int64

func HostNameMeasureMessages

func HostNameMeasureMessages(values []*HostName, report *TableReport) int64

func HostNameMeasureReason

func HostNameMeasureReason(value *HostName) (int64, error)

func HostNameOpen

func HostNameOpen(cook *HostNameCook, base unsafe.Pointer, length int64) bool

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

func HostNameReset

func HostNameReset(value *HostName)

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

func HostNameSave

func HostNameSave(value *HostName, buffer []byte) int64

func HostNameSaveBody

func HostNameSaveBody(w *TableWriter, value *HostName) bool

func HostNameSaveMessageBody

func HostNameSaveMessageBody(w *TableMessageWriter, value *HostName) bool

func HostNameSaveMessages

func HostNameSaveMessages(values []*HostName, buffer []byte, report *TableReport) int64

func HostNameSaveText

func HostNameSaveText(value *HostName) (string, error)

HostNameSaveText returns the base64 of HostName'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 HostNameToJson

func HostNameToJson(value *HostName, buffer []byte) int64

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

func HostNameToJsonMeasure

func HostNameToJsonMeasure(value *HostName) int64

HostNameToJsonMeasure is the exact size of HostName's JSON text, writing nothing.

func HostViewBlockBegin

func HostViewBlockBegin(b *HostViewBlock, s *HostViewBlockStorage, c HostViewCounts, refusal *TableBlockRefusal) bool

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

func HostViewBlockBytes

func HostViewBlockBytes(b *HostViewBlock) int64

func HostViewBlockOpen

func HostViewBlockOpen(block *HostViewBlock, base unsafe.Pointer, bytes int64) bool

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

func HostViewCookFrom

func HostViewCookFrom(value *HostView, buffer []byte, order TableByteOrder) bool

func HostViewCookMeasure

func HostViewCookMeasure(value *HostView) int64

func HostViewCookMeasureReason

func HostViewCookMeasureReason(value *HostView) (int64, error)

func HostViewFixedCheckBody

func HostViewFixedCheckBody(value *HostView) bool

HostView's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func HostViewFixedCheckBodyExact

func HostViewFixedCheckBodyExact(value *HostView) bool

HostViewFixedCheckBodyExact is HostViewFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func HostViewFixedClamp

func HostViewFixedClamp(value *HostView, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func HostViewFixedClampBody

func HostViewFixedClampBody(value *HostView, clamped *int32)

HostView's read-side bounds.

func HostViewFixedLeaves

func HostViewFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func HostViewFixedLoad

func HostViewFixedLoad(values []HostView, data []byte, plan []TableFixedEntry, report *TableReport) int64

func HostViewFixedMeasure

func HostViewFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func HostViewFixedSave

func HostViewFixedSave(values []HostView, buffer []byte) int64

HostViewFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func HostViewFixedSaveReason

func HostViewFixedSaveReason(values []HostView, buffer []byte) (int64, error)

func HostViewFixedWriteBody

func HostViewFixedWriteBody(b []byte, value *HostView)

func HostViewFromJson

func HostViewFromJson(value *HostView, text []byte, report *TableReport) bool

HostViewFromJson fills one HostView 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 HostViewLoad

func HostViewLoad(value *HostView, data []byte, report *TableReport) bool

HostView also carries the FIXED form (form 3): HostViewFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func HostViewLoadBody

func HostViewLoadBody(r *TableReader, value *HostView) bool

func HostViewLoadMessageBody

func HostViewLoadMessageBody(r *TableMessageReader, value *HostView) bool

func HostViewLoadMessages

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

func HostViewMeasure

func HostViewMeasure(value *HostView) int64

func HostViewMeasureBody

func HostViewMeasureBody(value *HostView, ids *TableIds) int64

func HostViewMeasureMessages

func HostViewMeasureMessages(values []*HostView, report *TableReport) int64

func HostViewMeasureReason

func HostViewMeasureReason(value *HostView) (int64, error)

func HostViewOpen

func HostViewOpen(cook *HostViewCook, base unsafe.Pointer, length int64) bool

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

func HostViewReset

func HostViewReset(value *HostView)

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

func HostViewSave

func HostViewSave(value *HostView, buffer []byte) int64

func HostViewSaveBody

func HostViewSaveBody(w *TableWriter, value *HostView) bool

func HostViewSaveMessageBody

func HostViewSaveMessageBody(w *TableMessageWriter, value *HostView) bool

func HostViewSaveMessages

func HostViewSaveMessages(values []*HostView, buffer []byte, report *TableReport) int64

func HostViewSaveText

func HostViewSaveText(value *HostView) (string, error)

HostViewSaveText returns the base64 of HostView'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 HostViewToJson

func HostViewToJson(value *HostView, buffer []byte) int64

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

func HostViewToJsonMeasure

func HostViewToJsonMeasure(value *HostView) int64

HostViewToJsonMeasure is the exact size of HostView's JSON text, writing nothing.

func InventoryBlockBegin

func InventoryBlockBegin(b *InventoryBlock, s *InventoryBlockStorage, c InventoryCounts, refusal *TableBlockRefusal) bool

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

func InventoryBlockBytes

func InventoryBlockBytes(b *InventoryBlock) int64

func InventoryBlockOpen

func InventoryBlockOpen(block *InventoryBlock, base unsafe.Pointer, bytes int64) bool

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

func InventoryCookFrom

func InventoryCookFrom(value *Inventory, buffer []byte, order TableByteOrder) bool

func InventoryCookMeasure

func InventoryCookMeasure(value *Inventory) int64

func InventoryCookMeasureReason

func InventoryCookMeasureReason(value *Inventory) (int64, error)

func InventoryFixedCheckBody

func InventoryFixedCheckBody(value *Inventory) bool

Inventory's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func InventoryFixedCheckBodyExact

func InventoryFixedCheckBodyExact(value *Inventory) bool

InventoryFixedCheckBodyExact is InventoryFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func InventoryFixedClamp

func InventoryFixedClamp(value *Inventory, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func InventoryFixedClampBody

func InventoryFixedClampBody(value *Inventory, clamped *int32)

Inventory's read-side bounds.

func InventoryFixedLeaves

func InventoryFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func InventoryFixedLoad

func InventoryFixedLoad(values []Inventory, data []byte, plan []TableFixedEntry, report *TableReport) int64

func InventoryFixedMeasure

func InventoryFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func InventoryFixedSave

func InventoryFixedSave(values []Inventory, buffer []byte) int64

InventoryFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func InventoryFixedSaveReason

func InventoryFixedSaveReason(values []Inventory, buffer []byte) (int64, error)

func InventoryFixedWriteBody

func InventoryFixedWriteBody(b []byte, value *Inventory)

func InventoryFromJson

func InventoryFromJson(value *Inventory, text []byte, report *TableReport) bool

InventoryFromJson fills one Inventory 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 InventoryLoad

func InventoryLoad(value *Inventory, data []byte, report *TableReport) bool

Inventory also carries the FIXED form (form 3): InventoryFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func InventoryLoadBody

func InventoryLoadBody(r *TableReader, value *Inventory) bool

func InventoryLoadMessageBody

func InventoryLoadMessageBody(r *TableMessageReader, value *Inventory) bool

func InventoryLoadMessages

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

func InventoryLoopBlockBegin

func InventoryLoopBlockBegin(b *InventoryLoopBlock, s *InventoryLoopBlockStorage, c InventoryLoopCounts, refusal *TableBlockRefusal) bool

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

func InventoryLoopBlockBytes

func InventoryLoopBlockBytes(b *InventoryLoopBlock) int64

func InventoryLoopBlockOpen

func InventoryLoopBlockOpen(block *InventoryLoopBlock, base unsafe.Pointer, bytes int64) bool

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

func InventoryLoopCookFrom

func InventoryLoopCookFrom(value *InventoryLoop, buffer []byte, order TableByteOrder) bool

func InventoryLoopCookMeasure

func InventoryLoopCookMeasure(value *InventoryLoop) int64

func InventoryLoopCookMeasureReason

func InventoryLoopCookMeasureReason(value *InventoryLoop) (int64, error)

func InventoryLoopFixedCheckBody

func InventoryLoopFixedCheckBody(value *InventoryLoop) bool

InventoryLoop's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func InventoryLoopFixedCheckBodyExact

func InventoryLoopFixedCheckBodyExact(value *InventoryLoop) bool

InventoryLoopFixedCheckBodyExact is InventoryLoopFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func InventoryLoopFixedClamp

func InventoryLoopFixedClamp(value *InventoryLoop, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func InventoryLoopFixedClampBody

func InventoryLoopFixedClampBody(value *InventoryLoop, clamped *int32)

InventoryLoop's read-side bounds.

func InventoryLoopFixedLeaves

func InventoryLoopFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func InventoryLoopFixedLoad

func InventoryLoopFixedLoad(values []InventoryLoop, data []byte, plan []TableFixedEntry, report *TableReport) int64

func InventoryLoopFixedMeasure

func InventoryLoopFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func InventoryLoopFixedSave

func InventoryLoopFixedSave(values []InventoryLoop, buffer []byte) int64

InventoryLoopFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func InventoryLoopFixedSaveReason

func InventoryLoopFixedSaveReason(values []InventoryLoop, buffer []byte) (int64, error)

func InventoryLoopFixedWriteBody

func InventoryLoopFixedWriteBody(b []byte, value *InventoryLoop)

func InventoryLoopFromJson

func InventoryLoopFromJson(value *InventoryLoop, text []byte, report *TableReport) bool

InventoryLoopFromJson fills one InventoryLoop 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 InventoryLoopLoad

func InventoryLoopLoad(value *InventoryLoop, data []byte, report *TableReport) bool

InventoryLoop also carries the FIXED form (form 3): InventoryLoopFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func InventoryLoopLoadBody

func InventoryLoopLoadBody(r *TableReader, value *InventoryLoop) bool

func InventoryLoopLoadMessageBody

func InventoryLoopLoadMessageBody(r *TableMessageReader, value *InventoryLoop) bool

func InventoryLoopLoadMessages

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

func InventoryLoopMeasure

func InventoryLoopMeasure(value *InventoryLoop) int64

func InventoryLoopMeasureBody

func InventoryLoopMeasureBody(value *InventoryLoop, ids *TableIds) int64

func InventoryLoopMeasureMessages

func InventoryLoopMeasureMessages(values []*InventoryLoop, report *TableReport) int64

func InventoryLoopMeasureReason

func InventoryLoopMeasureReason(value *InventoryLoop) (int64, error)

func InventoryLoopOpen

func InventoryLoopOpen(cook *InventoryLoopCook, base unsafe.Pointer, length int64) bool

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

func InventoryLoopReset

func InventoryLoopReset(value *InventoryLoop)

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

func InventoryLoopSave

func InventoryLoopSave(value *InventoryLoop, buffer []byte) int64

func InventoryLoopSaveBody

func InventoryLoopSaveBody(w *TableWriter, value *InventoryLoop) bool

func InventoryLoopSaveMessageBody

func InventoryLoopSaveMessageBody(w *TableMessageWriter, value *InventoryLoop) bool

func InventoryLoopSaveMessages

func InventoryLoopSaveMessages(values []*InventoryLoop, buffer []byte, report *TableReport) int64

func InventoryLoopSaveText

func InventoryLoopSaveText(value *InventoryLoop) (string, error)

InventoryLoopSaveText returns the base64 of InventoryLoop'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 InventoryLoopToJson

func InventoryLoopToJson(value *InventoryLoop, buffer []byte) int64

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

func InventoryLoopToJsonMeasure

func InventoryLoopToJsonMeasure(value *InventoryLoop) int64

InventoryLoopToJsonMeasure is the exact size of InventoryLoop's JSON text, writing nothing.

func InventoryMeasure

func InventoryMeasure(value *Inventory) int64

func InventoryMeasureBody

func InventoryMeasureBody(value *Inventory, ids *TableIds) int64

func InventoryMeasureMessages

func InventoryMeasureMessages(values []*Inventory, report *TableReport) int64

func InventoryMeasureReason

func InventoryMeasureReason(value *Inventory) (int64, error)

func InventoryOpen

func InventoryOpen(cook *InventoryCook, base unsafe.Pointer, length int64) bool

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

func InventoryReset

func InventoryReset(value *Inventory)

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

func InventorySave

func InventorySave(value *Inventory, buffer []byte) int64

func InventorySaveBody

func InventorySaveBody(w *TableWriter, value *Inventory) bool

func InventorySaveMessageBody

func InventorySaveMessageBody(w *TableMessageWriter, value *Inventory) bool

func InventorySaveMessages

func InventorySaveMessages(values []*Inventory, buffer []byte, report *TableReport) int64

func InventorySaveText

func InventorySaveText(value *Inventory) (string, error)

InventorySaveText returns the base64 of Inventory'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 InventoryToJson

func InventoryToJson(value *Inventory, buffer []byte) int64

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

func InventoryToJsonMeasure

func InventoryToJsonMeasure(value *Inventory) int64

InventoryToJsonMeasure is the exact size of Inventory's JSON text, writing nothing.

func KindRevBlockBegin

func KindRevBlockBegin(b *KindRevBlock, s *KindRevBlockStorage, c KindRevCounts, refusal *TableBlockRefusal) bool

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

func KindRevBlockBytes

func KindRevBlockBytes(b *KindRevBlock) int64

func KindRevBlockOpen

func KindRevBlockOpen(block *KindRevBlock, base unsafe.Pointer, bytes int64) bool

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

func KindRevCookFrom

func KindRevCookFrom(value *KindRev, buffer []byte, order TableByteOrder) bool

func KindRevCookMeasure

func KindRevCookMeasure(value *KindRev) int64

func KindRevCookMeasureReason

func KindRevCookMeasureReason(value *KindRev) (int64, error)

func KindRevFixedCheckBody

func KindRevFixedCheckBody(value *KindRev) bool

KindRev's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func KindRevFixedClamp

func KindRevFixedClamp(value *KindRev, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func KindRevFixedClampBody

func KindRevFixedClampBody(value *KindRev, clamped *int32)

KindRev's read-side bounds.

func KindRevFixedLeaves

func KindRevFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func KindRevFixedLoad

func KindRevFixedLoad(values []KindRev, data []byte, plan []TableFixedEntry, report *TableReport) int64

func KindRevFixedMeasure

func KindRevFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func KindRevFixedSave

func KindRevFixedSave(values []KindRev, buffer []byte) int64

KindRevFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func KindRevFixedSaveReason

func KindRevFixedSaveReason(values []KindRev, buffer []byte) (int64, error)

func KindRevFixedWriteBody

func KindRevFixedWriteBody(b []byte, value *KindRev)

func KindRevFromJson

func KindRevFromJson(value *KindRev, text []byte, report *TableReport) bool

KindRevFromJson fills one KindRev 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 KindRevLoad

func KindRevLoad(value *KindRev, data []byte, report *TableReport) bool

KindRev also carries the FIXED form (form 3): KindRevFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func KindRevLoadBody

func KindRevLoadBody(r *TableReader, value *KindRev) bool

func KindRevLoadMessageBody

func KindRevLoadMessageBody(r *TableMessageReader, value *KindRev) bool

func KindRevLoadMessages

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

func KindRevMeasure

func KindRevMeasure(value *KindRev) int64

func KindRevMeasureBody

func KindRevMeasureBody(value *KindRev, ids *TableIds) int64

func KindRevMeasureMessages

func KindRevMeasureMessages(values []*KindRev, report *TableReport) int64

func KindRevMeasureReason

func KindRevMeasureReason(value *KindRev) (int64, error)

func KindRevOpen

func KindRevOpen(cook *KindRevCook, base unsafe.Pointer, length int64) bool

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

func KindRevReset

func KindRevReset(value *KindRev)

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

func KindRevSave

func KindRevSave(value *KindRev, buffer []byte) int64

func KindRevSaveBody

func KindRevSaveBody(w *TableWriter, value *KindRev) bool

func KindRevSaveMessageBody

func KindRevSaveMessageBody(w *TableMessageWriter, value *KindRev) bool

func KindRevSaveMessages

func KindRevSaveMessages(values []*KindRev, buffer []byte, report *TableReport) int64

func KindRevSaveText

func KindRevSaveText(value *KindRev) (string, error)

KindRevSaveText returns the base64 of KindRev'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 KindRevToJson

func KindRevToJson(value *KindRev, buffer []byte) int64

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

func KindRevToJsonMeasure

func KindRevToJsonMeasure(value *KindRev) int64

KindRevToJsonMeasure is the exact size of KindRev's JSON text, writing nothing.

func MachineBeatBlockBegin

func MachineBeatBlockBegin(b *MachineBeatBlock, s *MachineBeatBlockStorage, c MachineBeatCounts, refusal *TableBlockRefusal) bool

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

func MachineBeatBlockBytes

func MachineBeatBlockBytes(b *MachineBeatBlock) int64

func MachineBeatBlockOpen

func MachineBeatBlockOpen(block *MachineBeatBlock, base unsafe.Pointer, bytes int64) bool

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

func MachineBeatCookFrom

func MachineBeatCookFrom(value *MachineBeat, buffer []byte, order TableByteOrder) bool

func MachineBeatCookMeasure

func MachineBeatCookMeasure(value *MachineBeat) int64

func MachineBeatCookMeasureReason

func MachineBeatCookMeasureReason(value *MachineBeat) (int64, error)

func MachineBeatFixedCheckBody

func MachineBeatFixedCheckBody(value *MachineBeat) bool

MachineBeat's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func MachineBeatFixedCheckBodyExact

func MachineBeatFixedCheckBodyExact(value *MachineBeat) bool

MachineBeatFixedCheckBodyExact is MachineBeatFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func MachineBeatFixedClamp

func MachineBeatFixedClamp(value *MachineBeat, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func MachineBeatFixedClampBody

func MachineBeatFixedClampBody(value *MachineBeat, clamped *int32)

MachineBeat's read-side bounds.

func MachineBeatFixedLeaves

func MachineBeatFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func MachineBeatFixedLoad

func MachineBeatFixedLoad(values []MachineBeat, data []byte, plan []TableFixedEntry, report *TableReport) int64

func MachineBeatFixedMeasure

func MachineBeatFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func MachineBeatFixedSave

func MachineBeatFixedSave(values []MachineBeat, buffer []byte) int64

MachineBeatFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func MachineBeatFixedSaveReason

func MachineBeatFixedSaveReason(values []MachineBeat, buffer []byte) (int64, error)

func MachineBeatFixedWriteBody

func MachineBeatFixedWriteBody(b []byte, value *MachineBeat)

func MachineBeatFromJson

func MachineBeatFromJson(value *MachineBeat, text []byte, report *TableReport) bool

MachineBeatFromJson fills one MachineBeat 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 MachineBeatLoad

func MachineBeatLoad(value *MachineBeat, data []byte, report *TableReport) bool

MachineBeat also carries the FIXED form (form 3): MachineBeatFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func MachineBeatLoadBody

func MachineBeatLoadBody(r *TableReader, value *MachineBeat) bool

func MachineBeatLoadMessageBody

func MachineBeatLoadMessageBody(r *TableMessageReader, value *MachineBeat) bool

func MachineBeatLoadMessages

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

func MachineBeatMeasure

func MachineBeatMeasure(value *MachineBeat) int64

func MachineBeatMeasureBody

func MachineBeatMeasureBody(value *MachineBeat, ids *TableIds) int64

func MachineBeatMeasureMessages

func MachineBeatMeasureMessages(values []*MachineBeat, report *TableReport) int64

func MachineBeatMeasureReason

func MachineBeatMeasureReason(value *MachineBeat) (int64, error)

func MachineBeatOpen

func MachineBeatOpen(cook *MachineBeatCook, base unsafe.Pointer, length int64) bool

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

func MachineBeatReset

func MachineBeatReset(value *MachineBeat)

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

func MachineBeatSave

func MachineBeatSave(value *MachineBeat, buffer []byte) int64

func MachineBeatSaveBody

func MachineBeatSaveBody(w *TableWriter, value *MachineBeat) bool

func MachineBeatSaveMessageBody

func MachineBeatSaveMessageBody(w *TableMessageWriter, value *MachineBeat) bool

func MachineBeatSaveMessages

func MachineBeatSaveMessages(values []*MachineBeat, buffer []byte, report *TableReport) int64

func MachineBeatSaveText

func MachineBeatSaveText(value *MachineBeat) (string, error)

MachineBeatSaveText returns the base64 of MachineBeat'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 MachineBeatToJson

func MachineBeatToJson(value *MachineBeat, buffer []byte) int64

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

func MachineBeatToJsonMeasure

func MachineBeatToJsonMeasure(value *MachineBeat) int64

MachineBeatToJsonMeasure is the exact size of MachineBeat's JSON text, writing nothing.

func MachineViewBlockBegin

func MachineViewBlockBegin(b *MachineViewBlock, s *MachineViewBlockStorage, c MachineViewCounts, refusal *TableBlockRefusal) bool

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

func MachineViewBlockBytes

func MachineViewBlockBytes(b *MachineViewBlock) int64

func MachineViewBlockOpen

func MachineViewBlockOpen(block *MachineViewBlock, base unsafe.Pointer, bytes int64) bool

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

func MachineViewCookFrom

func MachineViewCookFrom(value *MachineView, buffer []byte, order TableByteOrder) bool

func MachineViewCookMeasure

func MachineViewCookMeasure(value *MachineView) int64

func MachineViewCookMeasureReason

func MachineViewCookMeasureReason(value *MachineView) (int64, error)

func MachineViewFixedCheckBody

func MachineViewFixedCheckBody(value *MachineView) bool

MachineView's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func MachineViewFixedCheckBodyExact

func MachineViewFixedCheckBodyExact(value *MachineView) bool

MachineViewFixedCheckBodyExact is MachineViewFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func MachineViewFixedClamp

func MachineViewFixedClamp(value *MachineView, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func MachineViewFixedClampBody

func MachineViewFixedClampBody(value *MachineView, clamped *int32)

MachineView's read-side bounds.

func MachineViewFixedLeaves

func MachineViewFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func MachineViewFixedLoad

func MachineViewFixedLoad(values []MachineView, data []byte, plan []TableFixedEntry, report *TableReport) int64

func MachineViewFixedMeasure

func MachineViewFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func MachineViewFixedSave

func MachineViewFixedSave(values []MachineView, buffer []byte) int64

MachineViewFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func MachineViewFixedSaveReason

func MachineViewFixedSaveReason(values []MachineView, buffer []byte) (int64, error)

func MachineViewFixedWriteBody

func MachineViewFixedWriteBody(b []byte, value *MachineView)

func MachineViewFromJson

func MachineViewFromJson(value *MachineView, text []byte, report *TableReport) bool

MachineViewFromJson fills one MachineView 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 MachineViewLoad

func MachineViewLoad(value *MachineView, data []byte, report *TableReport) bool

MachineView also carries the FIXED form (form 3): MachineViewFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func MachineViewLoadBody

func MachineViewLoadBody(r *TableReader, value *MachineView) bool

func MachineViewLoadMessageBody

func MachineViewLoadMessageBody(r *TableMessageReader, value *MachineView) bool

func MachineViewLoadMessages

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

func MachineViewMeasure

func MachineViewMeasure(value *MachineView) int64

func MachineViewMeasureBody

func MachineViewMeasureBody(value *MachineView, ids *TableIds) int64

func MachineViewMeasureMessages

func MachineViewMeasureMessages(values []*MachineView, report *TableReport) int64

func MachineViewMeasureReason

func MachineViewMeasureReason(value *MachineView) (int64, error)

func MachineViewOpen

func MachineViewOpen(cook *MachineViewCook, base unsafe.Pointer, length int64) bool

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

func MachineViewReset

func MachineViewReset(value *MachineView)

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

func MachineViewSave

func MachineViewSave(value *MachineView, buffer []byte) int64

func MachineViewSaveBody

func MachineViewSaveBody(w *TableWriter, value *MachineView) bool

func MachineViewSaveMessageBody

func MachineViewSaveMessageBody(w *TableMessageWriter, value *MachineView) bool

func MachineViewSaveMessages

func MachineViewSaveMessages(values []*MachineView, buffer []byte, report *TableReport) int64

func MachineViewSaveText

func MachineViewSaveText(value *MachineView) (string, error)

MachineViewSaveText returns the base64 of MachineView'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 MachineViewToJson

func MachineViewToJson(value *MachineView, buffer []byte) int64

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

func MachineViewToJsonMeasure

func MachineViewToJsonMeasure(value *MachineView) int64

MachineViewToJsonMeasure is the exact size of MachineView's JSON text, writing nothing.

func MemberBeatBlockBegin

func MemberBeatBlockBegin(b *MemberBeatBlock, s *MemberBeatBlockStorage, c MemberBeatCounts, refusal *TableBlockRefusal) bool

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

func MemberBeatBlockBytes

func MemberBeatBlockBytes(b *MemberBeatBlock) int64

func MemberBeatBlockOpen

func MemberBeatBlockOpen(block *MemberBeatBlock, base unsafe.Pointer, bytes int64) bool

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

func MemberBeatCookFrom

func MemberBeatCookFrom(value *MemberBeat, buffer []byte, order TableByteOrder) bool

func MemberBeatCookMeasure

func MemberBeatCookMeasure(value *MemberBeat) int64

func MemberBeatCookMeasureReason

func MemberBeatCookMeasureReason(value *MemberBeat) (int64, error)

func MemberBeatFixedCheckBody

func MemberBeatFixedCheckBody(value *MemberBeat) bool

MemberBeat's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func MemberBeatFixedClamp

func MemberBeatFixedClamp(value *MemberBeat, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func MemberBeatFixedClampBody

func MemberBeatFixedClampBody(value *MemberBeat, clamped *int32)

MemberBeat's read-side bounds.

func MemberBeatFixedLeaves

func MemberBeatFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func MemberBeatFixedLoad

func MemberBeatFixedLoad(values []MemberBeat, data []byte, plan []TableFixedEntry, report *TableReport) int64

func MemberBeatFixedMeasure

func MemberBeatFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func MemberBeatFixedSave

func MemberBeatFixedSave(values []MemberBeat, buffer []byte) int64

MemberBeatFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func MemberBeatFixedSaveReason

func MemberBeatFixedSaveReason(values []MemberBeat, buffer []byte) (int64, error)

func MemberBeatFixedWriteBody

func MemberBeatFixedWriteBody(b []byte, value *MemberBeat)

func MemberBeatFromJson

func MemberBeatFromJson(value *MemberBeat, text []byte, report *TableReport) bool

MemberBeatFromJson fills one MemberBeat 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 MemberBeatLoad

func MemberBeatLoad(value *MemberBeat, data []byte, report *TableReport) bool

MemberBeat also carries the FIXED form (form 3): MemberBeatFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func MemberBeatLoadBody

func MemberBeatLoadBody(r *TableReader, value *MemberBeat) bool

func MemberBeatLoadMessageBody

func MemberBeatLoadMessageBody(r *TableMessageReader, value *MemberBeat) bool

func MemberBeatLoadMessages

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

func MemberBeatMeasure

func MemberBeatMeasure(value *MemberBeat) int64

func MemberBeatMeasureBody

func MemberBeatMeasureBody(value *MemberBeat, ids *TableIds) int64

func MemberBeatMeasureMessages

func MemberBeatMeasureMessages(values []*MemberBeat, report *TableReport) int64

func MemberBeatMeasureReason

func MemberBeatMeasureReason(value *MemberBeat) (int64, error)

func MemberBeatOpen

func MemberBeatOpen(cook *MemberBeatCook, base unsafe.Pointer, length int64) bool

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

func MemberBeatReset

func MemberBeatReset(value *MemberBeat)

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

func MemberBeatSave

func MemberBeatSave(value *MemberBeat, buffer []byte) int64

func MemberBeatSaveBody

func MemberBeatSaveBody(w *TableWriter, value *MemberBeat) bool

func MemberBeatSaveMessageBody

func MemberBeatSaveMessageBody(w *TableMessageWriter, value *MemberBeat) bool

func MemberBeatSaveMessages

func MemberBeatSaveMessages(values []*MemberBeat, buffer []byte, report *TableReport) int64

func MemberBeatSaveText

func MemberBeatSaveText(value *MemberBeat) (string, error)

MemberBeatSaveText returns the base64 of MemberBeat'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 MemberBeatToJson

func MemberBeatToJson(value *MemberBeat, buffer []byte) int64

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

func MemberBeatToJsonMeasure

func MemberBeatToJsonMeasure(value *MemberBeat) int64

MemberBeatToJsonMeasure is the exact size of MemberBeat's JSON text, writing nothing.

func RowFieldsBlockBegin

func RowFieldsBlockBegin(b *RowFieldsBlock, s *RowFieldsBlockStorage, c RowFieldsCounts, refusal *TableBlockRefusal) bool

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

func RowFieldsBlockBytes

func RowFieldsBlockBytes(b *RowFieldsBlock) int64

func RowFieldsBlockOpen

func RowFieldsBlockOpen(block *RowFieldsBlock, base unsafe.Pointer, bytes int64) bool

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

func RowFieldsCookFrom

func RowFieldsCookFrom(value *RowFields, buffer []byte, order TableByteOrder) bool

func RowFieldsCookMeasure

func RowFieldsCookMeasure(value *RowFields) int64

func RowFieldsCookMeasureReason

func RowFieldsCookMeasureReason(value *RowFields) (int64, error)

func RowFieldsFixedCheckBody

func RowFieldsFixedCheckBody(value *RowFields) bool

RowFields's write-side contract (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §3.1): false is TableRefuseInvalidValue.

func RowFieldsFixedCheckBodyExact

func RowFieldsFixedCheckBodyExact(value *RowFields) bool

RowFieldsFixedCheckBodyExact is RowFieldsFixedCheckBody with each string asked by tableFixedUtf8Ok: the answer for text with a byte at or past 0x80 (§3.1).

func RowFieldsFixedClamp

func RowFieldsFixedClamp(value *RowFields, report *TableReport)

THE READ-SIDE BOUNDS (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4): a ranged scalar's declared min and max, and an ORDINAL's set — a union tag past the arm count, an enum ordinal past the enum's top value. Straight-line, after the copy, over STORAGE, so the identity plan and a plan compiled from a stranger's layout are held to the same numbers by the same pass. Every clamp COUNTS. The pass walks LIVE elements only: a counted array's live count, not its slack; an optional's payload only when present; a union's set arm, not the others.

func RowFieldsFixedClampBody

func RowFieldsFixedClampBody(value *RowFields, clamped *int32)

RowFields's read-side bounds.

func RowFieldsFixedLeaves

func RowFieldsFixedLeaves(out []TableFixedEntry, links [][]TableFixedGuardLink, src, dst uint32) int

func RowFieldsFixedLoad

func RowFieldsFixedLoad(values []RowFields, data []byte, plan []TableFixedEntry, report *TableReport) int64

func RowFieldsFixedMeasure

func RowFieldsFixedMeasure(count int64) int64

A FILE: form byte, seven reserved zeros, the LAYOUT HASH at 8, body at 16, then the layout behind its u32 length, then the records to the end of it.

func RowFieldsFixedSave

func RowFieldsFixedSave(values []RowFields, buffer []byte) int64

RowFieldsFixedSave is the fixed form's writer: it returns the bytes written, or -1 for a buffer too short or a value outside its declared contract (§3.1); see FixedSaveReason.

func RowFieldsFixedSaveReason

func RowFieldsFixedSaveReason(values []RowFields, buffer []byte) (int64, error)

func RowFieldsFixedWriteBody

func RowFieldsFixedWriteBody(b []byte, value *RowFields)

func RowFieldsFromJson

func RowFieldsFromJson(value *RowFields, text []byte, report *TableReport) bool

RowFieldsFromJson fills one RowFields 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 RowFieldsLoad

func RowFieldsLoad(value *RowFields, data []byte, report *TableReport) bool

RowFields also carries the FIXED form (form 3): RowFieldsFixedLoad reads that one and names a form-1 file `previous_form`. This Load is the VARIABLE form's entry point and reads form 1, whether or not the table was DECLARED fixed (mas-bandwidth/schema docs/SPEC-TABLES.md §3.4, §15).

func RowFieldsLoadBody

func RowFieldsLoadBody(r *TableReader, value *RowFields) bool

func RowFieldsLoadMessageBody

func RowFieldsLoadMessageBody(r *TableMessageReader, value *RowFields) bool

func RowFieldsLoadMessages

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

func RowFieldsMeasure

func RowFieldsMeasure(value *RowFields) int64

func RowFieldsMeasureBody

func RowFieldsMeasureBody(value *RowFields, ids *TableIds) int64

func RowFieldsMeasureMessages

func RowFieldsMeasureMessages(values []*RowFields, report *TableReport) int64

func RowFieldsMeasureReason

func RowFieldsMeasureReason(value *RowFields) (int64, error)

func RowFieldsOpen

func RowFieldsOpen(cook *RowFieldsCook, base unsafe.Pointer, length int64) bool

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

func RowFieldsReset

func RowFieldsReset(value *RowFields)

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

func RowFieldsSave

func RowFieldsSave(value *RowFields, buffer []byte) int64

func RowFieldsSaveBody

func RowFieldsSaveBody(w *TableWriter, value *RowFields) bool

func RowFieldsSaveMessageBody

func RowFieldsSaveMessageBody(w *TableMessageWriter, value *RowFields) bool

func RowFieldsSaveMessages

func RowFieldsSaveMessages(values []*RowFields, buffer []byte, report *TableReport) int64

func RowFieldsSaveText

func RowFieldsSaveText(value *RowFields) (string, error)

RowFieldsSaveText returns the base64 of RowFields'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 RowFieldsToJson

func RowFieldsToJson(value *RowFields, buffer []byte) int64

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

func RowFieldsToJsonMeasure

func RowFieldsToJsonMeasure(value *RowFields) int64

RowFieldsToJsonMeasure is the exact size of RowFields's JSON text, writing nothing.

Types

type BenchBeat

type BenchBeat struct {
	Host           [128]byte // string(MaxName): max length, used length beside it
	HostLength     int32
	AtMs           int64
	Load1          [16]byte // string(16): max length, used length beside it
	Load1Length    int32
	Ncpu           [8]byte // string(8): max length, used length beside it
	NcpuLength     int32
	Cpu            [16]byte // string(16): max length, used length beside it
	CpuLength      int32
	Os             [32]byte // string(32): max length, used length beside it
	OsLength       int32
	Arch           [32]byte // string(32): max length, used length beside it
	ArchLength     int32
	MemoryGb       [16]byte // string(16): max length, used length beside it
	MemoryGbLength int32
}

The bench hash beside the member beat (pkg/config BeatKey, bench:<m>:beat, written by the bench that runs on the machine, read by nova-config): host, at (unix milliseconds), load1, ncpu, cpu, and os, arch and memory_gb when the beat carries them. A hash value is text; load1, ncpu, cpu and memory_gb keep the text the writer gave. BenchBeat — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by BenchBeatReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func BenchBeatLoadText

func BenchBeatLoadText(text string, report *TableReport) (*BenchBeat, error)

BenchBeatLoadText fills one BenchBeat 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 BenchBeatReadStrict

func BenchBeatReadStrict(wire []byte) (*BenchBeat, error)

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

type BenchBeatBlock

type BenchBeatBlock struct {
	Base       unsafe.Pointer            // the extent's base, 64-byte aligned
	Projection *BenchBeatBlockProjection // the projection, at offset 0
	Bytes      int64                     // the extent in use
}

BenchBeatBlock is BenchBeat'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 (*BenchBeatBlock) Open

func (block *BenchBeatBlock) 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 (*BenchBeatBlock) Type

func (b *BenchBeatBlock) 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 BenchBeatBlockProjection

type BenchBeatBlockProjection 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
	Host         [129]byte // string(128): max length, used length beside it

	HostLength int32
	AtMs       int64
	Load1      [17]byte // string(16): max length, used length beside it

	Load1Length int32
	Ncpu        [9]byte // string(8): max length, used length beside it

	NcpuLength int32
	Cpu        [17]byte // string(16): max length, used length beside it

	CpuLength int32
	Os        [33]byte // string(32): max length, used length beside it

	OsLength int32
	Arch     [33]byte // string(32): max length, used length beside it

	ArchLength int32
	MemoryGb   [17]byte // string(16): max length, used length beside it

	MemoryGbLength int32
	// contains filtered or unexported fields
}

BenchBeatBlockProjection — 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 BenchBeatRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type BenchBeatBlockStorage

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

BenchBeatBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*BenchBeatBlockStorage) Create

func (*BenchBeatBlockStorage) Destroy

func (s *BenchBeatBlockStorage) Destroy()

type BenchBeatCook

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

BenchBeatCook is BenchBeat'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 — BenchBeatOpen, BenchBeatAt — 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 (*BenchBeatCook) Open

func (cook *BenchBeatCook) 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 (BenchBeatCook) RegionAlignment

func (c BenchBeatCook) 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 (BenchBeatCook) Root

func (c BenchBeatCook) Root() *BenchBeatRow

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 (BenchBeatCook) RootAlign

func (c BenchBeatCook) RootAlign() int64

func (BenchBeatCook) RootSize

func (c BenchBeatCook) RootSize() int64

func (BenchBeatCook) Type

func (c BenchBeatCook) Type() *TableCookInfo

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

type BenchBeatCounts

type BenchBeatCounts struct {
}

BenchBeatCounts is gathered before Begin; clamping is the caller's policy.

type BenchBeatRow

type BenchBeatRow struct {
	Host [129]byte // string(128): buffer, used length beside it

	HostLength int32
	AtMs       int64
	Load1      [17]byte // string(16): buffer, used length beside it

	Load1Length int32
	Ncpu        [9]byte // string(8): buffer, used length beside it

	NcpuLength int32
	Cpu        [17]byte // string(16): buffer, used length beside it

	CpuLength int32
	Os        [33]byte // string(32): buffer, used length beside it

	OsLength int32
	Arch     [33]byte // string(32): buffer, used length beside it

	ArchLength int32
	MemoryGb   [17]byte // string(16): buffer, used length beside it

	MemoryGbLength int32
	// contains filtered or unexported fields
}

BenchBeatRow — 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 BenchBeatAt

func BenchBeatAt(slot *int64) *BenchBeatRow

BenchBeatAt 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 CanonicalWord

type CanonicalWord struct {
	Kind      ConfigKind
	FieldType FieldType
	Op        ChangeOp
	Singleton bool
}

The canonical words a kind and a field type and a write op are spelled with: the registry's vocabulary as one record (pkg/config Kinds, Type, Op). CanonicalWord — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by CanonicalWordReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func CanonicalWordLoadText

func CanonicalWordLoadText(text string, report *TableReport) (*CanonicalWord, error)

CanonicalWordLoadText fills one CanonicalWord 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 CanonicalWordReadStrict

func CanonicalWordReadStrict(wire []byte) (*CanonicalWord, error)

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

type CanonicalWordBlock

type CanonicalWordBlock struct {
	Base       unsafe.Pointer                // the extent's base, 64-byte aligned
	Projection *CanonicalWordBlockProjection // the projection, at offset 0
	Bytes      int64                         // the extent in use
}

CanonicalWordBlock is CanonicalWord'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 (*CanonicalWordBlock) Open

func (block *CanonicalWordBlock) 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 (*CanonicalWordBlock) Type

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 CanonicalWordBlockProjection

type CanonicalWordBlockProjection 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
	Kind         ConfigKind
	FieldType    FieldType
	Op           ChangeOp
	Singleton    bool
	// contains filtered or unexported fields
}

CanonicalWordBlockProjection — 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 CanonicalWordRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type CanonicalWordBlockStorage

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

CanonicalWordBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*CanonicalWordBlockStorage) Create

func (*CanonicalWordBlockStorage) Destroy

func (s *CanonicalWordBlockStorage) Destroy()

type CanonicalWordCook

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

CanonicalWordCook is CanonicalWord'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 — CanonicalWordOpen, CanonicalWordAt — 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 (*CanonicalWordCook) Open

func (cook *CanonicalWordCook) 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 (CanonicalWordCook) RegionAlignment

func (c CanonicalWordCook) 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 (CanonicalWordCook) Root

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

func (CanonicalWordCook) RootAlign

func (c CanonicalWordCook) RootAlign() int64

func (CanonicalWordCook) RootSize

func (c CanonicalWordCook) RootSize() int64

func (CanonicalWordCook) Type

func (c CanonicalWordCook) Type() *TableCookInfo

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

type CanonicalWordCounts

type CanonicalWordCounts struct {
}

CanonicalWordCounts is gathered before Begin; clamping is the caller's policy.

type CanonicalWordRow

type CanonicalWordRow struct {
	Kind      ConfigKind
	FieldType FieldType
	Op        ChangeOp
	Singleton bool
}

CanonicalWordRow — 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 CanonicalWordAt

func CanonicalWordAt(slot *int64) *CanonicalWordRow

CanonicalWordAt 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 ChangeOp

type ChangeOp uint8

The write a history row records (pkg/config OpAdd, OpSet, OpRemove). ChangeOp — None = 0 implicit, variants dense from 1, wire range [0, 3] (SPEC §4.2)

const (
	ChangeOpNone   ChangeOp = 0
	ChangeOpAdd    ChangeOp = 1
	ChangeOpSet    ChangeOp = 2
	ChangeOpRemove ChangeOp = 3
	ChangeOpCount  ChangeOp = 3 // the declared variant count (SPEC §4.2)
	ChangeOpMax    ChangeOp = 3 // the exported extent (SPEC §4.2)
)

func (ChangeOp) TableEnumId

func (value ChangeOp) TableEnumId() (uint64, bool)

TableEnumId: ChangeOp 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 (*ChangeOp) TableEnumValue

func (value *ChangeOp) TableEnumValue(id uint64) bool

TableEnumValue resolves a table-wire variant id to a ChangeOp, 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 ConfigChange

type ConfigChange struct {
	Id           int64
	Kind         ConfigKind
	Name         [128]byte // string(MaxName): max length, used length beside it
	NameLength   int32
	Op           ChangeOp
	HasBefore    bool
	HasAfter     bool
	Actor        [128]byte // string(MaxActor): max length, used length beside it
	ActorLength  int32
	Reason       [4608]byte // string(MaxReason): max length, used length beside it
	ReasonLength int32
	At           [32]byte // string(32): max length, used length beside it
	AtLength     int32
}

One history row (pkg/config Change, written pg.go record, read pg.go History): the write's kind, name and op, which sides of the change ride (an add has no before and a remove has no after: the has_ flags say which), who made it, why (the --reason, empty when none), and when (RFC 3339 UTC). The reason rides here, apart from the fields, as Change.Reason does. The before and the after are RowFields records that follow this header, the before first, as pg.go keeps them in two columns: two rows at the field bound do not fit one 65536 byte record, so each side is a record of its own. ConfigChange — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by ConfigChangeReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func ConfigChangeLoadText

func ConfigChangeLoadText(text string, report *TableReport) (*ConfigChange, error)

ConfigChangeLoadText fills one ConfigChange 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 ConfigChangeReadStrict

func ConfigChangeReadStrict(wire []byte) (*ConfigChange, error)

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

type ConfigChangeBlock

type ConfigChangeBlock struct {
	Base       unsafe.Pointer               // the extent's base, 64-byte aligned
	Projection *ConfigChangeBlockProjection // the projection, at offset 0
	Bytes      int64                        // the extent in use
}

ConfigChangeBlock is ConfigChange'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 (*ConfigChangeBlock) Open

func (block *ConfigChangeBlock) 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 (*ConfigChangeBlock) Type

func (b *ConfigChangeBlock) 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 ConfigChangeBlockProjection

type ConfigChangeBlockProjection 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
	Id           int64
	Kind         ConfigKind
	Name         [129]byte // string(128): max length, used length beside it

	NameLength  int32
	Op          ChangeOp
	HasBefore   bool
	HasAfter    bool
	Actor       [129]byte // string(128): max length, used length beside it
	ActorLength int32
	Reason      [4609]byte // string(4608): max length, used length beside it

	ReasonLength int32
	At           [33]byte // string(32): max length, used length beside it

	AtLength int32
	// contains filtered or unexported fields
}

ConfigChangeBlockProjection — 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 ConfigChangeRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type ConfigChangeBlockStorage

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

ConfigChangeBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*ConfigChangeBlockStorage) Create

func (*ConfigChangeBlockStorage) Destroy

func (s *ConfigChangeBlockStorage) Destroy()

type ConfigChangeCook

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

ConfigChangeCook is ConfigChange'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 — ConfigChangeOpen, ConfigChangeAt — 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 (*ConfigChangeCook) Open

func (cook *ConfigChangeCook) 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 (ConfigChangeCook) RegionAlignment

func (c ConfigChangeCook) 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 (ConfigChangeCook) Root

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

func (ConfigChangeCook) RootAlign

func (c ConfigChangeCook) RootAlign() int64

func (ConfigChangeCook) RootSize

func (c ConfigChangeCook) RootSize() int64

func (ConfigChangeCook) Type

func (c ConfigChangeCook) Type() *TableCookInfo

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

type ConfigChangeCounts

type ConfigChangeCounts struct {
}

ConfigChangeCounts is gathered before Begin; clamping is the caller's policy.

type ConfigChangeRow

type ConfigChangeRow struct {
	Id   int64
	Kind ConfigKind
	Name [129]byte // string(128): buffer, used length beside it

	NameLength  int32
	Op          ChangeOp
	HasBefore   bool
	HasAfter    bool
	Actor       [129]byte // string(128): buffer, used length beside it
	ActorLength int32
	Reason      [4609]byte // string(4608): buffer, used length beside it

	ReasonLength int32
	At           [33]byte // string(32): buffer, used length beside it

	AtLength int32
	// contains filtered or unexported fields
}

ConfigChangeRow — 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 ConfigChangeAt

func ConfigChangeAt(slot *int64) *ConfigChangeRow

ConfigChangeAt 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 ConfigKind

type ConfigKind uint8

The canonical kind words (pkg/config KindMachine to KindTier, in apply order). The members are the words with a leading capital, since a few words (int, enum, bool) are the schema language's own; the canonical word is the member's name in lower case. ConfigKind — None = 0 implicit, variants dense from 1, wire range [0, 8] (SPEC §4.2)

const (
	ConfigKindNone     ConfigKind = 0
	ConfigKindMachine  ConfigKind = 1
	ConfigKindFleet    ConfigKind = 2
	ConfigKindFriend   ConfigKind = 3
	ConfigKindSprint   ConfigKind = 4
	ConfigKindLoop     ConfigKind = 5
	ConfigKindProvider ConfigKind = 6
	ConfigKindRoute    ConfigKind = 7
	ConfigKindTier     ConfigKind = 8
	ConfigKindCount    ConfigKind = 8 // the declared variant count (SPEC §4.2)
	ConfigKindMax      ConfigKind = 8 // the exported extent (SPEC §4.2)
)

func (ConfigKind) TableEnumId

func (value ConfigKind) TableEnumId() (uint64, bool)

TableEnumId: ConfigKind 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 (*ConfigKind) TableEnumValue

func (value *ConfigKind) TableEnumValue(id uint64) bool

TableEnumValue resolves a table-wire variant id to a ConfigKind, 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 ConfigRow

type ConfigRow struct {
	Kind            ConfigKind
	Name            [128]byte // string(MaxName): max length, used length beside it
	NameLength      int32
	Fields          RowFields
	CreatedAt       [32]byte // string(32): max length, used length beside it
	CreatedAtLength int32
	UpdatedAt       [32]byte // string(32): max length, used length beside it
	UpdatedAtLength int32
}

One row of a kind (pkg/config Row): its name and its fields, and the two stamps, RFC 3339 UTC, empty for a row a store has not stamped. ConfigRow — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by ConfigRowReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func ConfigRowLoadText

func ConfigRowLoadText(text string, report *TableReport) (*ConfigRow, error)

ConfigRowLoadText fills one ConfigRow 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 ConfigRowReadStrict

func ConfigRowReadStrict(wire []byte) (*ConfigRow, error)

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

type ConfigRowBlock

type ConfigRowBlock struct {
	Base       unsafe.Pointer            // the extent's base, 64-byte aligned
	Projection *ConfigRowBlockProjection // the projection, at offset 0
	Bytes      int64                     // the extent in use
}

ConfigRowBlock is ConfigRow'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 (*ConfigRowBlock) Open

func (block *ConfigRowBlock) 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 (*ConfigRowBlock) Type

func (b *ConfigRowBlock) 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 ConfigRowBlockProjection

type ConfigRowBlockProjection 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
	Kind         ConfigKind
	Name         [129]byte // string(128): max length, used length beside it

	NameLength int32
	Fields     RowFieldsRow
	CreatedAt  [33]byte // string(32): max length, used length beside it

	CreatedAtLength int32
	UpdatedAt       [33]byte // string(32): max length, used length beside it

	UpdatedAtLength int32
	// contains filtered or unexported fields
}

ConfigRowBlockProjection — 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 ConfigRowRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type ConfigRowBlockStorage

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

ConfigRowBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*ConfigRowBlockStorage) Create

func (*ConfigRowBlockStorage) Destroy

func (s *ConfigRowBlockStorage) Destroy()

type ConfigRowCook

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

ConfigRowCook is ConfigRow'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 — ConfigRowOpen, ConfigRowAt — 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 (*ConfigRowCook) Open

func (cook *ConfigRowCook) 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 (ConfigRowCook) RegionAlignment

func (c ConfigRowCook) 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 (ConfigRowCook) Root

func (c ConfigRowCook) Root() *ConfigRowRow

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 (ConfigRowCook) RootAlign

func (c ConfigRowCook) RootAlign() int64

func (ConfigRowCook) RootSize

func (c ConfigRowCook) RootSize() int64

func (ConfigRowCook) Type

func (c ConfigRowCook) Type() *TableCookInfo

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

type ConfigRowCounts

type ConfigRowCounts struct {
}

ConfigRowCounts is gathered before Begin; clamping is the caller's policy.

type ConfigRowRow

type ConfigRowRow struct {
	Kind ConfigKind
	Name [129]byte // string(128): buffer, used length beside it

	NameLength int32
	Fields     RowFieldsRow
	CreatedAt  [33]byte // string(32): buffer, used length beside it

	CreatedAtLength int32
	UpdatedAt       [33]byte // string(32): buffer, used length beside it

	UpdatedAtLength int32
	// contains filtered or unexported fields
}

ConfigRowRow — 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 ConfigRowAt

func ConfigRowAt(slot *int64) *ConfigRowRow

ConfigRowAt 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 EnvName

type EnvName struct {
	Name       [128]byte // string(MaxEnvName): max length, used length beside it
	NameLength int32
}

A secret's environment variable name in a loop's keys list (letters, digits and underscores, not starting with a digit: pkg/config keyPattern). EnvName — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by EnvNameReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func EnvNameLoadText

func EnvNameLoadText(text string, report *TableReport) (*EnvName, error)

EnvNameLoadText fills one EnvName 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 EnvNameReadStrict

func EnvNameReadStrict(wire []byte) (*EnvName, error)

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

type EnvNameBlock

type EnvNameBlock struct {
	Base       unsafe.Pointer          // the extent's base, 64-byte aligned
	Projection *EnvNameBlockProjection // the projection, at offset 0
	Bytes      int64                   // the extent in use
}

EnvNameBlock is EnvName'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 (*EnvNameBlock) Open

func (block *EnvNameBlock) 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 (*EnvNameBlock) Type

func (b *EnvNameBlock) 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 EnvNameBlockProjection

type EnvNameBlockProjection 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
	Name         [129]byte // string(128): max length, used length beside it

	NameLength int32
	// contains filtered or unexported fields
}

EnvNameBlockProjection — 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 EnvNameRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type EnvNameBlockStorage

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

EnvNameBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*EnvNameBlockStorage) Create

func (*EnvNameBlockStorage) Destroy

func (s *EnvNameBlockStorage) Destroy()

type EnvNameCook

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

EnvNameCook is EnvName'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 — EnvNameOpen, EnvNameAt — 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 (*EnvNameCook) Open

func (cook *EnvNameCook) 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 (EnvNameCook) RegionAlignment

func (c EnvNameCook) 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 (EnvNameCook) Root

func (c EnvNameCook) Root() *EnvNameRow

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 (EnvNameCook) RootAlign

func (c EnvNameCook) RootAlign() int64

func (EnvNameCook) RootSize

func (c EnvNameCook) RootSize() int64

func (EnvNameCook) Type

func (c EnvNameCook) Type() *TableCookInfo

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

type EnvNameCounts

type EnvNameCounts struct {
}

EnvNameCounts is gathered before Begin; clamping is the caller's policy.

type EnvNameRow

type EnvNameRow struct {
	Name [129]byte // string(128): max length, used length beside it

	NameLength int32
	// contains filtered or unexported fields
}

EnvNameRow — a block row, or a record one nests by value. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func EnvNameAt

func EnvNameAt(slot *int64) *EnvNameRow

EnvNameAt 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 FieldPair

type FieldPair struct {
	Name        [32]byte // string(MaxFieldName): max length, used length beside it
	NameLength  int32
	Value       [2304]byte // string(MaxFieldValue): max length, used length beside it
	ValueLength int32
}

One field of a row: its name and its canonical text (ints as digits, lists sorted and comma joined, empty for an empty value). Values are text end to end (pkg/config Row), so the descriptor, not the row, knows the type. FieldPair — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by FieldPairReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func FieldPairLoadText

func FieldPairLoadText(text string, report *TableReport) (*FieldPair, error)

FieldPairLoadText fills one FieldPair 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 FieldPairReadStrict

func FieldPairReadStrict(wire []byte) (*FieldPair, error)

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

type FieldPairBlock

type FieldPairBlock struct {
	Base       unsafe.Pointer            // the extent's base, 64-byte aligned
	Projection *FieldPairBlockProjection // the projection, at offset 0
	Bytes      int64                     // the extent in use
}

FieldPairBlock is FieldPair'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 (*FieldPairBlock) Open

func (block *FieldPairBlock) 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 (*FieldPairBlock) Type

func (b *FieldPairBlock) 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 FieldPairBlockProjection

type FieldPairBlockProjection 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
	Name         [33]byte // string(32): max length, used length beside it

	NameLength int32
	Value      [2305]byte // string(2304): max length, used length beside it

	ValueLength int32
	// contains filtered or unexported fields
}

FieldPairBlockProjection — 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 FieldPairRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type FieldPairBlockStorage

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

FieldPairBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*FieldPairBlockStorage) Create

func (*FieldPairBlockStorage) Destroy

func (s *FieldPairBlockStorage) Destroy()

type FieldPairCook

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

FieldPairCook is FieldPair'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 — FieldPairOpen, FieldPairAt — 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 (*FieldPairCook) Open

func (cook *FieldPairCook) 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 (FieldPairCook) RegionAlignment

func (c FieldPairCook) 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 (FieldPairCook) Root

func (c FieldPairCook) Root() *FieldPairRow

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 (FieldPairCook) RootAlign

func (c FieldPairCook) RootAlign() int64

func (FieldPairCook) RootSize

func (c FieldPairCook) RootSize() int64

func (FieldPairCook) Type

func (c FieldPairCook) Type() *TableCookInfo

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

type FieldPairCounts

type FieldPairCounts struct {
}

FieldPairCounts is gathered before Begin; clamping is the caller's policy.

type FieldPairRow

type FieldPairRow struct {
	Name [33]byte // string(32): max length, used length beside it

	NameLength int32
	Value      [2305]byte // string(2304): max length, used length beside it

	ValueLength int32
	// contains filtered or unexported fields
}

FieldPairRow — a block row, or a record one nests by value. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func FieldPairAt

func FieldPairAt(slot *int64) *FieldPairRow

FieldPairAt 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 FieldType

type FieldType uint8

The canonical field type words (pkg/config Type: TypeText to TypeDecimal). FieldType — None = 0 implicit, variants dense from 1, wire range [0, 11] (SPEC §4.2)

const (
	FieldTypeNone    FieldType = 0
	FieldTypeText    FieldType = 1
	FieldTypeInt     FieldType = 2
	FieldTypeEnum    FieldType = 3
	FieldTypeList    FieldType = 4
	FieldTypeNames   FieldType = 5
	FieldTypeRef     FieldType = 6
	FieldTypeBool    FieldType = 7
	FieldTypeKeys    FieldType = 8
	FieldTypeArgv    FieldType = 9
	FieldTypeSeq     FieldType = 10
	FieldTypeDecimal FieldType = 11
	FieldTypeCount   FieldType = 11 // the declared variant count (SPEC §4.2)
	FieldTypeMax     FieldType = 11 // the exported extent (SPEC §4.2)
)

func (FieldType) TableEnumId

func (value FieldType) TableEnumId() (uint64, bool)

TableEnumId: FieldType 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 (*FieldType) TableEnumValue

func (value *FieldType) TableEnumValue(id uint64) bool

TableEnumValue resolves a table-wire variant id to a FieldType, 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 FileHeader

type FileHeader struct {
	Schema int32
}

The header of the file twin's state (pkg/config fileState, file.go): the store file holds this record, then the rows as ConfigRow records, then the history as ConfigChange records, in a fixed batch each. The file is bounded by MaxStoreFileBytes (16 MiB), read whole when it is opened. FileHeader — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by FileHeaderReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func FileHeaderLoadText

func FileHeaderLoadText(text string, report *TableReport) (*FileHeader, error)

FileHeaderLoadText fills one FileHeader 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 FileHeaderReadStrict

func FileHeaderReadStrict(wire []byte) (*FileHeader, error)

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

type FileHeaderBlock

type FileHeaderBlock struct {
	Base       unsafe.Pointer             // the extent's base, 64-byte aligned
	Projection *FileHeaderBlockProjection // the projection, at offset 0
	Bytes      int64                      // the extent in use
}

FileHeaderBlock is FileHeader'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 (*FileHeaderBlock) Open

func (block *FileHeaderBlock) 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 (*FileHeaderBlock) Type

func (b *FileHeaderBlock) 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 FileHeaderBlockProjection

type FileHeaderBlockProjection 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
	Schema       int32
	// contains filtered or unexported fields
}

FileHeaderBlockProjection — 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 FileHeaderRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type FileHeaderBlockStorage

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

FileHeaderBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*FileHeaderBlockStorage) Create

func (*FileHeaderBlockStorage) Destroy

func (s *FileHeaderBlockStorage) Destroy()

type FileHeaderCook

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

FileHeaderCook is FileHeader'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 — FileHeaderOpen, FileHeaderAt — 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 (*FileHeaderCook) Open

func (cook *FileHeaderCook) 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 (FileHeaderCook) RegionAlignment

func (c FileHeaderCook) 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 (FileHeaderCook) Root

func (c FileHeaderCook) Root() *FileHeaderRow

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 (FileHeaderCook) RootAlign

func (c FileHeaderCook) RootAlign() int64

func (FileHeaderCook) RootSize

func (c FileHeaderCook) RootSize() int64

func (FileHeaderCook) Type

func (c FileHeaderCook) Type() *TableCookInfo

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

type FileHeaderCounts

type FileHeaderCounts struct {
}

FileHeaderCounts is gathered before Begin; clamping is the caller's policy.

type FileHeaderRow

type FileHeaderRow struct {
	Schema int32
}

FileHeaderRow — 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 FileHeaderAt

func FileHeaderAt(slot *int64) *FileHeaderRow

FileHeaderAt 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 HostGroup

type HostGroup struct {
	Hosts      [48]HostName // used count beside it; count in [0, 48]
	HostsCount int32
}

A group of the inventory: its hosts, at most MaxHosts of them. HostGroup — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by HostGroupReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func HostGroupLoadText

func HostGroupLoadText(text string, report *TableReport) (*HostGroup, error)

HostGroupLoadText fills one HostGroup 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 HostGroupReadStrict

func HostGroupReadStrict(wire []byte) (*HostGroup, error)

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

type HostGroupBlock

type HostGroupBlock struct {
	Base       unsafe.Pointer            // the extent's base, 64-byte aligned
	Projection *HostGroupBlockProjection // the projection, at offset 0
	Bytes      int64                     // the extent in use
}

HostGroupBlock is HostGroup'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 (*HostGroupBlock) Hosts

Hosts is ITERATED, not indexed by hand: the accessor points at each row where it lies, at the pitch the INSTANCE gives, for the count the instance gives.

func (*HostGroupBlock) HostsMax

func (b *HostGroupBlock) HostsMax() int64

func (*HostGroupBlock) HostsProjectionOffset

func (b *HostGroupBlock) HostsProjectionOffset() int64

func (*HostGroupBlock) HostsSpan

func (b *HostGroupBlock) HostsSpan() []HostNameRow

HostsSpan is the CONTIGUOUS view, available because the pitch IS the element's size (§2.7), which is how the per-frame fast path is written.

func (*HostGroupBlock) HostsStride

func (b *HostGroupBlock) HostsStride() int64

---- block fill path: begin ---- HostsStride, HostsMax and HostsProjectionOffset are the constants this build asserts against. A consumer INDEXES with what it read from the instance, never with these (mas-bandwidth/schema docs/SPEC-TABLES.md §19.2). They are METHODS rather than package constants because §11 gives a language whose accessors are members exactly that latitude: a member claims nothing at file scope.

func (*HostGroupBlock) Open

func (block *HostGroupBlock) 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 (*HostGroupBlock) Type

func (b *HostGroupBlock) 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 HostGroupBlockProjection

type HostGroupBlockProjection 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
	Hosts        TableBlockTriple // [..48]HostName, laid out of line
}

HostGroupBlockProjection — 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 HostGroupRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type HostGroupBlockStorage

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

HostGroupBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*HostGroupBlockStorage) Create

func (*HostGroupBlockStorage) Destroy

func (s *HostGroupBlockStorage) Destroy()

type HostGroupCook

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

HostGroupCook is HostGroup'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 — HostGroupOpen, HostGroupAt — 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 (*HostGroupCook) Open

func (cook *HostGroupCook) 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 (HostGroupCook) RegionAlignment

func (c HostGroupCook) 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 (HostGroupCook) Root

func (c HostGroupCook) Root() *HostGroupRow

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 (HostGroupCook) RootAlign

func (c HostGroupCook) RootAlign() int64

func (HostGroupCook) RootSize

func (c HostGroupCook) RootSize() int64

func (HostGroupCook) Type

func (c HostGroupCook) Type() *TableCookInfo

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

type HostGroupCounts

type HostGroupCounts struct {
	Hosts int32
}

HostGroupCounts is gathered before Begin; clamping is the caller's policy.

type HostGroupRow

type HostGroupRow struct {
	Hosts      [48]HostNameRow
	HostsCount int32
}

HostGroupRow — a block row, or a record one nests by value. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func HostGroupAt

func HostGroupAt(slot *int64) *HostGroupRow

HostGroupAt 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 HostName

type HostName struct {
	Name       [128]byte // string(MaxName): max length, used length beside it
	NameLength int32
}

A host name in a group (the shape of a row name, at most MaxName bytes). An array of strings is a bounded array of this wrapper (the compiler's rule: an array of string(N) is not supported). HostName — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by HostNameReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func HostNameLoadText

func HostNameLoadText(text string, report *TableReport) (*HostName, error)

HostNameLoadText fills one HostName 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 HostNameReadStrict

func HostNameReadStrict(wire []byte) (*HostName, error)

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

type HostNameBlock

type HostNameBlock struct {
	Base       unsafe.Pointer           // the extent's base, 64-byte aligned
	Projection *HostNameBlockProjection // the projection, at offset 0
	Bytes      int64                    // the extent in use
}

HostNameBlock is HostName'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 (*HostNameBlock) Open

func (block *HostNameBlock) 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 (*HostNameBlock) Type

func (b *HostNameBlock) 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 HostNameBlockProjection

type HostNameBlockProjection 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
	Name         [129]byte // string(128): max length, used length beside it

	NameLength int32
	// contains filtered or unexported fields
}

HostNameBlockProjection — 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 HostNameRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type HostNameBlockStorage

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

HostNameBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*HostNameBlockStorage) Create

func (*HostNameBlockStorage) Destroy

func (s *HostNameBlockStorage) Destroy()

type HostNameCook

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

HostNameCook is HostName'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 — HostNameOpen, HostNameAt — 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 (*HostNameCook) Open

func (cook *HostNameCook) 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 (HostNameCook) RegionAlignment

func (c HostNameCook) 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 (HostNameCook) Root

func (c HostNameCook) Root() *HostNameRow

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 (HostNameCook) RootAlign

func (c HostNameCook) RootAlign() int64

func (HostNameCook) RootSize

func (c HostNameCook) RootSize() int64

func (HostNameCook) Type

func (c HostNameCook) Type() *TableCookInfo

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

type HostNameCounts

type HostNameCounts struct {
}

HostNameCounts is gathered before Begin; clamping is the caller's policy.

type HostNameRow

type HostNameRow struct {
	Name [129]byte // string(128): max length, used length beside it

	NameLength int32
	// contains filtered or unexported fields
}

HostNameRow — a block row, or a record one nests by value. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func HostNameAt

func HostNameAt(slot *int64) *HostNameRow

HostNameAt 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 HostView

type HostView struct {
	AnsibleHost         [128]byte // string(MaxName): max length, used length beside it
	AnsibleHostLength   int32
	Kind                ConfigKind
	Slots               int32
	SlotsCapacity       int32
	Runners             int32
	SlotsShare          int32
	SlotsSharePresent   bool // ?int32: absent until set
	Cores               int32
	CoresPresent        bool     // ?int32: absent until set
	BenchOs             [32]byte // string(32): max length, used length beside it
	BenchOsLength       int32
	NovaArch            [32]byte // string(32): max length, used length beside it
	NovaArchLength      int32
	NovaTla             bool
	RegistrySeat        [2304]byte // string(MaxFieldValue): max length, used length beside it
	RegistrySeatLength  int32
	RegistryRoles       [64]byte // string(64): max length, used length beside it
	RegistryRolesLength int32
	AnsibleUser         [2304]byte // string(MaxFieldValue): max length, used length beside it
	AnsibleUserLength   int32
	NovaSeat            [2304]byte // string(MaxFieldValue): max length, used length beside it
	NovaSeatLength      int32
	NovaRedisAddr       [2304]byte // string(MaxFieldValue): max length, used length beside it
	NovaRedisAddrLength int32
	NovaBusAddr         [2304]byte // string(MaxFieldValue): max length, used length beside it
	NovaBusAddrLength   int32
	NovaRedisPort       int32
	NovaPgDsn           [2304]byte // string(MaxFieldValue): max length, used length beside it
	NovaPgDsnLength     int32
	Local               bool
}

One host's variables in the inventory (pkg/config BuildInventory, the hostvars map): the facts the machine row and its beat give, the fleet's store, bus and port, and whether the host is the machine the command runs on. An empty value is left out of the Ansible JSON; here it is the empty string, and the optionals are the facts that may be absent: slots_share (the width), cores, and the beat's os and arch. HostView — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by HostViewReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func HostViewLoadText

func HostViewLoadText(text string, report *TableReport) (*HostView, error)

HostViewLoadText fills one HostView 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 HostViewReadStrict

func HostViewReadStrict(wire []byte) (*HostView, error)

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

type HostViewBlock

type HostViewBlock struct {
	Base       unsafe.Pointer           // the extent's base, 64-byte aligned
	Projection *HostViewBlockProjection // the projection, at offset 0
	Bytes      int64                    // the extent in use
}

HostViewBlock is HostView'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 (*HostViewBlock) Open

func (block *HostViewBlock) 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 (*HostViewBlock) Type

func (b *HostViewBlock) 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 HostViewBlockProjection

type HostViewBlockProjection 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
	AnsibleHost  [129]byte // string(128): max length, used length beside it

	AnsibleHostLength int32
	Kind              ConfigKind

	Slots             int32
	SlotsCapacity     int32
	Runners           int32
	SlotsShare        int32
	SlotsSharePresent bool // ?: one byte, in Go's model as in C++

	Cores        int32
	CoresPresent bool     // ?: one byte, in Go's model as in C++
	BenchOs      [33]byte // string(32): max length, used length beside it

	BenchOsLength int32
	NovaArch      [33]byte // string(32): max length, used length beside it

	NovaArchLength int32
	NovaTla        bool
	RegistrySeat   [2305]byte // string(2304): max length, used length beside it

	RegistrySeatLength int32
	RegistryRoles      [65]byte // string(64): max length, used length beside it

	RegistryRolesLength int32
	AnsibleUser         [2305]byte // string(2304): max length, used length beside it

	AnsibleUserLength int32
	NovaSeat          [2305]byte // string(2304): max length, used length beside it

	NovaSeatLength int32
	NovaRedisAddr  [2305]byte // string(2304): max length, used length beside it

	NovaRedisAddrLength int32
	NovaBusAddr         [2305]byte // string(2304): max length, used length beside it

	NovaBusAddrLength int32
	NovaRedisPort     int32
	NovaPgDsn         [2305]byte // string(2304): max length, used length beside it

	NovaPgDsnLength int32
	Local           bool
	// contains filtered or unexported fields
}

HostViewBlockProjection — 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 HostViewRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type HostViewBlockStorage

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

HostViewBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*HostViewBlockStorage) Create

func (*HostViewBlockStorage) Destroy

func (s *HostViewBlockStorage) Destroy()

type HostViewCook

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

HostViewCook is HostView'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 — HostViewOpen, HostViewAt — 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 (*HostViewCook) Open

func (cook *HostViewCook) 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 (HostViewCook) RegionAlignment

func (c HostViewCook) 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 (HostViewCook) Root

func (c HostViewCook) Root() *HostViewRow

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 (HostViewCook) RootAlign

func (c HostViewCook) RootAlign() int64

func (HostViewCook) RootSize

func (c HostViewCook) RootSize() int64

func (HostViewCook) Type

func (c HostViewCook) Type() *TableCookInfo

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

type HostViewCounts

type HostViewCounts struct {
}

HostViewCounts is gathered before Begin; clamping is the caller's policy.

type HostViewRow

type HostViewRow struct {
	AnsibleHost [129]byte // string(128): buffer, used length beside it

	AnsibleHostLength int32
	Kind              ConfigKind

	Slots             int32
	SlotsCapacity     int32
	Runners           int32
	SlotsShare        int32
	SlotsSharePresent bool // ?: one byte, in Go's model as in C++

	Cores        int32
	CoresPresent bool     // ?: one byte, in Go's model as in C++
	BenchOs      [33]byte // string(32): buffer, used length beside it

	BenchOsLength int32
	NovaArch      [33]byte // string(32): buffer, used length beside it

	NovaArchLength int32
	NovaTla        bool
	RegistrySeat   [2305]byte // string(2304): buffer, used length beside it

	RegistrySeatLength int32
	RegistryRoles      [65]byte // string(64): buffer, used length beside it

	RegistryRolesLength int32
	AnsibleUser         [2305]byte // string(2304): buffer, used length beside it

	AnsibleUserLength int32
	NovaSeat          [2305]byte // string(2304): buffer, used length beside it

	NovaSeatLength int32
	NovaRedisAddr  [2305]byte // string(2304): buffer, used length beside it

	NovaRedisAddrLength int32
	NovaBusAddr         [2305]byte // string(2304): buffer, used length beside it

	NovaBusAddrLength int32
	NovaRedisPort     int32
	NovaPgDsn         [2305]byte // string(2304): buffer, used length beside it

	NovaPgDsnLength int32
	Local           bool
	// contains filtered or unexported fields
}

HostViewRow — 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 HostViewAt

func HostViewAt(slot *int64) *HostViewRow

HostViewAt 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 Inventory

type Inventory struct {
	All             HostGroup
	Adopt           HostGroup
	Benches         HostGroup
	Coordinator     HostGroup
	Store           HostGroup
	StoreDeployer   HostGroup
	Runners         HostGroup
	Tla             HostGroup
	NovaStore       [2304]byte // string(MaxFieldValue): max length, used length beside it
	NovaStoreLength int32
	Revs            [8]KindRev // used count beside it; count in [0, 8]
	RevsCount       int32
}

The inventory (pkg/config AnsibleInventory): the groups the plays select, the store host and the revisions of the applied kinds (nova_config_rev). Inventory — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by InventoryReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func InventoryLoadText

func InventoryLoadText(text string, report *TableReport) (*Inventory, error)

InventoryLoadText fills one Inventory 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 InventoryReadStrict

func InventoryReadStrict(wire []byte) (*Inventory, error)

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

type InventoryBlock

type InventoryBlock struct {
	Base       unsafe.Pointer            // the extent's base, 64-byte aligned
	Projection *InventoryBlockProjection // the projection, at offset 0
	Bytes      int64                     // the extent in use
}

InventoryBlock is Inventory'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 (*InventoryBlock) Open

func (block *InventoryBlock) 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 (*InventoryBlock) Revs

Revs is ITERATED, not indexed by hand: the accessor points at each row where it lies, at the pitch the INSTANCE gives, for the count the instance gives.

func (*InventoryBlock) RevsMax

func (b *InventoryBlock) RevsMax() int64

func (*InventoryBlock) RevsProjectionOffset

func (b *InventoryBlock) RevsProjectionOffset() int64

func (*InventoryBlock) RevsSpan

func (b *InventoryBlock) RevsSpan() []KindRevRow

RevsSpan is the CONTIGUOUS view, available because the pitch IS the element's size (§2.7), which is how the per-frame fast path is written.

func (*InventoryBlock) RevsStride

func (b *InventoryBlock) RevsStride() int64

---- block fill path: begin ---- RevsStride, RevsMax and RevsProjectionOffset are the constants this build asserts against. A consumer INDEXES with what it read from the instance, never with these (mas-bandwidth/schema docs/SPEC-TABLES.md §19.2). They are METHODS rather than package constants because §11 gives a language whose accessors are members exactly that latitude: a member claims nothing at file scope.

func (*InventoryBlock) Type

func (b *InventoryBlock) 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 InventoryBlockProjection

type InventoryBlockProjection 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
	All           HostGroupRow
	Adopt         HostGroupRow
	Benches       HostGroupRow
	Coordinator   HostGroupRow
	Store         HostGroupRow
	StoreDeployer HostGroupRow
	Runners       HostGroupRow
	Tla           HostGroupRow
	NovaStore     [2305]byte // string(2304): max length, used length beside it

	NovaStoreLength int32
	Revs            TableBlockTriple // [..8]KindRev, laid out of line
	// contains filtered or unexported fields
}

InventoryBlockProjection — 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 InventoryRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type InventoryBlockStorage

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

InventoryBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*InventoryBlockStorage) Create

func (*InventoryBlockStorage) Destroy

func (s *InventoryBlockStorage) Destroy()

type InventoryCook

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

InventoryCook is Inventory'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 — InventoryOpen, InventoryAt — 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 (*InventoryCook) Open

func (cook *InventoryCook) 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 (InventoryCook) RegionAlignment

func (c InventoryCook) 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 (InventoryCook) Root

func (c InventoryCook) Root() *InventoryRow

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 (InventoryCook) RootAlign

func (c InventoryCook) RootAlign() int64

func (InventoryCook) RootSize

func (c InventoryCook) RootSize() int64

func (InventoryCook) Type

func (c InventoryCook) Type() *TableCookInfo

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

type InventoryCounts

type InventoryCounts struct {
	Revs int32
}

InventoryCounts is gathered before Begin; clamping is the caller's policy.

type InventoryLoop

type InventoryLoop struct {
	Machine       [128]byte // string(MaxName): max length, used length beside it
	MachineLength int32
	Name          [128]byte // string(MaxName): max length, used length beside it
	NameLength    int32
	Argv          [4096]byte // string(MaxArgvBytes): max length, used length beside it
	ArgvLength    int32
	Seat          [2304]byte // string(MaxFieldValue): max length, used length beside it
	SeatLength    int32
	Keys          [32]EnvName // used count beside it; count in [0, 32]
	KeysCount     int32
	Every         int32
	Keepalive     bool
	Enabled       bool
	Log           [2304]byte // string(MaxFieldValue): max length, used length beside it
	LogLength     int32
}

One loop as the inventory carries it (pkg/config InventoryLoop, written inventory.go, read parseLoop): its machine, name, the argv in the loop view's canonical JSON text (a list of at most 64 strings in at most MaxArgvBytes bytes; the view carries it as that text), the seat, the secret names (a sorted list, only with a seat), every (seconds, 0 for a kept-alive loop), keepalive, enabled and the log path. InventoryLoop — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by InventoryLoopReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func InventoryLoopLoadText

func InventoryLoopLoadText(text string, report *TableReport) (*InventoryLoop, error)

InventoryLoopLoadText fills one InventoryLoop 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 InventoryLoopReadStrict

func InventoryLoopReadStrict(wire []byte) (*InventoryLoop, error)

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

type InventoryLoopBlock

type InventoryLoopBlock struct {
	Base       unsafe.Pointer                // the extent's base, 64-byte aligned
	Projection *InventoryLoopBlockProjection // the projection, at offset 0
	Bytes      int64                         // the extent in use
}

InventoryLoopBlock is InventoryLoop'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 (*InventoryLoopBlock) Keys

Keys is ITERATED, not indexed by hand: the accessor points at each row where it lies, at the pitch the INSTANCE gives, for the count the instance gives.

func (*InventoryLoopBlock) KeysMax

func (b *InventoryLoopBlock) KeysMax() int64

func (*InventoryLoopBlock) KeysProjectionOffset

func (b *InventoryLoopBlock) KeysProjectionOffset() int64

func (*InventoryLoopBlock) KeysSpan

func (b *InventoryLoopBlock) KeysSpan() []EnvNameRow

KeysSpan is the CONTIGUOUS view, available because the pitch IS the element's size (§2.7), which is how the per-frame fast path is written.

func (*InventoryLoopBlock) KeysStride

func (b *InventoryLoopBlock) KeysStride() int64

---- block fill path: begin ---- KeysStride, KeysMax and KeysProjectionOffset are the constants this build asserts against. A consumer INDEXES with what it read from the instance, never with these (mas-bandwidth/schema docs/SPEC-TABLES.md §19.2). They are METHODS rather than package constants because §11 gives a language whose accessors are members exactly that latitude: a member claims nothing at file scope.

func (*InventoryLoopBlock) Open

func (block *InventoryLoopBlock) 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 (*InventoryLoopBlock) Type

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 InventoryLoopBlockProjection

type InventoryLoopBlockProjection 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
	Machine      [129]byte // string(128): max length, used length beside it

	MachineLength int32
	Name          [129]byte // string(128): max length, used length beside it

	NameLength int32
	Argv       [4097]byte // string(4096): max length, used length beside it

	ArgvLength int32
	Seat       [2305]byte // string(2304): max length, used length beside it

	SeatLength int32
	Keys       TableBlockTriple // [..32]EnvName, laid out of line
	Every      int32
	Keepalive  bool
	Enabled    bool
	Log        [2305]byte // string(2304): max length, used length beside it

	LogLength int32
	// contains filtered or unexported fields
}

InventoryLoopBlockProjection — 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 InventoryLoopRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type InventoryLoopBlockStorage

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

InventoryLoopBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*InventoryLoopBlockStorage) Create

func (*InventoryLoopBlockStorage) Destroy

func (s *InventoryLoopBlockStorage) Destroy()

type InventoryLoopCook

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

InventoryLoopCook is InventoryLoop'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 — InventoryLoopOpen, InventoryLoopAt — 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 (*InventoryLoopCook) Open

func (cook *InventoryLoopCook) 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 (InventoryLoopCook) RegionAlignment

func (c InventoryLoopCook) 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 (InventoryLoopCook) Root

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

func (InventoryLoopCook) RootAlign

func (c InventoryLoopCook) RootAlign() int64

func (InventoryLoopCook) RootSize

func (c InventoryLoopCook) RootSize() int64

func (InventoryLoopCook) Type

func (c InventoryLoopCook) Type() *TableCookInfo

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

type InventoryLoopCounts

type InventoryLoopCounts struct {
	Keys int32
}

InventoryLoopCounts is gathered before Begin; clamping is the caller's policy.

type InventoryLoopRow

type InventoryLoopRow struct {
	Machine [129]byte // string(128): buffer, used length beside it

	MachineLength int32
	Name          [129]byte // string(128): buffer, used length beside it

	NameLength int32
	Argv       [4097]byte // string(4096): buffer, used length beside it

	ArgvLength int32
	Seat       [2305]byte // string(2304): buffer, used length beside it

	SeatLength int32
	Keys       [32]EnvNameRow
	KeysCount  int32
	Every      int32
	Keepalive  bool
	Enabled    bool
	Log        [2305]byte // string(2304): buffer, used length beside it

	LogLength int32
	// contains filtered or unexported fields
}

InventoryLoopRow — 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 InventoryLoopAt

func InventoryLoopAt(slot *int64) *InventoryLoopRow

InventoryLoopAt 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 InventoryRow

type InventoryRow struct {
	All           HostGroupRow
	Adopt         HostGroupRow
	Benches       HostGroupRow
	Coordinator   HostGroupRow
	Store         HostGroupRow
	StoreDeployer HostGroupRow
	Runners       HostGroupRow
	Tla           HostGroupRow
	NovaStore     [2305]byte // string(2304): buffer, used length beside it

	NovaStoreLength int32
	Revs            [8]KindRevRow
	RevsCount       int32
	// contains filtered or unexported fields
}

InventoryRow — 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 InventoryAt

func InventoryAt(slot *int64) *InventoryRow

InventoryAt 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 KindRev

type KindRev struct {
	Kind ConfigKind
	Rev  int64
}

The revision config:decl holds for a kind (pkg/config Snapshot.Revs). KindRev — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by KindRevReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func KindRevLoadText

func KindRevLoadText(text string, report *TableReport) (*KindRev, error)

KindRevLoadText fills one KindRev 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 KindRevReadStrict

func KindRevReadStrict(wire []byte) (*KindRev, error)

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

type KindRevBlock

type KindRevBlock struct {
	Base       unsafe.Pointer          // the extent's base, 64-byte aligned
	Projection *KindRevBlockProjection // the projection, at offset 0
	Bytes      int64                   // the extent in use
}

KindRevBlock is KindRev'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 (*KindRevBlock) Open

func (block *KindRevBlock) 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 (*KindRevBlock) Type

func (b *KindRevBlock) 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 KindRevBlockProjection

type KindRevBlockProjection 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
	Kind         ConfigKind

	Rev int64
	// contains filtered or unexported fields
}

KindRevBlockProjection — 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 KindRevRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type KindRevBlockStorage

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

KindRevBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*KindRevBlockStorage) Create

func (*KindRevBlockStorage) Destroy

func (s *KindRevBlockStorage) Destroy()

type KindRevCook

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

KindRevCook is KindRev'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 — KindRevOpen, KindRevAt — 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 (*KindRevCook) Open

func (cook *KindRevCook) 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 (KindRevCook) RegionAlignment

func (c KindRevCook) 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 (KindRevCook) Root

func (c KindRevCook) Root() *KindRevRow

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 (KindRevCook) RootAlign

func (c KindRevCook) RootAlign() int64

func (KindRevCook) RootSize

func (c KindRevCook) RootSize() int64

func (KindRevCook) Type

func (c KindRevCook) Type() *TableCookInfo

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

type KindRevCounts

type KindRevCounts struct {
}

KindRevCounts is gathered before Begin; clamping is the caller's policy.

type KindRevRow

type KindRevRow struct {
	Kind ConfigKind

	Rev int64
	// contains filtered or unexported fields
}

KindRevRow — a block row, or a record one nests by value. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func KindRevAt

func KindRevAt(slot *int64) *KindRevRow

KindRevAt 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 MachineBeat

type MachineBeat struct {
	Os             [32]byte // string(32): max length, used length beside it
	OsLength       int32
	Arch           [32]byte // string(32): max length, used length beside it
	ArchLength     int32
	Cores          [8]byte // string(8): max length, used length beside it
	CoresLength    int32
	MemoryGb       [16]byte // string(16): max length, used length beside it
	MemoryGbLength int32
	At             [32]byte // string(32): max length, used length beside it
	AtLength       int32
}

The beat a machine reported last, merged from the member beat and the bench hash (pkg/config Beat, mergeBeat): os, arch, cores (the member's when it has any, else the hash's ncpu), memory_gb and at (RFC 3339 UTC). Empty is a fact the beat does not carry. MachineBeat — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by MachineBeatReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func MachineBeatLoadText

func MachineBeatLoadText(text string, report *TableReport) (*MachineBeat, error)

MachineBeatLoadText fills one MachineBeat 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 MachineBeatReadStrict

func MachineBeatReadStrict(wire []byte) (*MachineBeat, error)

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

type MachineBeatBlock

type MachineBeatBlock struct {
	Base       unsafe.Pointer              // the extent's base, 64-byte aligned
	Projection *MachineBeatBlockProjection // the projection, at offset 0
	Bytes      int64                       // the extent in use
}

MachineBeatBlock is MachineBeat'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 (*MachineBeatBlock) Open

func (block *MachineBeatBlock) 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 (*MachineBeatBlock) Type

func (b *MachineBeatBlock) 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 MachineBeatBlockProjection

type MachineBeatBlockProjection 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
	Os           [33]byte // string(32): max length, used length beside it

	OsLength int32
	Arch     [33]byte // string(32): max length, used length beside it

	ArchLength int32
	Cores      [9]byte // string(8): max length, used length beside it

	CoresLength int32
	MemoryGb    [17]byte // string(16): max length, used length beside it

	MemoryGbLength int32
	At             [33]byte // string(32): max length, used length beside it

	AtLength int32
	// contains filtered or unexported fields
}

MachineBeatBlockProjection — 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 MachineBeatRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type MachineBeatBlockStorage

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

MachineBeatBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*MachineBeatBlockStorage) Create

func (*MachineBeatBlockStorage) Destroy

func (s *MachineBeatBlockStorage) Destroy()

type MachineBeatCook

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

MachineBeatCook is MachineBeat'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 — MachineBeatOpen, MachineBeatAt — 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 (*MachineBeatCook) Open

func (cook *MachineBeatCook) 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 (MachineBeatCook) RegionAlignment

func (c MachineBeatCook) 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 (MachineBeatCook) Root

func (c MachineBeatCook) Root() *MachineBeatRow

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 (MachineBeatCook) RootAlign

func (c MachineBeatCook) RootAlign() int64

func (MachineBeatCook) RootSize

func (c MachineBeatCook) RootSize() int64

func (MachineBeatCook) Type

func (c MachineBeatCook) Type() *TableCookInfo

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

type MachineBeatCounts

type MachineBeatCounts struct {
}

MachineBeatCounts is gathered before Begin; clamping is the caller's policy.

type MachineBeatRow

type MachineBeatRow struct {
	Os [33]byte // string(32): buffer, used length beside it

	OsLength int32
	Arch     [33]byte // string(32): buffer, used length beside it

	ArchLength int32
	Cores      [9]byte // string(8): buffer, used length beside it

	CoresLength int32
	MemoryGb    [17]byte // string(16): buffer, used length beside it

	MemoryGbLength int32
	At             [33]byte // string(32): buffer, used length beside it

	AtLength int32
	// contains filtered or unexported fields
}

MachineBeatRow — 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 MachineBeatAt

func MachineBeatAt(slot *int64) *MachineBeatRow

MachineBeatAt 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 MachineView

type MachineView struct {
	Name         [128]byte // string(MaxName): max length, used length beside it
	NameLength   int32
	User         [2304]byte // string(MaxFieldValue): max length, used length beside it
	UserLength   int32
	Seat         [2304]byte // string(MaxFieldValue): max length, used length beside it
	SeatLength   int32
	Slots        int32
	Runners      int32
	Roles        [64]byte // string(64): max length, used length beside it
	RolesLength  int32
	Tla          bool
	Width        int32
	WidthPresent bool // ?int32: absent until set
}

A machine's view as the Redis view holds it (the machine:<name> hash the inventory reads, pkg/config Snapshot.Machines): its login, seat, slots, runners, explicit roles as the canonical comma list, tla flag, and the width when the row names one (the nullable width; absent defaults to half the beat cores). MachineView — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by MachineViewReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func MachineViewLoadText

func MachineViewLoadText(text string, report *TableReport) (*MachineView, error)

MachineViewLoadText fills one MachineView 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 MachineViewReadStrict

func MachineViewReadStrict(wire []byte) (*MachineView, error)

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

type MachineViewBlock

type MachineViewBlock struct {
	Base       unsafe.Pointer              // the extent's base, 64-byte aligned
	Projection *MachineViewBlockProjection // the projection, at offset 0
	Bytes      int64                       // the extent in use
}

MachineViewBlock is MachineView'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 (*MachineViewBlock) Open

func (block *MachineViewBlock) 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 (*MachineViewBlock) Type

func (b *MachineViewBlock) 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 MachineViewBlockProjection

type MachineViewBlockProjection 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
	Name         [129]byte // string(128): max length, used length beside it

	NameLength int32
	User       [2305]byte // string(2304): max length, used length beside it

	UserLength int32
	Seat       [2305]byte // string(2304): max length, used length beside it

	SeatLength int32
	Slots      int32
	Runners    int32
	Roles      [65]byte // string(64): max length, used length beside it

	RolesLength int32
	Tla         bool

	Width        int32
	WidthPresent bool // ?: one byte, in Go's model as in C++
	// contains filtered or unexported fields
}

MachineViewBlockProjection — 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 MachineViewRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type MachineViewBlockStorage

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

MachineViewBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*MachineViewBlockStorage) Create

func (*MachineViewBlockStorage) Destroy

func (s *MachineViewBlockStorage) Destroy()

type MachineViewCook

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

MachineViewCook is MachineView'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 — MachineViewOpen, MachineViewAt — 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 (*MachineViewCook) Open

func (cook *MachineViewCook) 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 (MachineViewCook) RegionAlignment

func (c MachineViewCook) 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 (MachineViewCook) Root

func (c MachineViewCook) Root() *MachineViewRow

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 (MachineViewCook) RootAlign

func (c MachineViewCook) RootAlign() int64

func (MachineViewCook) RootSize

func (c MachineViewCook) RootSize() int64

func (MachineViewCook) Type

func (c MachineViewCook) Type() *TableCookInfo

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

type MachineViewCounts

type MachineViewCounts struct {
}

MachineViewCounts is gathered before Begin; clamping is the caller's policy.

type MachineViewRow

type MachineViewRow struct {
	Name [129]byte // string(128): buffer, used length beside it

	NameLength int32
	User       [2305]byte // string(2304): buffer, used length beside it

	UserLength int32
	Seat       [2305]byte // string(2304): buffer, used length beside it

	SeatLength int32
	Slots      int32
	Runners    int32
	Roles      [65]byte // string(64): buffer, used length beside it

	RolesLength int32
	Tla         bool

	Width        int32
	WidthPresent bool // ?: one byte, in Go's model as in C++
	// contains filtered or unexported fields
}

MachineViewRow — 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 MachineViewAt

func MachineViewAt(slot *int64) *MachineViewRow

MachineViewAt 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 MemberBeat

type MemberBeat struct {
	AtMs  int64
	Cores int32
}

The member beat record (pkg/config MemberBeatKey, sprint:beat:<machine>): the part of the nova-sprint member's JSON the inventory reads, the beat time as Unix milliseconds and the logical cores. Every other field is the sprint's. MemberBeat — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by MemberBeatReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func MemberBeatLoadText

func MemberBeatLoadText(text string, report *TableReport) (*MemberBeat, error)

MemberBeatLoadText fills one MemberBeat 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 MemberBeatReadStrict

func MemberBeatReadStrict(wire []byte) (*MemberBeat, error)

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

type MemberBeatBlock

type MemberBeatBlock struct {
	Base       unsafe.Pointer             // the extent's base, 64-byte aligned
	Projection *MemberBeatBlockProjection // the projection, at offset 0
	Bytes      int64                      // the extent in use
}

MemberBeatBlock is MemberBeat'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 (*MemberBeatBlock) Open

func (block *MemberBeatBlock) 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 (*MemberBeatBlock) Type

func (b *MemberBeatBlock) 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 MemberBeatBlockProjection

type MemberBeatBlockProjection 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
	AtMs         int64
	Cores        int32
	// contains filtered or unexported fields
}

MemberBeatBlockProjection — 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 MemberBeatRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type MemberBeatBlockStorage

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

MemberBeatBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*MemberBeatBlockStorage) Create

func (*MemberBeatBlockStorage) Destroy

func (s *MemberBeatBlockStorage) Destroy()

type MemberBeatCook

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

MemberBeatCook is MemberBeat'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 — MemberBeatOpen, MemberBeatAt — 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 (*MemberBeatCook) Open

func (cook *MemberBeatCook) 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 (MemberBeatCook) RegionAlignment

func (c MemberBeatCook) 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 (MemberBeatCook) Root

func (c MemberBeatCook) Root() *MemberBeatRow

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 (MemberBeatCook) RootAlign

func (c MemberBeatCook) RootAlign() int64

func (MemberBeatCook) RootSize

func (c MemberBeatCook) RootSize() int64

func (MemberBeatCook) Type

func (c MemberBeatCook) Type() *TableCookInfo

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

type MemberBeatCounts

type MemberBeatCounts struct {
}

MemberBeatCounts is gathered before Begin; clamping is the caller's policy.

type MemberBeatRow

type MemberBeatRow struct {
	AtMs  int64
	Cores int32
	// contains filtered or unexported fields
}

MemberBeatRow — 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 MemberBeatAt

func MemberBeatAt(slot *int64) *MemberBeatRow

MemberBeatAt 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 RowFields

type RowFields struct {
	Pairs      [24]FieldPair // used count beside it; count in [0, 24]
	PairsCount int32
	Argv       [4096]byte // string(MaxArgvBytes): max length, used length beside it
	ArgvLength int32
}

A row's fields, the map pkg/config Row.Fields and Change.Before and After hold. The loop kind's argv is the one field the code bounds above a kilobyte, so it rides its own slot: a pair named argv is never written, the slot is. Pairs are kept in name order, which makes the image of a row unique. RowFields — TABLE-wire storage: exported fields, every buffer inside the value, declared defaults restored by RowFieldsReset (mas-bandwidth/schema docs/SPEC-TABLES.md).

func RowFieldsLoadText

func RowFieldsLoadText(text string, report *TableReport) (*RowFields, error)

RowFieldsLoadText fills one RowFields 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 RowFieldsReadStrict

func RowFieldsReadStrict(wire []byte) (*RowFields, error)

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

type RowFieldsBlock

type RowFieldsBlock struct {
	Base       unsafe.Pointer            // the extent's base, 64-byte aligned
	Projection *RowFieldsBlockProjection // the projection, at offset 0
	Bytes      int64                     // the extent in use
}

RowFieldsBlock is RowFields'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 (*RowFieldsBlock) Open

func (block *RowFieldsBlock) 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 (*RowFieldsBlock) Pairs

Pairs is ITERATED, not indexed by hand: the accessor points at each row where it lies, at the pitch the INSTANCE gives, for the count the instance gives.

func (*RowFieldsBlock) PairsMax

func (b *RowFieldsBlock) PairsMax() int64

func (*RowFieldsBlock) PairsProjectionOffset

func (b *RowFieldsBlock) PairsProjectionOffset() int64

func (*RowFieldsBlock) PairsSpan

func (b *RowFieldsBlock) PairsSpan() []FieldPairRow

PairsSpan is the CONTIGUOUS view, available because the pitch IS the element's size (§2.7), which is how the per-frame fast path is written.

func (*RowFieldsBlock) PairsStride

func (b *RowFieldsBlock) PairsStride() int64

---- block fill path: begin ---- PairsStride, PairsMax and PairsProjectionOffset are the constants this build asserts against. A consumer INDEXES with what it read from the instance, never with these (mas-bandwidth/schema docs/SPEC-TABLES.md §19.2). They are METHODS rather than package constants because §11 gives a language whose accessors are members exactly that latitude: a member claims nothing at file scope.

func (*RowFieldsBlock) Type

func (b *RowFieldsBlock) 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 RowFieldsBlockProjection

type RowFieldsBlockProjection 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
	Pairs        TableBlockTriple // [..24]FieldPair, laid out of line
	Argv         [4097]byte       // string(4096): max length, used length beside it

	ArgvLength int32
	// contains filtered or unexported fields
}

RowFieldsBlockProjection — 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 RowFieldsRow: a table can be both a block root and another block's row, and the two differ by the prologue.

type RowFieldsBlockStorage

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

RowFieldsBlockStorage owns a maximum-sized extent. Do not copy an initialized storage.

func (*RowFieldsBlockStorage) Create

func (*RowFieldsBlockStorage) Destroy

func (s *RowFieldsBlockStorage) Destroy()

type RowFieldsCook

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

RowFieldsCook is RowFields'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 — RowFieldsOpen, RowFieldsAt — 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 (*RowFieldsCook) Open

func (cook *RowFieldsCook) 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 (RowFieldsCook) RegionAlignment

func (c RowFieldsCook) 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 (RowFieldsCook) Root

func (c RowFieldsCook) Root() *RowFieldsRow

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 (RowFieldsCook) RootAlign

func (c RowFieldsCook) RootAlign() int64

func (RowFieldsCook) RootSize

func (c RowFieldsCook) RootSize() int64

func (RowFieldsCook) Type

func (c RowFieldsCook) Type() *TableCookInfo

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

type RowFieldsCounts

type RowFieldsCounts struct {
	Pairs int32
}

RowFieldsCounts is gathered before Begin; clamping is the caller's policy.

type RowFieldsRow

type RowFieldsRow struct {
	Pairs      [24]FieldPairRow
	PairsCount int32
	Argv       [4097]byte // string(4096): max length, used length beside it

	ArgvLength int32
	// contains filtered or unexported fields
}

RowFieldsRow — a block row, or a record one nests by value. `Row` is a CLAIMED suffix (mas-bandwidth/schema docs/SPEC-TABLES.md §11), so no declaration in the unit can take it.

func RowFieldsAt

func RowFieldsAt(slot *int64) *RowFieldsRow

RowFieldsAt 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 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 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

type TableByteOrder

type TableByteOrder uint8

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

const (
	TableByteOrderLittle TableByteOrder = 1
	TableByteOrderBig    TableByteOrder = 2
)

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 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 {
	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 TableMessageEntry

type TableMessageEntry struct {
	Id             uint64
	Shape, Element TableMessageShape
}

type TableMessageReader

type TableMessageReader struct {
	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
}

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 TableOpenVerdict

type TableOpenVerdict uint8

TableOpenVerdict distinguishes an unsupported form from framing damage.

const (
	TableOpenOk TableOpenVerdict = iota
	TableOpenRefused
	TableOpenDamaged
	TableOpenBodyStopped
)

type TableReader

type TableReader struct {
	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) Unsigned

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

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 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 {
	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 BenchBeatTableInfo TableTypeInfo

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

var CanonicalWordTableInfo TableTypeInfo

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

var ConfigChangeTableInfo TableTypeInfo

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

var ConfigRowTableInfo TableTypeInfo

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

var EnvNameTableInfo TableTypeInfo

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

var FieldPairTableInfo TableTypeInfo

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

var FileHeaderTableInfo TableTypeInfo

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

var HostGroupTableInfo TableTypeInfo

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

var HostNameTableInfo TableTypeInfo

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

var HostViewTableInfo TableTypeInfo

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

var InventoryLoopTableInfo TableTypeInfo

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

var InventoryTableInfo TableTypeInfo

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

var KindRevTableInfo TableTypeInfo

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

var MachineBeatTableInfo TableTypeInfo

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

var MachineViewTableInfo TableTypeInfo

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

var MemberBeatTableInfo TableTypeInfo

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

var RowFieldsTableInfo TableTypeInfo

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

func BenchBeatTableType

func BenchBeatTableType() *TableTypeInfo

BenchBeatTableType returns BenchBeat's reflection descriptor.

func CanonicalWordTableType

func CanonicalWordTableType() *TableTypeInfo

CanonicalWordTableType returns CanonicalWord's reflection descriptor.

func ConfigChangeTableType

func ConfigChangeTableType() *TableTypeInfo

ConfigChangeTableType returns ConfigChange's reflection descriptor.

func ConfigRowTableType

func ConfigRowTableType() *TableTypeInfo

ConfigRowTableType returns ConfigRow's reflection descriptor.

func EnvNameTableType

func EnvNameTableType() *TableTypeInfo

EnvNameTableType returns EnvName's reflection descriptor.

func FieldPairTableType

func FieldPairTableType() *TableTypeInfo

FieldPairTableType returns FieldPair's reflection descriptor.

func FileHeaderTableType

func FileHeaderTableType() *TableTypeInfo

FileHeaderTableType returns FileHeader's reflection descriptor.

func HostGroupTableType

func HostGroupTableType() *TableTypeInfo

HostGroupTableType returns HostGroup's reflection descriptor.

func HostNameTableType

func HostNameTableType() *TableTypeInfo

HostNameTableType returns HostName's reflection descriptor.

func HostViewTableType

func HostViewTableType() *TableTypeInfo

HostViewTableType returns HostView's reflection descriptor.

func InventoryLoopTableType

func InventoryLoopTableType() *TableTypeInfo

InventoryLoopTableType returns InventoryLoop's reflection descriptor.

func InventoryTableType

func InventoryTableType() *TableTypeInfo

InventoryTableType returns Inventory's reflection descriptor.

func KindRevTableType

func KindRevTableType() *TableTypeInfo

KindRevTableType returns KindRev's reflection descriptor.

func MachineBeatTableType

func MachineBeatTableType() *TableTypeInfo

MachineBeatTableType returns MachineBeat's reflection descriptor.

func MachineViewTableType

func MachineViewTableType() *TableTypeInfo

MachineViewTableType returns MachineView's reflection descriptor.

func MemberBeatTableType

func MemberBeatTableType() *TableTypeInfo

MemberBeatTableType returns MemberBeat's reflection descriptor.

func RowFieldsTableType

func RowFieldsTableType() *TableTypeInfo

RowFieldsTableType returns RowFields'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 TableWriter

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

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

func (*TableWriter) Advance

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

func (*TableWriter) Header

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

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

func (*TableWriter) Id

func (w *TableWriter) Id(id uint64)

func (*TableWriter) IdAt

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

func (*TableWriter) Put8

func (w *TableWriter) Put8(v uint8)

func (*TableWriter) Put16

func (w *TableWriter) Put16(v uint16)

func (*TableWriter) Put32

func (w *TableWriter) Put32(v uint32)

func (*TableWriter) Put64

func (w *TableWriter) Put64(v uint64)

func (*TableWriter) Put128

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

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

func (*TableWriter) PutLeb

func (w *TableWriter) PutLeb(v uint64)

func (*TableWriter) Raw

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

func (*TableWriter) Trailer

func (w *TableWriter) Trailer()

type UnitViewInfo

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

func UnitView

func UnitView() *UnitViewInfo

type ViewConstant

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

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

type ViewType

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

type ViewVariant

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

type ViewVocabulary

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

Jump to

Keyboard shortcuts

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