friendfilewire

package
v1.5.2 Latest Latest
Warning

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

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

Documentation

Overview

Package friendfilewire is the friend files' table wire, generated by the schema compiler from schemas/friendfile/: the saved notice (notice.schema), a lane's end (laneend.schema), the sprint server's delivery of a friend's cards (delivery.schema) and the friend's local state (state.schema). Every other .go file here is generated: edit the .schema and run go generate ./pkg/friendfilewire, never the output.

Index

Constants

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

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

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

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

View Source
const BuildVersion uint64 = 0xd575252ba3100a3e

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 DeliveryCardLoadRetainBuilder = "DeliveryCard: retention requires a region round trip through the VARIABLE form"
View Source
const DeliveryCardSaveRetainMessages = "DeliveryCard: retention requires a region round trip through the VARIABLE form"
View Source
const DeliveryLoadRetainBuilder = "Delivery: retention requires a region round trip through the VARIABLE form"
View Source
const DeliverySaveRetainMessages = "Delivery: retention requires a region round trip through the VARIABLE form"
View Source
const FriendQueueLoadRetainBuilder = "FriendQueue: retention requires a region round trip through the VARIABLE form"
View Source
const FriendQueueSaveRetainMessages = "FriendQueue: retention requires a region round trip through the VARIABLE form"
View Source
const FriendRefusalLoadRetainBuilder = "FriendRefusal: retention requires a region round trip through the VARIABLE form"
View Source
const FriendRefusalSaveRetainMessages = "FriendRefusal: retention requires a region round trip through the VARIABLE form"
View Source
const FriendStatusLoadRetainBuilder = "FriendStatus: retention requires a region round trip through the VARIABLE form"
View Source
const FriendStatusSaveRetainMessages = "FriendStatus: retention requires a region round trip through the VARIABLE form"
View Source
const FriendTaskLoadRetainBuilder = "FriendTask: retention requires a region round trip through the VARIABLE form"
View Source
const FriendTaskSaveRetainMessages = "FriendTask: retention requires a region round trip through the VARIABLE form"
View Source
const FriendWatchLoadRetainBuilder = "FriendWatch: retention requires a region round trip through the VARIABLE form"
View Source
const FriendWatchSaveRetainMessages = "FriendWatch: retention requires a region round trip through the VARIABLE form"
View Source
const LaneEndLoadRetainBuilder = "LaneEnd: retention requires a region round trip through the VARIABLE form"
View Source
const LaneEndSaveRetainMessages = "LaneEnd: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeEnvelopeLoadRetainBuilder = "NoticeEnvelope: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeEnvelopeSaveRetainMessages = "NoticeEnvelope: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeMarkLoadRetainBuilder = "NoticeMark: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeMarkSaveRetainMessages = "NoticeMark: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeMessageLoadRetainBuilder = "NoticeMessage: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeMessageSaveRetainMessages = "NoticeMessage: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeNameLoadRetainBuilder = "NoticeName: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeNameSaveRetainMessages = "NoticeName: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeReceiverLoadRetainBuilder = "NoticeReceiver: retention requires a region round trip through the VARIABLE form"
View Source
const NoticeReceiverSaveRetainMessages = "NoticeReceiver: retention requires a region round trip through the VARIABLE form"
View Source
const ProtocolId uint64 = 0x0e5a50a709c93f09

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 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 = 119
View Source
const TableMessageRefBitsHere = 7

Variables

View Source
var DeliveryCardTableFields = []TableFieldInfo{
	{Name: "card", Json: "card", TypeName: "string", DeclaredTypeName: "string", Id: 0xb5614e90e87b455f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Card)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Card)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "job", Json: "job", TypeName: "string", DeclaredTypeName: "string", Id: 0x45627c193a5b605c, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 200, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Job)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Job)), CountOffset: uint32(unsafe.Offsetof(DeliveryCard{}.JobLength)), PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 1, CookCountOffset: 212, 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: "col", Json: "col", TypeName: "string", DeclaredTypeName: "string", Id: 0xf604f3190d016791, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Col)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Col)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 216, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "kind", Json: "kind", TypeName: "string", DeclaredTypeName: "string", Id: 0xef9c96d721673243, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Kind)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 224, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "branch", Json: "branch", TypeName: "string", DeclaredTypeName: "string", Id: 0x919ec0f651278ba5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Branch)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Branch)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 232, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "tier", Json: "tier", TypeName: "string", DeclaredTypeName: "string", Id: 0x1e6f84ef2eb65989, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Tier)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Tier)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 240, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "stream", Json: "stream", TypeName: "string", DeclaredTypeName: "string", Id: 0x4f6a36d8e8907985, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Stream)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Stream)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 248, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "attempt", Json: "attempt", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x63e618bd2b303dee, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Attempt)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Attempt)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 256, 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: "gen", Json: "gen", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xd4e26d18faaa8af5, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Gen)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Gen)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 264, 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: "epoch", Json: "epoch", TypeName: "uint64", DeclaredTypeName: "uint64", Id: 0xfc9697d1196e6ba6, Kind: 9, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Epoch)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Epoch)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 272, 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: "repo", Json: "repo", TypeName: "string", DeclaredTypeName: "string", Id: 0x4cac581fbfac663d, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Repo)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Repo)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 280, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "base_ref", Json: "base", TypeName: "string", DeclaredTypeName: "string", Id: 0xd46f4a3ebed65022, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.BaseRef)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.BaseRef)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 288, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "brief", Json: "brief", TypeName: "string", DeclaredTypeName: "string", Id: 0xf90e421e2470877f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Brief)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Brief)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 296, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "lane", Json: "lane", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x460ddad9060af0f, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(DeliveryCard{}.Lane)), ElemSize: uint32(unsafe.Sizeof(DeliveryCard{}.Lane)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 304, 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},
}

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

View Source
var DeliveryTableFields = []TableFieldInfo{
	{Name: "friend_name", Json: "friend", TypeName: "string", DeclaredTypeName: "string", Id: 0x2bcee2fac7bb6eb5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(Delivery{}.FriendName)), ElemSize: uint32(unsafe.Sizeof(Delivery{}.FriendName)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "cards", Json: "cards", TypeName: "DeliveryCard", DeclaredTypeName: "DeliveryCard", Id: 0xaf9dac3b097689c4, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(Delivery{}.Cards)), ElemSize: uint32(unsafe.Sizeof(*new(DeliveryCardRow))), CountOffset: (uint32(unsafe.Offsetof(Delivery{}.Cards))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 312, CookCountOffset: 16, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: DeliveryCardTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source
var ErrValidation = errors.New("friendfilewire: 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 FriendQueueTableFields = []TableFieldInfo{
	{Name: "tasks", Json: "tasks", TypeName: "FriendTask", DeclaredTypeName: "FriendTask", Id: 0x7d8162a04b6c10d, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(FriendQueue{}.Tasks)), ElemSize: uint32(unsafe.Sizeof(*new(FriendTaskRow))), CountOffset: (uint32(unsafe.Offsetof(FriendQueue{}.Tasks))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 40, CookCountOffset: 8, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: FriendTaskTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

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

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

View Source
var FriendStatusTableFields = []TableFieldInfo{
	{Name: "friend_name", Json: "friend", TypeName: "string", DeclaredTypeName: "string", Id: 0x2bcee2fac7bb6eb5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.FriendName)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.FriendName)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "harness", Json: "harness", TypeName: "string", DeclaredTypeName: "string", Id: 0x211fcbbafe5331ab, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Harness)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Harness)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "started", Json: "started", TypeName: "string", DeclaredTypeName: "string", Id: 0xc732f2e2fbe9f15e, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Started)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Started)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "at", Json: "at", TypeName: "string", DeclaredTypeName: "string", Id: 0x89c4e07b545a968, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.At)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.At)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "seat", Json: "seat", TypeName: "string", DeclaredTypeName: "string", Id: 0x2d08f118d3f933e8, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Seat)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Seat)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "beats", Json: "beats", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x67fea45e4a3e6082, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Beats)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Beats)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "last_beat", Json: "last_beat", TypeName: "string", DeclaredTypeName: "string", Id: 0xea60c9023c49fe1a, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.LastBeat)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.LastBeat)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 48, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "beat_error", Json: "beat_error", TypeName: "string", DeclaredTypeName: "string", Id: 0x4397007c7f5e1038, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.BeatError)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.BeatError)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 56, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "store_error", Json: "store_error", TypeName: "string", DeclaredTypeName: "string", Id: 0x641650763c8d0b0b, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.StoreError)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.StoreError)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 64, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "width", Json: "width", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xdbdacd932fd1e9bf, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Width)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Width)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 72, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "session", Json: "session", TypeName: "string", DeclaredTypeName: "string", Id: 0x3ca2c49553a457d7, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Session)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Session)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 80, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "session_id", Json: "session_id", TypeName: "string", DeclaredTypeName: "string", Id: 0xb7d7b5650a590b05, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.SessionId)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.SessionId)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 88, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "session_reason", Json: "session_reason", TypeName: "string", DeclaredTypeName: "string", Id: 0xc5fb10aa40fcabf4, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.SessionReason)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.SessionReason)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 96, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "broken_at", Json: "broken_at", TypeName: "string", DeclaredTypeName: "string", Id: 0x5511ffbeac7291d0, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.BrokenAt)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.BrokenAt)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 104, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "limit_kind", Json: "limit_kind", TypeName: "string", DeclaredTypeName: "string", Id: 0x408210b5d955146f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.LimitKind)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.LimitKind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 112, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "limit_until", Json: "limit_until", TypeName: "string", DeclaredTypeName: "string", Id: 0xaa460484f7e77bb3, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.LimitUntil)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.LimitUntil)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 120, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "mode", Json: "mode", TypeName: "string", DeclaredTypeName: "string", Id: 0xd3deba2c41dadb2, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Mode)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Mode)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 128, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "lanes", Json: "lanes", TypeName: "string", DeclaredTypeName: "string", Id: 0xd14829ec544a2fb4, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Lanes)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Lanes)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 136, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "paced", Json: "paced", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x8a2a33a758314d6a, Kind: 5, IsArray: false, Counted: false, Optional: true,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Paced)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Paced)), CountOffset: 0xffffffff, PresentOffset: uint32(unsafe.Offsetof(FriendStatus{}.PacedPresent)),
		CookOffset: 144, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 152,
		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: "window", Json: "window", TypeName: "string", DeclaredTypeName: "string", Id: 0x71f304ea62c01cbd, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Window)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Window)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 160, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "pacing", Json: "pacing", TypeName: "string", DeclaredTypeName: "string", Id: 0x8e31065aa027e00d, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Pacing)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Pacing)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 168, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "held_known", Json: "held_known", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x19122926f9f3e41a, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.HeldKnown)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.HeldKnown)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 176, 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: "held", Json: "held", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xa9904cc5fa248be, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Held)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Held)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 184, 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: "inbox", Json: "inbox", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x961de08f9b26b75b, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Inbox)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Inbox)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 192, 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: "missing", Json: "missing", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x8a56a8c8bd19c9c7, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Missing)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Missing)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 200, 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: "inbox_error", Json: "inbox_error", TypeName: "string", DeclaredTypeName: "string", Id: 0x792404531d6c907a, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.InboxError)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.InboxError)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 208, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "held_from", Json: "held_from", TypeName: "string", DeclaredTypeName: "string", Id: 0x5f4ae73e88afff4f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.HeldFrom)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.HeldFrom)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 216, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "refused", Json: "refused", TypeName: "FriendRefusal", DeclaredTypeName: "FriendRefusal", Id: 0xdd362779f48a4b03, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Refused)), ElemSize: uint32(unsafe.Sizeof(*new(FriendRefusalRow))), CountOffset: (uint32(unsafe.Offsetof(FriendStatus{}.Refused))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 224, CookElemSize: 16, CookCountOffset: 232, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: FriendRefusalTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "last_refusal", Json: "last_refusal", TypeName: "string", DeclaredTypeName: "string", Id: 0x7c7af471a8f22fe6, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.LastRefusal)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.LastRefusal)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 240, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "last_refusal_at", Json: "last_refusal_at", TypeName: "string", DeclaredTypeName: "string", Id: 0x237c71d418afddce, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.LastRefusalAt)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.LastRefusalAt)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 248, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "proof", Json: "proof", TypeName: "string", DeclaredTypeName: "string", Id: 0xf96ca0246daa2be9, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.Proof)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.Proof)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 256, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "proof_at", Json: "proof_at", TypeName: "string", DeclaredTypeName: "string", Id: 0xc2c5666060e98d17, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendStatus{}.ProofAt)), ElemSize: uint32(unsafe.Sizeof(FriendStatus{}.ProofAt)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 264, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source
var FriendTaskTableFields = []TableFieldInfo{
	{Name: "gen", Json: "gen", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xd4e26d18faaa8af5, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendTask{}.Gen)), ElemSize: uint32(unsafe.Sizeof(FriendTask{}.Gen)), 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: "job", Json: "job", TypeName: "string", DeclaredTypeName: "string", Id: 0x45627c193a5b605c, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendTask{}.Job)), ElemSize: uint32(unsafe.Sizeof(FriendTask{}.Job)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "id", Json: "id", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b72e07b55c3ac0, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendTask{}.Id)), ElemSize: uint32(unsafe.Sizeof(FriendTask{}.Id)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "state", Json: "state", TypeName: "string", DeclaredTypeName: "string", Id: 0xee63aaad45b1b116, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendTask{}.State)), ElemSize: uint32(unsafe.Sizeof(FriendTask{}.State)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "deliverable", Json: "deliverable", TypeName: "string", DeclaredTypeName: "string", Id: 0x92f1351d710c0102, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(FriendTask{}.Deliverable)), ElemSize: uint32(unsafe.Sizeof(FriendTask{}.Deliverable)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

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

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

View Source
var LaneEndTableFields = []TableFieldInfo{
	{Name: "exit", Json: "Exit", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xe79e4d608e807965, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Exit)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Exit)), 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: "err", Json: "Err", TypeName: "string", DeclaredTypeName: "string", Id: 0xc2fd0518f05dddcc, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Err)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Err)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "wall", Json: "Wall", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x5e76c2f62c1e1615, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Wall)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Wall)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "cap", Json: "Cap", TypeName: "string", DeclaredTypeName: "string", Id: 0xf5e303190ce49c5b, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Cap)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Cap)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "rejected", Json: "Rejected", TypeName: "string", DeclaredTypeName: "string", Id: 0xd182d068c109b1a7, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Rejected)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Rejected)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "turns", Json: "Turns", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x7f189dd0bc4902cb, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Turns)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Turns)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "restart", Json: "Restart", TypeName: "string", DeclaredTypeName: "string", Id: 0x9e1e242908cbee6c, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Restart)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Restart)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 48, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "started", Json: "Started", TypeName: "string", DeclaredTypeName: "string", Id: 0xc732f2e2fbe9f15e, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Started)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Started)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 56, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "no_report", Json: "NoReport", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x6ac71b271d6040e1, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.NoReport)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.NoReport)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 64, 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: "capped", Json: "Capped", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xf440984007926fe8, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Capped)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Capped)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 72, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "tier", Json: "Tier", TypeName: "string", DeclaredTypeName: "string", Id: 0x1e6f84ef2eb65989, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Tier)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Tier)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 80, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "overrun", Json: "Overrun", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x3c5eb11289517748, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Overrun)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Overrun)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 88, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "tail", Json: "Tail", TypeName: "string", DeclaredTypeName: "string", Id: 0xd94c56ef0798d723, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(LaneEnd{}.Tail)), ElemSize: uint32(unsafe.Sizeof(LaneEnd{}.Tail)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 96, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source
var NoticeEnvelopeTableFields = []TableFieldInfo{
	{Name: "local_receiver", Json: "local_receiver", TypeName: "NoticeReceiver", DeclaredTypeName: "NoticeReceiver", Id: 0x93b8471189b8b480, Kind: 13, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.LocalReceiver)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.LocalReceiver)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 32, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: NoticeReceiverTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "saved_at", Json: "saved_at", TypeName: "string", DeclaredTypeName: "string", Id: 0x7292c470718967bc, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.SavedAt)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.SavedAt)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 32, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "hook_epoch", Json: "hook_epoch", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x24c223c4ecaf6514, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.HookEpoch)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.HookEpoch)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 40, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "hook_role", Json: "hook_role", TypeName: "string", DeclaredTypeName: "string", Id: 0xd26e136f8e0073fb, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.HookRole)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.HookRole)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 48, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "event_id", Json: "event_id", TypeName: "string", DeclaredTypeName: "string", Id: 0x462dc6cc35c7a0bd, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.EventId)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.EventId)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 56, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "challenge", Json: "challenge", TypeName: "NoticeMessage", DeclaredTypeName: "NoticeMessage", Id: 0x273f002e1ba79f9e, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.Challenge)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.Challenge)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 64, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x5b78034b7b8297a8,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: NoticeMessageTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "messages", Json: "messages", TypeName: "int64", DeclaredTypeName: "int64", Id: 0xec1bef4f4de4355, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.Messages)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.Messages)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 72, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "senders", Json: "senders", TypeName: "NoticeName", DeclaredTypeName: "NoticeName", Id: 0x6c00e03ae71f1255, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.Senders)), ElemSize: uint32(unsafe.Sizeof(*new(NoticeNameRow))), CountOffset: (uint32(unsafe.Offsetof(NoticeEnvelope{}.Senders))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 80, CookElemSize: 72, CookCountOffset: 88, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 4,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: NoticeNameTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "recovery_since", Json: "recovery_since", TypeName: "string", DeclaredTypeName: "string", Id: 0x8fbf9eff7657e09b, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.RecoverySince)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.RecoverySince)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 96, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "recovery_coverage", Json: "recovery_coverage", TypeName: "string", DeclaredTypeName: "string", Id: 0x9d1f00c76880906d, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.RecoveryCoverage)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.RecoveryCoverage)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 104, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "recovery_messages", Json: "recovery_messages", TypeName: "NoticeMessage", DeclaredTypeName: "NoticeMessage", Id: 0xf690792f3c74b303, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.RecoveryMessages)), ElemSize: uint32(unsafe.Sizeof(*new(NoticeMessageRow))), CountOffset: (uint32(unsafe.Offsetof(NoticeEnvelope{}.RecoveryMessages))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 112, CookElemSize: 1048928, CookCountOffset: 120, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: NoticeMessageTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "possible_duplicates", Json: "possible_duplicates", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x8580c70f07ced1b9, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeEnvelope{}.PossibleDuplicates)), ElemSize: uint32(unsafe.Sizeof(NoticeEnvelope{}.PossibleDuplicates)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 128, 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},
}

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

View Source
var NoticeMarkTableFields = []TableFieldInfo{
	{Name: "key", Json: "Key", TypeName: "string", DeclaredTypeName: "string", Id: 0x3dc94a19365b10ec, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMark{}.Key)), ElemSize: uint32(unsafe.Sizeof(NoticeMark{}.Key)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "field", Json: "Field", TypeName: "string", DeclaredTypeName: "string", Id: 0x2c5d047ff4e6ffc7, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMark{}.Field)), ElemSize: uint32(unsafe.Sizeof(NoticeMark{}.Field)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "value", Json: "Value", TypeName: "string", DeclaredTypeName: "string", Id: 0x7ce4fd9430e80cea, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMark{}.Value)), ElemSize: uint32(unsafe.Sizeof(NoticeMark{}.Value)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "clear", Json: "Clear", TypeName: "bool", DeclaredTypeName: "bool", Id: 0xf531f89544a910a2, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMark{}.Clear)), ElemSize: uint32(unsafe.Sizeof(NoticeMark{}.Clear)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, 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: "forward", Json: "Forward", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x1e65942e132f4f7a, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMark{}.Forward)), ElemSize: uint32(unsafe.Sizeof(NoticeMark{}.Forward)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 25, 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: "once", Json: "Once", TypeName: "bool", DeclaredTypeName: "bool", Id: 0x70eceb46ad585c4, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMark{}.Once)), ElemSize: uint32(unsafe.Sizeof(NoticeMark{}.Once)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 26, 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},
}

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

View Source
var NoticeMessageTableFields = []TableFieldInfo{
	{Name: "model_activity", Json: "ModelActivity", TypeName: "bool", DeclaredTypeName: "bool", Id: 0xdac99c68d1d84a7e, Kind: 1, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.ModelActivity)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.ModelActivity)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, 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: "id", Json: "ID", TypeName: "string", DeclaredTypeName: "string", Id: 0x8b72e07b55c3ac0, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Id)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Id)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "from", Json: "From", TypeName: "string", DeclaredTypeName: "string", Id: 0x7f845078d7a5c0b5, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 64, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.From)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.From)), CountOffset: uint32(unsafe.Offsetof(NoticeMessage{}.FromLength)), PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 1, CookCountOffset: 84, 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: "to", Json: "To", TypeName: "NoticeName", DeclaredTypeName: "NoticeName", Id: 0x8c83907b56ac0a4, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.To)), ElemSize: uint32(unsafe.Sizeof(*new(NoticeNameRow))), CountOffset: (uint32(unsafe.Offsetof(NoticeMessage{}.To))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 88, CookElemSize: 72, CookCountOffset: 96, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 4,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: NoticeNameTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "cc", Json: "CC", TypeName: "NoticeName", DeclaredTypeName: "NoticeName", Id: 0x8a24d07b54a1363, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Cc)), ElemSize: uint32(unsafe.Sizeof(*new(NoticeNameRow))), CountOffset: (uint32(unsafe.Offsetof(NoticeMessage{}.Cc))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 104, CookElemSize: 72, CookCountOffset: 112, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 4,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: NoticeNameTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "subject", Json: "Subject", TypeName: "string", DeclaredTypeName: "string", Id: 0x9640735281e90c0f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Subject)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Subject)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 120, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "re", Json: "Re", TypeName: "string", DeclaredTypeName: "string", Id: 0x8dc4f07b57b8f10, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Re)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Re)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 128, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "card", Json: "Card", TypeName: "string", DeclaredTypeName: "string", Id: 0xb5614e90e87b455f, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Card)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Card)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 136, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "head", Json: "Head", TypeName: "string", DeclaredTypeName: "string", Id: 0xa8f12cc5f9a0c03, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Head)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Head)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 144, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "kind", Json: "Kind", TypeName: "string", DeclaredTypeName: "string", Id: 0xef9c96d721673243, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Kind)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Kind)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 152, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "at", Json: "At", TypeName: "string", DeclaredTypeName: "string", Id: 0x89c4e07b545a968, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.At)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.At)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 160, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "body", Json: "Body", TypeName: "string", DeclaredTypeName: "string", Id: 0xcd4de79bc6c93295, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 1048576, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Body)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Body)), CountOffset: uint32(unsafe.Offsetof(NoticeMessage{}.BodyLength)), PresentOffset: 0xffffffff,
		CookOffset: 168, CookElemSize: 1, CookCountOffset: 1048748, 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: "wait", Json: "Wait", TypeName: "int64", DeclaredTypeName: "int64", Id: 0x5e81a4f62c27eaa0, Kind: 5, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Wait)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Wait)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 1048752, 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: "due", Json: "Due", TypeName: "string", DeclaredTypeName: "string", Id: 0xca643d18f43490d5, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Due)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Due)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 1048760, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "token", Json: "Token", TypeName: "string", DeclaredTypeName: "string", Id: 0x26c4b17d50b3c152, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 128, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Token)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Token)), CountOffset: uint32(unsafe.Offsetof(NoticeMessage{}.TokenLength)), PresentOffset: 0xffffffff,
		CookOffset: 1048768, CookElemSize: 1, CookCountOffset: 1048900, 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: "once", Json: "Once", TypeName: "string", DeclaredTypeName: "string", Id: 0x70eceb46ad585c4, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Once)), ElemSize: uint32(unsafe.Sizeof(NoticeMessage{}.Once)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 1048904, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "marks", Json: "Marks", TypeName: "NoticeMark", DeclaredTypeName: "NoticeMark", Id: 0x9077d4a4e1726e29, Kind: 13, IsArray: true, Counted: true, Optional: false,
		ArrayBound: 2147483647, Offset: uint32(unsafe.Offsetof(NoticeMessage{}.Marks)), ElemSize: uint32(unsafe.Sizeof(*new(NoticeMarkRow))), CountOffset: (uint32(unsafe.Offsetof(NoticeMessage{}.Marks))) + 8, PresentOffset: 0xffffffff,
		CookOffset: 1048912, CookElemSize: 32, CookCountOffset: 1048920, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		List: true, ElemAlign: 8,
		FracBits: 0, Pointer: false, TargetId: 0x0000000000000000,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: NoticeMarkTableType,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source
var NoticeNameTableFields = []TableFieldInfo{
	{Name: "s", Json: "s", TypeName: "string", DeclaredTypeName: "string", Id: 0xaf63ee4c86020b22, Kind: 12, IsArray: false, Counted: true, Optional: false,
		ArrayBound: 64, Offset: uint32(unsafe.Offsetof(NoticeName{}.S)), ElemSize: uint32(unsafe.Sizeof(NoticeName{}.S)), CountOffset: uint32(unsafe.Offsetof(NoticeName{}.SLength)), PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 1, CookCountOffset: 68, 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},
}

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

View Source
var NoticeReceiverTableFields = []TableFieldInfo{
	{Name: "identity", Json: "identity", TypeName: "string", DeclaredTypeName: "string", Id: 0xe90f184c6aa3ffbb, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeReceiver{}.Identity)), ElemSize: uint32(unsafe.Sizeof(NoticeReceiver{}.Identity)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 0, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "redis", Json: "redis", TypeName: "string", DeclaredTypeName: "string", Id: 0xa30c3ff3148ac374, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeReceiver{}.Redis)), ElemSize: uint32(unsafe.Sizeof(NoticeReceiver{}.Redis)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 8, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "proof", Json: "proof", TypeName: "string", DeclaredTypeName: "string", Id: 0xf96ca0246daa2be9, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeReceiver{}.Proof)), ElemSize: uint32(unsafe.Sizeof(NoticeReceiver{}.Proof)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 16, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
	{Name: "acknowledge", Json: "acknowledge", TypeName: "string", DeclaredTypeName: "string", Id: 0xe1d811da25ba0773, Kind: 17, IsArray: false, Counted: false, Optional: false,
		ArrayBound: 0, Offset: uint32(unsafe.Offsetof(NoticeReceiver{}.Acknowledge)), ElemSize: uint32(unsafe.Sizeof(NoticeReceiver{}.Acknowledge)), CountOffset: 0xffffffff, PresentOffset: 0xffffffff,
		CookOffset: 24, CookElemSize: 8, CookCountOffset: 4294967295, CookPresentOffset: 4294967295,
		HasRange: false, RangeMin: 0.0, RangeMax: 0.0, EnumMax: -1,
		FracBits: 0, Pointer: true, TargetId: 0x704be0d8faaffc58,
		EnumName:    nil,
		VariantId:   nil,
		KeyTypeName: "", KeyName: nil, KeyId: nil,
		Arms:  nil,
		Guard: "", Table: nil,
		Doc: TableDocNone, NumTags: 0, Tags: nil},
}

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

View Source
var TableCookByteOrder = tableCookNativeOrder()

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

Functions

func Announce

func Announce(buffer []byte) int64

func AnnounceMeasure

func AnnounceMeasure() int64

func AnnounceRead

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

func DeliveryCardCookFrom

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

func DeliveryCardCookMeasure

func DeliveryCardCookMeasure(value *DeliveryCard, context ...TableWriteContext) int64

func DeliveryCardCookMeasureReason

func DeliveryCardCookMeasureReason(value *DeliveryCard, context ...TableWriteContext) (int64, error)

func DeliveryCardFromJson

func DeliveryCardFromJson(builder *DeliveryCardBuilder, text []byte, report *TableReport) bool

func DeliveryCardLoadBody

func DeliveryCardLoadBody(r *TableReader, value *DeliveryCard) bool

func DeliveryCardLoadBodyRetain

func DeliveryCardLoadBodyRetain(r *TableRetainReader, value *DeliveryCard) bool

func DeliveryCardLoadBuilder

func DeliveryCardLoadBuilder(b *DeliveryCardBuilder, wire []byte, report *TableReport) bool

func DeliveryCardLoadMeasure

func DeliveryCardLoadMeasure(wire []byte) int64

func DeliveryCardLoadMeasureReason

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

func DeliveryCardLoadMessageBody

func DeliveryCardLoadMessageBody(r *TableMessageReader, value *DeliveryCard) bool

func DeliveryCardLoadMessageBodyRetain

func DeliveryCardLoadMessageBodyRetain(r *TableRetainMessageReader, value *DeliveryCard) bool

func DeliveryCardMeasure

func DeliveryCardMeasure(value *DeliveryCard, context ...TableWriteContext) int64

func DeliveryCardMeasureBody

func DeliveryCardMeasureBody(value *DeliveryCard, ids *TableIds) int64

func DeliveryCardMeasureBodyRetain

func DeliveryCardMeasureBodyRetain(value *DeliveryCard, ids *TableRetainIds) int64

func DeliveryCardMeasureReason

func DeliveryCardMeasureReason(value *DeliveryCard, context ...TableWriteContext) (int64, error)

func DeliveryCardMeasureRetain

func DeliveryCardMeasureRetain(value *DeliveryCard, retain *TableRetain, allocator ...TableAllocator) int64

func DeliveryCardOpen

func DeliveryCardOpen(cook *DeliveryCardCook, base unsafe.Pointer, length int64) bool

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

func DeliveryCardReset

func DeliveryCardReset(value *DeliveryCard)

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

func DeliveryCardSave

func DeliveryCardSave(value *DeliveryCard, buffer []byte, context ...TableWriteContext) int64

func DeliveryCardSaveBody

func DeliveryCardSaveBody(w *TableWriter, value *DeliveryCard) bool

func DeliveryCardSaveBodyFields

func DeliveryCardSaveBodyFields(w *TableWriter, value *DeliveryCard) bool

func DeliveryCardSaveBodyFieldsRetain

func DeliveryCardSaveBodyFieldsRetain(w *TableRetainWriter, value *DeliveryCard) bool

func DeliveryCardSaveBodyRetain

func DeliveryCardSaveBodyRetain(w *TableRetainWriter, value *DeliveryCard) bool

func DeliveryCardSaveMessageBody

func DeliveryCardSaveMessageBody(w *TableMessageWriter, value *DeliveryCard) bool

func DeliveryCardSaveRetain

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

func DeliveryCardSaveText

func DeliveryCardSaveText(value *DeliveryCard, context ...TableWriteContext) (string, error)

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

func DeliveryCardToJson

func DeliveryCardToJson(value *DeliveryCard, buffer []byte, allocator ...TableAllocator) int64

func DeliveryCardToJsonMeasure

func DeliveryCardToJsonMeasure(value *DeliveryCard, allocator ...TableAllocator) int64

func DeliveryCardsEach

func DeliveryCardsEach(holder *TableList[DeliveryCardRow], visit func(*DeliveryCardRow) bool, arena ...*TableArena) bool

func DeliveryCardsErase

func DeliveryCardsErase(arena *TableArena, holder *TableList[DeliveryCardRow], element *DeliveryCardRow) bool

func DeliveryCookFrom

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

func DeliveryCookMeasure

func DeliveryCookMeasure(value *Delivery, context ...TableWriteContext) int64

func DeliveryCookMeasureReason

func DeliveryCookMeasureReason(value *Delivery, context ...TableWriteContext) (int64, error)

func DeliveryFromJson

func DeliveryFromJson(builder *DeliveryBuilder, text []byte, report *TableReport) bool

func DeliveryLoadBody

func DeliveryLoadBody(r *TableReader, value *Delivery) bool

func DeliveryLoadBodyRetain

func DeliveryLoadBodyRetain(r *TableRetainReader, value *Delivery) bool

func DeliveryLoadBuilder

func DeliveryLoadBuilder(b *DeliveryBuilder, wire []byte, report *TableReport) bool

func DeliveryLoadMeasure

func DeliveryLoadMeasure(wire []byte) int64

func DeliveryLoadMeasureReason

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

func DeliveryLoadMessageBody

func DeliveryLoadMessageBody(r *TableMessageReader, value *Delivery) bool

func DeliveryLoadMessageBodyRetain

func DeliveryLoadMessageBodyRetain(r *TableRetainMessageReader, value *Delivery) bool

func DeliveryMeasure

func DeliveryMeasure(value *Delivery, context ...TableWriteContext) int64

func DeliveryMeasureBody

func DeliveryMeasureBody(value *Delivery, ids *TableIds) int64

func DeliveryMeasureBodyRetain

func DeliveryMeasureBodyRetain(value *Delivery, ids *TableRetainIds) int64

func DeliveryMeasureReason

func DeliveryMeasureReason(value *Delivery, context ...TableWriteContext) (int64, error)

func DeliveryMeasureRetain

func DeliveryMeasureRetain(value *Delivery, retain *TableRetain, allocator ...TableAllocator) int64

func DeliveryOpen

func DeliveryOpen(cook *DeliveryCook, base unsafe.Pointer, length int64) bool

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

func DeliveryReset

func DeliveryReset(value *Delivery)

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

func DeliverySave

func DeliverySave(value *Delivery, buffer []byte, context ...TableWriteContext) int64

func DeliverySaveBody

func DeliverySaveBody(w *TableWriter, value *Delivery) bool

func DeliverySaveBodyFields

func DeliverySaveBodyFields(w *TableWriter, value *Delivery) bool

func DeliverySaveBodyFieldsRetain

func DeliverySaveBodyFieldsRetain(w *TableRetainWriter, value *Delivery) bool

func DeliverySaveBodyRetain

func DeliverySaveBodyRetain(w *TableRetainWriter, value *Delivery) bool

func DeliverySaveMessageBody

func DeliverySaveMessageBody(w *TableMessageWriter, value *Delivery) bool

func DeliverySaveRetain

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

func DeliverySaveText

func DeliverySaveText(value *Delivery, context ...TableWriteContext) (string, error)

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

func DeliveryToJson

func DeliveryToJson(value *Delivery, buffer []byte, allocator ...TableAllocator) int64

func DeliveryToJsonMeasure

func DeliveryToJsonMeasure(value *Delivery, allocator ...TableAllocator) int64

func FriendQueueCookFrom

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

func FriendQueueCookMeasure

func FriendQueueCookMeasure(value *FriendQueue, context ...TableWriteContext) int64

func FriendQueueCookMeasureReason

func FriendQueueCookMeasureReason(value *FriendQueue, context ...TableWriteContext) (int64, error)

func FriendQueueFromJson

func FriendQueueFromJson(builder *FriendQueueBuilder, text []byte, report *TableReport) bool

func FriendQueueLoadBody

func FriendQueueLoadBody(r *TableReader, value *FriendQueue) bool

func FriendQueueLoadBodyRetain

func FriendQueueLoadBodyRetain(r *TableRetainReader, value *FriendQueue) bool

func FriendQueueLoadBuilder

func FriendQueueLoadBuilder(b *FriendQueueBuilder, wire []byte, report *TableReport) bool

func FriendQueueLoadMeasure

func FriendQueueLoadMeasure(wire []byte) int64

func FriendQueueLoadMeasureReason

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

func FriendQueueLoadMessageBody

func FriendQueueLoadMessageBody(r *TableMessageReader, value *FriendQueue) bool

func FriendQueueLoadMessageBodyRetain

func FriendQueueLoadMessageBodyRetain(r *TableRetainMessageReader, value *FriendQueue) bool

func FriendQueueMeasure

func FriendQueueMeasure(value *FriendQueue, context ...TableWriteContext) int64

func FriendQueueMeasureBody

func FriendQueueMeasureBody(value *FriendQueue, ids *TableIds) int64

func FriendQueueMeasureBodyRetain

func FriendQueueMeasureBodyRetain(value *FriendQueue, ids *TableRetainIds) int64

func FriendQueueMeasureReason

func FriendQueueMeasureReason(value *FriendQueue, context ...TableWriteContext) (int64, error)

func FriendQueueMeasureRetain

func FriendQueueMeasureRetain(value *FriendQueue, retain *TableRetain, allocator ...TableAllocator) int64

func FriendQueueOpen

func FriendQueueOpen(cook *FriendQueueCook, base unsafe.Pointer, length int64) bool

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

func FriendQueueReset

func FriendQueueReset(value *FriendQueue)

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

func FriendQueueSave

func FriendQueueSave(value *FriendQueue, buffer []byte, context ...TableWriteContext) int64

func FriendQueueSaveBody

func FriendQueueSaveBody(w *TableWriter, value *FriendQueue) bool

func FriendQueueSaveBodyFields

func FriendQueueSaveBodyFields(w *TableWriter, value *FriendQueue) bool

func FriendQueueSaveBodyFieldsRetain

func FriendQueueSaveBodyFieldsRetain(w *TableRetainWriter, value *FriendQueue) bool

func FriendQueueSaveBodyRetain

func FriendQueueSaveBodyRetain(w *TableRetainWriter, value *FriendQueue) bool

func FriendQueueSaveMessageBody

func FriendQueueSaveMessageBody(w *TableMessageWriter, value *FriendQueue) bool

func FriendQueueSaveRetain

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

func FriendQueueSaveText

func FriendQueueSaveText(value *FriendQueue, context ...TableWriteContext) (string, error)

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

func FriendQueueTasksEach

func FriendQueueTasksEach(holder *TableList[FriendTaskRow], visit func(*FriendTaskRow) bool, arena ...*TableArena) bool

func FriendQueueTasksErase

func FriendQueueTasksErase(arena *TableArena, holder *TableList[FriendTaskRow], element *FriendTaskRow) bool

func FriendQueueToJson

func FriendQueueToJson(value *FriendQueue, buffer []byte, allocator ...TableAllocator) int64

func FriendQueueToJsonMeasure

func FriendQueueToJsonMeasure(value *FriendQueue, allocator ...TableAllocator) int64

func FriendRefusalCookFrom

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

func FriendRefusalCookMeasure

func FriendRefusalCookMeasure(value *FriendRefusal, context ...TableWriteContext) int64

func FriendRefusalCookMeasureReason

func FriendRefusalCookMeasureReason(value *FriendRefusal, context ...TableWriteContext) (int64, error)

func FriendRefusalFromJson

func FriendRefusalFromJson(builder *FriendRefusalBuilder, text []byte, report *TableReport) bool

func FriendRefusalLoadBody

func FriendRefusalLoadBody(r *TableReader, value *FriendRefusal) bool

func FriendRefusalLoadBodyRetain

func FriendRefusalLoadBodyRetain(r *TableRetainReader, value *FriendRefusal) bool

func FriendRefusalLoadBuilder

func FriendRefusalLoadBuilder(b *FriendRefusalBuilder, wire []byte, report *TableReport) bool

func FriendRefusalLoadMeasure

func FriendRefusalLoadMeasure(wire []byte) int64

func FriendRefusalLoadMeasureReason

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

func FriendRefusalLoadMessageBody

func FriendRefusalLoadMessageBody(r *TableMessageReader, value *FriendRefusal) bool

func FriendRefusalLoadMessageBodyRetain

func FriendRefusalLoadMessageBodyRetain(r *TableRetainMessageReader, value *FriendRefusal) bool

func FriendRefusalMeasure

func FriendRefusalMeasure(value *FriendRefusal, context ...TableWriteContext) int64

func FriendRefusalMeasureBody

func FriendRefusalMeasureBody(value *FriendRefusal, ids *TableIds) int64

func FriendRefusalMeasureBodyRetain

func FriendRefusalMeasureBodyRetain(value *FriendRefusal, ids *TableRetainIds) int64

func FriendRefusalMeasureReason

func FriendRefusalMeasureReason(value *FriendRefusal, context ...TableWriteContext) (int64, error)

func FriendRefusalMeasureRetain

func FriendRefusalMeasureRetain(value *FriendRefusal, retain *TableRetain, allocator ...TableAllocator) int64

func FriendRefusalOpen

func FriendRefusalOpen(cook *FriendRefusalCook, base unsafe.Pointer, length int64) bool

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

func FriendRefusalReset

func FriendRefusalReset(value *FriendRefusal)

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

func FriendRefusalSave

func FriendRefusalSave(value *FriendRefusal, buffer []byte, context ...TableWriteContext) int64

func FriendRefusalSaveBody

func FriendRefusalSaveBody(w *TableWriter, value *FriendRefusal) bool

func FriendRefusalSaveBodyFields

func FriendRefusalSaveBodyFields(w *TableWriter, value *FriendRefusal) bool

func FriendRefusalSaveBodyFieldsRetain

func FriendRefusalSaveBodyFieldsRetain(w *TableRetainWriter, value *FriendRefusal) bool

func FriendRefusalSaveBodyRetain

func FriendRefusalSaveBodyRetain(w *TableRetainWriter, value *FriendRefusal) bool

func FriendRefusalSaveMessageBody

func FriendRefusalSaveMessageBody(w *TableMessageWriter, value *FriendRefusal) bool

func FriendRefusalSaveRetain

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

func FriendRefusalSaveText

func FriendRefusalSaveText(value *FriendRefusal, context ...TableWriteContext) (string, error)

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

func FriendRefusalToJson

func FriendRefusalToJson(value *FriendRefusal, buffer []byte, allocator ...TableAllocator) int64

func FriendRefusalToJsonMeasure

func FriendRefusalToJsonMeasure(value *FriendRefusal, allocator ...TableAllocator) int64

func FriendStatusCookFrom

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

func FriendStatusCookMeasure

func FriendStatusCookMeasure(value *FriendStatus, context ...TableWriteContext) int64

func FriendStatusCookMeasureReason

func FriendStatusCookMeasureReason(value *FriendStatus, context ...TableWriteContext) (int64, error)

func FriendStatusFromJson

func FriendStatusFromJson(builder *FriendStatusBuilder, text []byte, report *TableReport) bool

func FriendStatusLoadBody

func FriendStatusLoadBody(r *TableReader, value *FriendStatus) bool

func FriendStatusLoadBodyRetain

func FriendStatusLoadBodyRetain(r *TableRetainReader, value *FriendStatus) bool

func FriendStatusLoadBuilder

func FriendStatusLoadBuilder(b *FriendStatusBuilder, wire []byte, report *TableReport) bool

func FriendStatusLoadMeasure

func FriendStatusLoadMeasure(wire []byte) int64

func FriendStatusLoadMeasureReason

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

func FriendStatusLoadMessageBody

func FriendStatusLoadMessageBody(r *TableMessageReader, value *FriendStatus) bool

func FriendStatusLoadMessageBodyRetain

func FriendStatusLoadMessageBodyRetain(r *TableRetainMessageReader, value *FriendStatus) bool

func FriendStatusMeasure

func FriendStatusMeasure(value *FriendStatus, context ...TableWriteContext) int64

func FriendStatusMeasureBody

func FriendStatusMeasureBody(value *FriendStatus, ids *TableIds) int64

func FriendStatusMeasureBodyRetain

func FriendStatusMeasureBodyRetain(value *FriendStatus, ids *TableRetainIds) int64

func FriendStatusMeasureReason

func FriendStatusMeasureReason(value *FriendStatus, context ...TableWriteContext) (int64, error)

func FriendStatusMeasureRetain

func FriendStatusMeasureRetain(value *FriendStatus, retain *TableRetain, allocator ...TableAllocator) int64

func FriendStatusOpen

func FriendStatusOpen(cook *FriendStatusCook, base unsafe.Pointer, length int64) bool

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

func FriendStatusRefusedEach

func FriendStatusRefusedEach(holder *TableList[FriendRefusalRow], visit func(*FriendRefusalRow) bool, arena ...*TableArena) bool

func FriendStatusRefusedErase

func FriendStatusRefusedErase(arena *TableArena, holder *TableList[FriendRefusalRow], element *FriendRefusalRow) bool

func FriendStatusReset

func FriendStatusReset(value *FriendStatus)

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

func FriendStatusSave

func FriendStatusSave(value *FriendStatus, buffer []byte, context ...TableWriteContext) int64

func FriendStatusSaveBody

func FriendStatusSaveBody(w *TableWriter, value *FriendStatus) bool

func FriendStatusSaveBodyFields

func FriendStatusSaveBodyFields(w *TableWriter, value *FriendStatus) bool

func FriendStatusSaveBodyFieldsRetain

func FriendStatusSaveBodyFieldsRetain(w *TableRetainWriter, value *FriendStatus) bool

func FriendStatusSaveBodyRetain

func FriendStatusSaveBodyRetain(w *TableRetainWriter, value *FriendStatus) bool

func FriendStatusSaveMessageBody

func FriendStatusSaveMessageBody(w *TableMessageWriter, value *FriendStatus) bool

func FriendStatusSaveRetain

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

func FriendStatusSaveText

func FriendStatusSaveText(value *FriendStatus, context ...TableWriteContext) (string, error)

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

func FriendStatusToJson

func FriendStatusToJson(value *FriendStatus, buffer []byte, allocator ...TableAllocator) int64

func FriendStatusToJsonMeasure

func FriendStatusToJsonMeasure(value *FriendStatus, allocator ...TableAllocator) int64

func FriendTaskCookFrom

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

func FriendTaskCookMeasure

func FriendTaskCookMeasure(value *FriendTask, context ...TableWriteContext) int64

func FriendTaskCookMeasureReason

func FriendTaskCookMeasureReason(value *FriendTask, context ...TableWriteContext) (int64, error)

func FriendTaskFromJson

func FriendTaskFromJson(builder *FriendTaskBuilder, text []byte, report *TableReport) bool

func FriendTaskLoadBody

func FriendTaskLoadBody(r *TableReader, value *FriendTask) bool

func FriendTaskLoadBodyRetain

func FriendTaskLoadBodyRetain(r *TableRetainReader, value *FriendTask) bool

func FriendTaskLoadBuilder

func FriendTaskLoadBuilder(b *FriendTaskBuilder, wire []byte, report *TableReport) bool

func FriendTaskLoadMeasure

func FriendTaskLoadMeasure(wire []byte) int64

func FriendTaskLoadMeasureReason

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

func FriendTaskLoadMessageBody

func FriendTaskLoadMessageBody(r *TableMessageReader, value *FriendTask) bool

func FriendTaskLoadMessageBodyRetain

func FriendTaskLoadMessageBodyRetain(r *TableRetainMessageReader, value *FriendTask) bool

func FriendTaskMeasure

func FriendTaskMeasure(value *FriendTask, context ...TableWriteContext) int64

func FriendTaskMeasureBody

func FriendTaskMeasureBody(value *FriendTask, ids *TableIds) int64

func FriendTaskMeasureBodyRetain

func FriendTaskMeasureBodyRetain(value *FriendTask, ids *TableRetainIds) int64

func FriendTaskMeasureReason

func FriendTaskMeasureReason(value *FriendTask, context ...TableWriteContext) (int64, error)

func FriendTaskMeasureRetain

func FriendTaskMeasureRetain(value *FriendTask, retain *TableRetain, allocator ...TableAllocator) int64

func FriendTaskOpen

func FriendTaskOpen(cook *FriendTaskCook, base unsafe.Pointer, length int64) bool

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

func FriendTaskReset

func FriendTaskReset(value *FriendTask)

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

func FriendTaskSave

func FriendTaskSave(value *FriendTask, buffer []byte, context ...TableWriteContext) int64

func FriendTaskSaveBody

func FriendTaskSaveBody(w *TableWriter, value *FriendTask) bool

func FriendTaskSaveBodyFields

func FriendTaskSaveBodyFields(w *TableWriter, value *FriendTask) bool

func FriendTaskSaveBodyFieldsRetain

func FriendTaskSaveBodyFieldsRetain(w *TableRetainWriter, value *FriendTask) bool

func FriendTaskSaveBodyRetain

func FriendTaskSaveBodyRetain(w *TableRetainWriter, value *FriendTask) bool

func FriendTaskSaveMessageBody

func FriendTaskSaveMessageBody(w *TableMessageWriter, value *FriendTask) bool

func FriendTaskSaveRetain

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

func FriendTaskSaveText

func FriendTaskSaveText(value *FriendTask, context ...TableWriteContext) (string, error)

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

func FriendTaskToJson

func FriendTaskToJson(value *FriendTask, buffer []byte, allocator ...TableAllocator) int64

func FriendTaskToJsonMeasure

func FriendTaskToJsonMeasure(value *FriendTask, allocator ...TableAllocator) int64

func FriendWatchCookFrom

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

func FriendWatchCookMeasure

func FriendWatchCookMeasure(value *FriendWatch, context ...TableWriteContext) int64

func FriendWatchCookMeasureReason

func FriendWatchCookMeasureReason(value *FriendWatch, context ...TableWriteContext) (int64, error)

func FriendWatchFromJson

func FriendWatchFromJson(builder *FriendWatchBuilder, text []byte, report *TableReport) bool

func FriendWatchLoadBody

func FriendWatchLoadBody(r *TableReader, value *FriendWatch) bool

func FriendWatchLoadBodyRetain

func FriendWatchLoadBodyRetain(r *TableRetainReader, value *FriendWatch) bool

func FriendWatchLoadBuilder

func FriendWatchLoadBuilder(b *FriendWatchBuilder, wire []byte, report *TableReport) bool

func FriendWatchLoadMeasure

func FriendWatchLoadMeasure(wire []byte) int64

func FriendWatchLoadMeasureReason

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

func FriendWatchLoadMessageBody

func FriendWatchLoadMessageBody(r *TableMessageReader, value *FriendWatch) bool

func FriendWatchLoadMessageBodyRetain

func FriendWatchLoadMessageBodyRetain(r *TableRetainMessageReader, value *FriendWatch) bool

func FriendWatchMeasure

func FriendWatchMeasure(value *FriendWatch, context ...TableWriteContext) int64

func FriendWatchMeasureBody

func FriendWatchMeasureBody(value *FriendWatch, ids *TableIds) int64

func FriendWatchMeasureBodyRetain

func FriendWatchMeasureBodyRetain(value *FriendWatch, ids *TableRetainIds) int64

func FriendWatchMeasureReason

func FriendWatchMeasureReason(value *FriendWatch, context ...TableWriteContext) (int64, error)

func FriendWatchMeasureRetain

func FriendWatchMeasureRetain(value *FriendWatch, retain *TableRetain, allocator ...TableAllocator) int64

func FriendWatchOpen

func FriendWatchOpen(cook *FriendWatchCook, base unsafe.Pointer, length int64) bool

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

func FriendWatchReset

func FriendWatchReset(value *FriendWatch)

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

func FriendWatchSave

func FriendWatchSave(value *FriendWatch, buffer []byte, context ...TableWriteContext) int64

func FriendWatchSaveBody

func FriendWatchSaveBody(w *TableWriter, value *FriendWatch) bool

func FriendWatchSaveBodyFields

func FriendWatchSaveBodyFields(w *TableWriter, value *FriendWatch) bool

func FriendWatchSaveBodyFieldsRetain

func FriendWatchSaveBodyFieldsRetain(w *TableRetainWriter, value *FriendWatch) bool

func FriendWatchSaveBodyRetain

func FriendWatchSaveBodyRetain(w *TableRetainWriter, value *FriendWatch) bool

func FriendWatchSaveMessageBody

func FriendWatchSaveMessageBody(w *TableMessageWriter, value *FriendWatch) bool

func FriendWatchSaveRetain

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

func FriendWatchSaveText

func FriendWatchSaveText(value *FriendWatch, context ...TableWriteContext) (string, error)

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

func FriendWatchToJson

func FriendWatchToJson(value *FriendWatch, buffer []byte, allocator ...TableAllocator) int64

func FriendWatchToJsonMeasure

func FriendWatchToJsonMeasure(value *FriendWatch, allocator ...TableAllocator) int64

func LaneEndCookFrom

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

func LaneEndCookMeasure

func LaneEndCookMeasure(value *LaneEnd, context ...TableWriteContext) int64

func LaneEndCookMeasureReason

func LaneEndCookMeasureReason(value *LaneEnd, context ...TableWriteContext) (int64, error)

func LaneEndFromJson

func LaneEndFromJson(builder *LaneEndBuilder, text []byte, report *TableReport) bool

func LaneEndLoadBody

func LaneEndLoadBody(r *TableReader, value *LaneEnd) bool

func LaneEndLoadBodyRetain

func LaneEndLoadBodyRetain(r *TableRetainReader, value *LaneEnd) bool

func LaneEndLoadBuilder

func LaneEndLoadBuilder(b *LaneEndBuilder, wire []byte, report *TableReport) bool

func LaneEndLoadMeasure

func LaneEndLoadMeasure(wire []byte) int64

func LaneEndLoadMeasureReason

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

func LaneEndLoadMessageBody

func LaneEndLoadMessageBody(r *TableMessageReader, value *LaneEnd) bool

func LaneEndLoadMessageBodyRetain

func LaneEndLoadMessageBodyRetain(r *TableRetainMessageReader, value *LaneEnd) bool

func LaneEndMeasure

func LaneEndMeasure(value *LaneEnd, context ...TableWriteContext) int64

func LaneEndMeasureBody

func LaneEndMeasureBody(value *LaneEnd, ids *TableIds) int64

func LaneEndMeasureBodyRetain

func LaneEndMeasureBodyRetain(value *LaneEnd, ids *TableRetainIds) int64

func LaneEndMeasureReason

func LaneEndMeasureReason(value *LaneEnd, context ...TableWriteContext) (int64, error)

func LaneEndMeasureRetain

func LaneEndMeasureRetain(value *LaneEnd, retain *TableRetain, allocator ...TableAllocator) int64

func LaneEndOpen

func LaneEndOpen(cook *LaneEndCook, base unsafe.Pointer, length int64) bool

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

func LaneEndReset

func LaneEndReset(value *LaneEnd)

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

func LaneEndSave

func LaneEndSave(value *LaneEnd, buffer []byte, context ...TableWriteContext) int64

func LaneEndSaveBody

func LaneEndSaveBody(w *TableWriter, value *LaneEnd) bool

func LaneEndSaveBodyFields

func LaneEndSaveBodyFields(w *TableWriter, value *LaneEnd) bool

func LaneEndSaveBodyFieldsRetain

func LaneEndSaveBodyFieldsRetain(w *TableRetainWriter, value *LaneEnd) bool

func LaneEndSaveBodyRetain

func LaneEndSaveBodyRetain(w *TableRetainWriter, value *LaneEnd) bool

func LaneEndSaveMessageBody

func LaneEndSaveMessageBody(w *TableMessageWriter, value *LaneEnd) bool

func LaneEndSaveRetain

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

func LaneEndSaveText

func LaneEndSaveText(value *LaneEnd, context ...TableWriteContext) (string, error)

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

func LaneEndToJson

func LaneEndToJson(value *LaneEnd, buffer []byte, allocator ...TableAllocator) int64

func LaneEndToJsonMeasure

func LaneEndToJsonMeasure(value *LaneEnd, allocator ...TableAllocator) int64

func NoticeEnvelopeCookFrom

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

func NoticeEnvelopeCookMeasure

func NoticeEnvelopeCookMeasure(value *NoticeEnvelope, context ...TableWriteContext) int64

func NoticeEnvelopeCookMeasureReason

func NoticeEnvelopeCookMeasureReason(value *NoticeEnvelope, context ...TableWriteContext) (int64, error)

func NoticeEnvelopeFromJson

func NoticeEnvelopeFromJson(builder *NoticeEnvelopeBuilder, text []byte, report *TableReport) bool

func NoticeEnvelopeLoadBody

func NoticeEnvelopeLoadBody(r *TableReader, value *NoticeEnvelope) bool

func NoticeEnvelopeLoadBodyRetain

func NoticeEnvelopeLoadBodyRetain(r *TableRetainReader, value *NoticeEnvelope) bool

func NoticeEnvelopeLoadBuilder

func NoticeEnvelopeLoadBuilder(b *NoticeEnvelopeBuilder, wire []byte, report *TableReport) bool

func NoticeEnvelopeLoadMeasure

func NoticeEnvelopeLoadMeasure(wire []byte) int64

func NoticeEnvelopeLoadMeasureReason

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

func NoticeEnvelopeLoadMessageBody

func NoticeEnvelopeLoadMessageBody(r *TableMessageReader, value *NoticeEnvelope) bool

func NoticeEnvelopeLoadMessageBodyRetain

func NoticeEnvelopeLoadMessageBodyRetain(r *TableRetainMessageReader, value *NoticeEnvelope) bool

func NoticeEnvelopeMeasure

func NoticeEnvelopeMeasure(value *NoticeEnvelope, context ...TableWriteContext) int64

func NoticeEnvelopeMeasureBody

func NoticeEnvelopeMeasureBody(value *NoticeEnvelope, ids *TableIds) int64

func NoticeEnvelopeMeasureBodyRetain

func NoticeEnvelopeMeasureBodyRetain(value *NoticeEnvelope, ids *TableRetainIds) int64

func NoticeEnvelopeMeasureReason

func NoticeEnvelopeMeasureReason(value *NoticeEnvelope, context ...TableWriteContext) (int64, error)

func NoticeEnvelopeMeasureRetain

func NoticeEnvelopeMeasureRetain(value *NoticeEnvelope, retain *TableRetain, allocator ...TableAllocator) int64

func NoticeEnvelopeOpen

func NoticeEnvelopeOpen(cook *NoticeEnvelopeCook, base unsafe.Pointer, length int64) bool

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

func NoticeEnvelopeRecoveryMessagesEach

func NoticeEnvelopeRecoveryMessagesEach(holder *TableList[NoticeMessageRow], visit func(*NoticeMessageRow) bool, arena ...*TableArena) bool

func NoticeEnvelopeRecoveryMessagesErase

func NoticeEnvelopeRecoveryMessagesErase(arena *TableArena, holder *TableList[NoticeMessageRow], element *NoticeMessageRow) bool

func NoticeEnvelopeReset

func NoticeEnvelopeReset(value *NoticeEnvelope)

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

func NoticeEnvelopeSave

func NoticeEnvelopeSave(value *NoticeEnvelope, buffer []byte, context ...TableWriteContext) int64

func NoticeEnvelopeSaveBody

func NoticeEnvelopeSaveBody(w *TableWriter, value *NoticeEnvelope) bool

func NoticeEnvelopeSaveBodyFields

func NoticeEnvelopeSaveBodyFields(w *TableWriter, value *NoticeEnvelope) bool

func NoticeEnvelopeSaveBodyFieldsRetain

func NoticeEnvelopeSaveBodyFieldsRetain(w *TableRetainWriter, value *NoticeEnvelope) bool

func NoticeEnvelopeSaveBodyRetain

func NoticeEnvelopeSaveBodyRetain(w *TableRetainWriter, value *NoticeEnvelope) bool

func NoticeEnvelopeSaveMessageBody

func NoticeEnvelopeSaveMessageBody(w *TableMessageWriter, value *NoticeEnvelope) bool

func NoticeEnvelopeSaveRetain

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

func NoticeEnvelopeSaveText

func NoticeEnvelopeSaveText(value *NoticeEnvelope, context ...TableWriteContext) (string, error)

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

func NoticeEnvelopeSendersEach

func NoticeEnvelopeSendersEach(holder *TableList[NoticeNameRow], visit func(*NoticeNameRow) bool, arena ...*TableArena) bool

func NoticeEnvelopeSendersErase

func NoticeEnvelopeSendersErase(arena *TableArena, holder *TableList[NoticeNameRow], element *NoticeNameRow) bool

func NoticeEnvelopeToJson

func NoticeEnvelopeToJson(value *NoticeEnvelope, buffer []byte, allocator ...TableAllocator) int64

func NoticeEnvelopeToJsonMeasure

func NoticeEnvelopeToJsonMeasure(value *NoticeEnvelope, allocator ...TableAllocator) int64

func NoticeMarkCookFrom

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

func NoticeMarkCookMeasure

func NoticeMarkCookMeasure(value *NoticeMark, context ...TableWriteContext) int64

func NoticeMarkCookMeasureReason

func NoticeMarkCookMeasureReason(value *NoticeMark, context ...TableWriteContext) (int64, error)

func NoticeMarkFromJson

func NoticeMarkFromJson(builder *NoticeMarkBuilder, text []byte, report *TableReport) bool

func NoticeMarkLoadBody

func NoticeMarkLoadBody(r *TableReader, value *NoticeMark) bool

func NoticeMarkLoadBodyRetain

func NoticeMarkLoadBodyRetain(r *TableRetainReader, value *NoticeMark) bool

func NoticeMarkLoadBuilder

func NoticeMarkLoadBuilder(b *NoticeMarkBuilder, wire []byte, report *TableReport) bool

func NoticeMarkLoadMeasure

func NoticeMarkLoadMeasure(wire []byte) int64

func NoticeMarkLoadMeasureReason

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

func NoticeMarkLoadMessageBody

func NoticeMarkLoadMessageBody(r *TableMessageReader, value *NoticeMark) bool

func NoticeMarkLoadMessageBodyRetain

func NoticeMarkLoadMessageBodyRetain(r *TableRetainMessageReader, value *NoticeMark) bool

func NoticeMarkMeasure

func NoticeMarkMeasure(value *NoticeMark, context ...TableWriteContext) int64

func NoticeMarkMeasureBody

func NoticeMarkMeasureBody(value *NoticeMark, ids *TableIds) int64

func NoticeMarkMeasureBodyRetain

func NoticeMarkMeasureBodyRetain(value *NoticeMark, ids *TableRetainIds) int64

func NoticeMarkMeasureReason

func NoticeMarkMeasureReason(value *NoticeMark, context ...TableWriteContext) (int64, error)

func NoticeMarkMeasureRetain

func NoticeMarkMeasureRetain(value *NoticeMark, retain *TableRetain, allocator ...TableAllocator) int64

func NoticeMarkOpen

func NoticeMarkOpen(cook *NoticeMarkCook, base unsafe.Pointer, length int64) bool

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

func NoticeMarkReset

func NoticeMarkReset(value *NoticeMark)

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

func NoticeMarkSave

func NoticeMarkSave(value *NoticeMark, buffer []byte, context ...TableWriteContext) int64

func NoticeMarkSaveBody

func NoticeMarkSaveBody(w *TableWriter, value *NoticeMark) bool

func NoticeMarkSaveBodyFields

func NoticeMarkSaveBodyFields(w *TableWriter, value *NoticeMark) bool

func NoticeMarkSaveBodyFieldsRetain

func NoticeMarkSaveBodyFieldsRetain(w *TableRetainWriter, value *NoticeMark) bool

func NoticeMarkSaveBodyRetain

func NoticeMarkSaveBodyRetain(w *TableRetainWriter, value *NoticeMark) bool

func NoticeMarkSaveMessageBody

func NoticeMarkSaveMessageBody(w *TableMessageWriter, value *NoticeMark) bool

func NoticeMarkSaveRetain

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

func NoticeMarkSaveText

func NoticeMarkSaveText(value *NoticeMark, context ...TableWriteContext) (string, error)

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

func NoticeMarkToJson

func NoticeMarkToJson(value *NoticeMark, buffer []byte, allocator ...TableAllocator) int64

func NoticeMarkToJsonMeasure

func NoticeMarkToJsonMeasure(value *NoticeMark, allocator ...TableAllocator) int64

func NoticeMessageCcEach

func NoticeMessageCcEach(holder *TableList[NoticeNameRow], visit func(*NoticeNameRow) bool, arena ...*TableArena) bool

func NoticeMessageCcErase

func NoticeMessageCcErase(arena *TableArena, holder *TableList[NoticeNameRow], element *NoticeNameRow) bool

func NoticeMessageCookFrom

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

func NoticeMessageCookMeasure

func NoticeMessageCookMeasure(value *NoticeMessage, context ...TableWriteContext) int64

func NoticeMessageCookMeasureReason

func NoticeMessageCookMeasureReason(value *NoticeMessage, context ...TableWriteContext) (int64, error)

func NoticeMessageFromJson

func NoticeMessageFromJson(builder *NoticeMessageBuilder, text []byte, report *TableReport) bool

func NoticeMessageLoadBody

func NoticeMessageLoadBody(r *TableReader, value *NoticeMessage) bool

func NoticeMessageLoadBodyRetain

func NoticeMessageLoadBodyRetain(r *TableRetainReader, value *NoticeMessage) bool

func NoticeMessageLoadBuilder

func NoticeMessageLoadBuilder(b *NoticeMessageBuilder, wire []byte, report *TableReport) bool

func NoticeMessageLoadMeasure

func NoticeMessageLoadMeasure(wire []byte) int64

func NoticeMessageLoadMeasureReason

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

func NoticeMessageLoadMessageBody

func NoticeMessageLoadMessageBody(r *TableMessageReader, value *NoticeMessage) bool

func NoticeMessageLoadMessageBodyRetain

func NoticeMessageLoadMessageBodyRetain(r *TableRetainMessageReader, value *NoticeMessage) bool

func NoticeMessageMarksEach

func NoticeMessageMarksEach(holder *TableList[NoticeMarkRow], visit func(*NoticeMarkRow) bool, arena ...*TableArena) bool

func NoticeMessageMarksErase

func NoticeMessageMarksErase(arena *TableArena, holder *TableList[NoticeMarkRow], element *NoticeMarkRow) bool

func NoticeMessageMeasure

func NoticeMessageMeasure(value *NoticeMessage, context ...TableWriteContext) int64

func NoticeMessageMeasureBody

func NoticeMessageMeasureBody(value *NoticeMessage, ids *TableIds) int64

func NoticeMessageMeasureBodyRetain

func NoticeMessageMeasureBodyRetain(value *NoticeMessage, ids *TableRetainIds) int64

func NoticeMessageMeasureReason

func NoticeMessageMeasureReason(value *NoticeMessage, context ...TableWriteContext) (int64, error)

func NoticeMessageMeasureRetain

func NoticeMessageMeasureRetain(value *NoticeMessage, retain *TableRetain, allocator ...TableAllocator) int64

func NoticeMessageOpen

func NoticeMessageOpen(cook *NoticeMessageCook, base unsafe.Pointer, length int64) bool

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

func NoticeMessageReset

func NoticeMessageReset(value *NoticeMessage)

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

func NoticeMessageSave

func NoticeMessageSave(value *NoticeMessage, buffer []byte, context ...TableWriteContext) int64

func NoticeMessageSaveBody

func NoticeMessageSaveBody(w *TableWriter, value *NoticeMessage) bool

func NoticeMessageSaveBodyFields

func NoticeMessageSaveBodyFields(w *TableWriter, value *NoticeMessage) bool

func NoticeMessageSaveBodyFieldsRetain

func NoticeMessageSaveBodyFieldsRetain(w *TableRetainWriter, value *NoticeMessage) bool

func NoticeMessageSaveBodyRetain

func NoticeMessageSaveBodyRetain(w *TableRetainWriter, value *NoticeMessage) bool

func NoticeMessageSaveMessageBody

func NoticeMessageSaveMessageBody(w *TableMessageWriter, value *NoticeMessage) bool

func NoticeMessageSaveRetain

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

func NoticeMessageSaveText

func NoticeMessageSaveText(value *NoticeMessage, context ...TableWriteContext) (string, error)

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

func NoticeMessageToEach

func NoticeMessageToEach(holder *TableList[NoticeNameRow], visit func(*NoticeNameRow) bool, arena ...*TableArena) bool

func NoticeMessageToErase

func NoticeMessageToErase(arena *TableArena, holder *TableList[NoticeNameRow], element *NoticeNameRow) bool

func NoticeMessageToJson

func NoticeMessageToJson(value *NoticeMessage, buffer []byte, allocator ...TableAllocator) int64

func NoticeMessageToJsonMeasure

func NoticeMessageToJsonMeasure(value *NoticeMessage, allocator ...TableAllocator) int64

func NoticeNameCookFrom

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

func NoticeNameCookMeasure

func NoticeNameCookMeasure(value *NoticeName, context ...TableWriteContext) int64

func NoticeNameCookMeasureReason

func NoticeNameCookMeasureReason(value *NoticeName, context ...TableWriteContext) (int64, error)

func NoticeNameFromJson

func NoticeNameFromJson(builder *NoticeNameBuilder, text []byte, report *TableReport) bool

func NoticeNameLoadBody

func NoticeNameLoadBody(r *TableReader, value *NoticeName) bool

func NoticeNameLoadBodyRetain

func NoticeNameLoadBodyRetain(r *TableRetainReader, value *NoticeName) bool

func NoticeNameLoadBuilder

func NoticeNameLoadBuilder(b *NoticeNameBuilder, wire []byte, report *TableReport) bool

func NoticeNameLoadMeasure

func NoticeNameLoadMeasure(wire []byte) int64

func NoticeNameLoadMeasureReason

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

func NoticeNameLoadMessageBody

func NoticeNameLoadMessageBody(r *TableMessageReader, value *NoticeName) bool

func NoticeNameLoadMessageBodyRetain

func NoticeNameLoadMessageBodyRetain(r *TableRetainMessageReader, value *NoticeName) bool

func NoticeNameMeasure

func NoticeNameMeasure(value *NoticeName, context ...TableWriteContext) int64

func NoticeNameMeasureBody

func NoticeNameMeasureBody(value *NoticeName, ids *TableIds) int64

func NoticeNameMeasureBodyRetain

func NoticeNameMeasureBodyRetain(value *NoticeName, ids *TableRetainIds) int64

func NoticeNameMeasureReason

func NoticeNameMeasureReason(value *NoticeName, context ...TableWriteContext) (int64, error)

func NoticeNameMeasureRetain

func NoticeNameMeasureRetain(value *NoticeName, retain *TableRetain, allocator ...TableAllocator) int64

func NoticeNameOpen

func NoticeNameOpen(cook *NoticeNameCook, base unsafe.Pointer, length int64) bool

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

func NoticeNameReset

func NoticeNameReset(value *NoticeName)

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

func NoticeNameSave

func NoticeNameSave(value *NoticeName, buffer []byte, context ...TableWriteContext) int64

func NoticeNameSaveBody

func NoticeNameSaveBody(w *TableWriter, value *NoticeName) bool

func NoticeNameSaveBodyFields

func NoticeNameSaveBodyFields(w *TableWriter, value *NoticeName) bool

func NoticeNameSaveBodyFieldsRetain

func NoticeNameSaveBodyFieldsRetain(w *TableRetainWriter, value *NoticeName) bool

func NoticeNameSaveBodyRetain

func NoticeNameSaveBodyRetain(w *TableRetainWriter, value *NoticeName) bool

func NoticeNameSaveMessageBody

func NoticeNameSaveMessageBody(w *TableMessageWriter, value *NoticeName) bool

func NoticeNameSaveRetain

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

func NoticeNameSaveText

func NoticeNameSaveText(value *NoticeName, context ...TableWriteContext) (string, error)

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

func NoticeNameToJson

func NoticeNameToJson(value *NoticeName, buffer []byte, allocator ...TableAllocator) int64

func NoticeNameToJsonMeasure

func NoticeNameToJsonMeasure(value *NoticeName, allocator ...TableAllocator) int64

func NoticeReceiverCookFrom

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

func NoticeReceiverCookMeasure

func NoticeReceiverCookMeasure(value *NoticeReceiver, context ...TableWriteContext) int64

func NoticeReceiverCookMeasureReason

func NoticeReceiverCookMeasureReason(value *NoticeReceiver, context ...TableWriteContext) (int64, error)

func NoticeReceiverFromJson

func NoticeReceiverFromJson(builder *NoticeReceiverBuilder, text []byte, report *TableReport) bool

func NoticeReceiverLoadBody

func NoticeReceiverLoadBody(r *TableReader, value *NoticeReceiver) bool

func NoticeReceiverLoadBodyRetain

func NoticeReceiverLoadBodyRetain(r *TableRetainReader, value *NoticeReceiver) bool

func NoticeReceiverLoadBuilder

func NoticeReceiverLoadBuilder(b *NoticeReceiverBuilder, wire []byte, report *TableReport) bool

func NoticeReceiverLoadMeasure

func NoticeReceiverLoadMeasure(wire []byte) int64

func NoticeReceiverLoadMeasureReason

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

func NoticeReceiverLoadMessageBody

func NoticeReceiverLoadMessageBody(r *TableMessageReader, value *NoticeReceiver) bool

func NoticeReceiverLoadMessageBodyRetain

func NoticeReceiverLoadMessageBodyRetain(r *TableRetainMessageReader, value *NoticeReceiver) bool

func NoticeReceiverMeasure

func NoticeReceiverMeasure(value *NoticeReceiver, context ...TableWriteContext) int64

func NoticeReceiverMeasureBody

func NoticeReceiverMeasureBody(value *NoticeReceiver, ids *TableIds) int64

func NoticeReceiverMeasureBodyRetain

func NoticeReceiverMeasureBodyRetain(value *NoticeReceiver, ids *TableRetainIds) int64

func NoticeReceiverMeasureReason

func NoticeReceiverMeasureReason(value *NoticeReceiver, context ...TableWriteContext) (int64, error)

func NoticeReceiverMeasureRetain

func NoticeReceiverMeasureRetain(value *NoticeReceiver, retain *TableRetain, allocator ...TableAllocator) int64

func NoticeReceiverOpen

func NoticeReceiverOpen(cook *NoticeReceiverCook, base unsafe.Pointer, length int64) bool

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

func NoticeReceiverReset

func NoticeReceiverReset(value *NoticeReceiver)

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

func NoticeReceiverSave

func NoticeReceiverSave(value *NoticeReceiver, buffer []byte, context ...TableWriteContext) int64

func NoticeReceiverSaveBody

func NoticeReceiverSaveBody(w *TableWriter, value *NoticeReceiver) bool

func NoticeReceiverSaveBodyFields

func NoticeReceiverSaveBodyFields(w *TableWriter, value *NoticeReceiver) bool

func NoticeReceiverSaveBodyFieldsRetain

func NoticeReceiverSaveBodyFieldsRetain(w *TableRetainWriter, value *NoticeReceiver) bool

func NoticeReceiverSaveBodyRetain

func NoticeReceiverSaveBodyRetain(w *TableRetainWriter, value *NoticeReceiver) bool

func NoticeReceiverSaveMessageBody

func NoticeReceiverSaveMessageBody(w *TableMessageWriter, value *NoticeReceiver) bool

func NoticeReceiverSaveRetain

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

func NoticeReceiverSaveText

func NoticeReceiverSaveText(value *NoticeReceiver, context ...TableWriteContext) (string, error)

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

func NoticeReceiverToJson

func NoticeReceiverToJson(value *NoticeReceiver, buffer []byte, allocator ...TableAllocator) int64

func NoticeReceiverToJsonMeasure

func NoticeReceiverToJsonMeasure(value *NoticeReceiver, allocator ...TableAllocator) int64

func TableBytesEmplace

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

func TableStringEmplace

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

Types

type Delivery

type Delivery = DeliveryRow

func DeliveryLoad

func DeliveryLoad(region, wire []byte, report *TableReport) *Delivery

func DeliveryLoadRetain

func DeliveryLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *Delivery

func DeliveryLoadText

func DeliveryLoadText(text string, report *TableReport) (*Delivery, error)

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

func DeliveryReadStrict

func DeliveryReadStrict(wire []byte) (*Delivery, error)

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

type DeliveryBuilder

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

func (*DeliveryBuilder) AsConst

func (b *DeliveryBuilder) AsConst() *Delivery

func (*DeliveryBuilder) GetRoot

func (b *DeliveryBuilder) GetRoot() *Delivery

func (*DeliveryBuilder) Init

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

func (*DeliveryBuilder) Lock

func (b *DeliveryBuilder) Lock() bool

func (*DeliveryBuilder) PackMeasure

func (b *DeliveryBuilder) PackMeasure() int64

func (*DeliveryBuilder) PackMeasureReason

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

func (*DeliveryBuilder) Region

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

func (*DeliveryBuilder) Shutdown

func (b *DeliveryBuilder) Shutdown()

type DeliveryCard

type DeliveryCard = DeliveryCardRow

func DeliveryCardLoad

func DeliveryCardLoad(region, wire []byte, report *TableReport) *DeliveryCard

func DeliveryCardLoadRetain

func DeliveryCardLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *DeliveryCard

func DeliveryCardLoadText

func DeliveryCardLoadText(text string, report *TableReport) (*DeliveryCard, error)

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

func DeliveryCardReadStrict

func DeliveryCardReadStrict(wire []byte) (*DeliveryCard, error)

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

type DeliveryCardBuilder

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

func (*DeliveryCardBuilder) AsConst

func (b *DeliveryCardBuilder) AsConst() *DeliveryCard

func (*DeliveryCardBuilder) GetRoot

func (b *DeliveryCardBuilder) GetRoot() *DeliveryCard

func (*DeliveryCardBuilder) Init

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

func (*DeliveryCardBuilder) Lock

func (b *DeliveryCardBuilder) Lock() bool

func (*DeliveryCardBuilder) PackMeasure

func (b *DeliveryCardBuilder) PackMeasure() int64

func (*DeliveryCardBuilder) PackMeasureReason

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

func (*DeliveryCardBuilder) Region

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

func (*DeliveryCardBuilder) Shutdown

func (b *DeliveryCardBuilder) Shutdown()

type DeliveryCardCook

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

DeliveryCardCook is DeliveryCard'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 — DeliveryCardOpen, DeliveryCardAt — 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 (*DeliveryCardCook) Open

func (cook *DeliveryCardCook) 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 (DeliveryCardCook) RegionAlignment

func (c DeliveryCardCook) 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 (DeliveryCardCook) 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 (DeliveryCardCook) RootAlign

func (c DeliveryCardCook) RootAlign() int64

func (DeliveryCardCook) RootSize

func (c DeliveryCardCook) RootSize() int64

func (DeliveryCardCook) Type

func (c DeliveryCardCook) Type() *TableCookInfo

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

type DeliveryCardRow

type DeliveryCardRow struct {
	Card int64     // *: signed self-relative delta, zero is null (§6.3)
	Job  [201]byte // string(200): buffer, used length beside it

	JobLength int32
	Col       int64 // *: signed self-relative delta, zero is null (§6.3)
	Kind      int64 // *: signed self-relative delta, zero is null (§6.3)
	Branch    int64 // *: signed self-relative delta, zero is null (§6.3)
	Tier      int64 // *: signed self-relative delta, zero is null (§6.3)
	Stream    int64 // *: signed self-relative delta, zero is null (§6.3)
	Attempt   int64
	Gen       int64
	Epoch     uint64
	Repo      int64 // *: signed self-relative delta, zero is null (§6.3)
	BaseRef   int64 // *: signed self-relative delta, zero is null (§6.3)
	Brief     int64 // *: signed self-relative delta, zero is null (§6.3)
	Lane      int64
	// contains filtered or unexported fields
}

DeliveryCardRow — 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 DeliveryCardAt

func DeliveryCardAt(slot *int64, arena ...*TableArena) *DeliveryCardRow

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

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

func DeliveryCardsAdd

func DeliveryCardsAdd(worker *TableWorker, holder *TableList[DeliveryCardRow]) *DeliveryCardRow

type DeliveryCook

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

DeliveryCook is Delivery'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 — DeliveryOpen, DeliveryAt — 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 (*DeliveryCook) Open

func (cook *DeliveryCook) 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 (DeliveryCook) RegionAlignment

func (c DeliveryCook) 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 (DeliveryCook) Root

func (c DeliveryCook) Root() *DeliveryRow

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 (DeliveryCook) RootAlign

func (c DeliveryCook) RootAlign() int64

func (DeliveryCook) RootSize

func (c DeliveryCook) RootSize() int64

func (DeliveryCook) Type

func (c DeliveryCook) Type() *TableCookInfo

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

type DeliveryRow

type DeliveryRow struct {
	FriendName int64 // *: signed self-relative delta, zero is null (§6.3)
	Cards      TableList[DeliveryCardRow]
}

DeliveryRow — 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 DeliveryAt

func DeliveryAt(slot *int64, arena ...*TableArena) *DeliveryRow

DeliveryAt 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 FriendQueue

type FriendQueue = FriendQueueRow

func FriendQueueLoad

func FriendQueueLoad(region, wire []byte, report *TableReport) *FriendQueue

func FriendQueueLoadRetain

func FriendQueueLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *FriendQueue

func FriendQueueLoadText

func FriendQueueLoadText(text string, report *TableReport) (*FriendQueue, error)

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

func FriendQueueReadStrict

func FriendQueueReadStrict(wire []byte) (*FriendQueue, error)

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

type FriendQueueBuilder

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

func (*FriendQueueBuilder) AsConst

func (b *FriendQueueBuilder) AsConst() *FriendQueue

func (*FriendQueueBuilder) GetRoot

func (b *FriendQueueBuilder) GetRoot() *FriendQueue

func (*FriendQueueBuilder) Init

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

func (*FriendQueueBuilder) Lock

func (b *FriendQueueBuilder) Lock() bool

func (*FriendQueueBuilder) PackMeasure

func (b *FriendQueueBuilder) PackMeasure() int64

func (*FriendQueueBuilder) PackMeasureReason

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

func (*FriendQueueBuilder) Region

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

func (*FriendQueueBuilder) Shutdown

func (b *FriendQueueBuilder) Shutdown()

type FriendQueueCook

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

FriendQueueCook is FriendQueue'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 — FriendQueueOpen, FriendQueueAt — 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 (*FriendQueueCook) Open

func (cook *FriendQueueCook) 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 (FriendQueueCook) RegionAlignment

func (c FriendQueueCook) 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 (FriendQueueCook) Root

func (c FriendQueueCook) Root() *FriendQueueRow

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 (FriendQueueCook) RootAlign

func (c FriendQueueCook) RootAlign() int64

func (FriendQueueCook) RootSize

func (c FriendQueueCook) RootSize() int64

func (FriendQueueCook) Type

func (c FriendQueueCook) Type() *TableCookInfo

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

type FriendQueueRow

type FriendQueueRow struct {
	Tasks TableList[FriendTaskRow]
}

FriendQueueRow — 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 FriendQueueAt

func FriendQueueAt(slot *int64, arena ...*TableArena) *FriendQueueRow

FriendQueueAt 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 FriendRefusal

type FriendRefusal = FriendRefusalRow

func FriendRefusalLoad

func FriendRefusalLoad(region, wire []byte, report *TableReport) *FriendRefusal

func FriendRefusalLoadRetain

func FriendRefusalLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *FriendRefusal

func FriendRefusalLoadText

func FriendRefusalLoadText(text string, report *TableReport) (*FriendRefusal, error)

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

func FriendRefusalReadStrict

func FriendRefusalReadStrict(wire []byte) (*FriendRefusal, error)

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

type FriendRefusalBuilder

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

func (*FriendRefusalBuilder) AsConst

func (b *FriendRefusalBuilder) AsConst() *FriendRefusal

func (*FriendRefusalBuilder) GetRoot

func (b *FriendRefusalBuilder) GetRoot() *FriendRefusal

func (*FriendRefusalBuilder) Init

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

func (*FriendRefusalBuilder) Lock

func (b *FriendRefusalBuilder) Lock() bool

func (*FriendRefusalBuilder) PackMeasure

func (b *FriendRefusalBuilder) PackMeasure() int64

func (*FriendRefusalBuilder) PackMeasureReason

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

func (*FriendRefusalBuilder) Region

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

func (*FriendRefusalBuilder) Shutdown

func (b *FriendRefusalBuilder) Shutdown()

type FriendRefusalCook

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

FriendRefusalCook is FriendRefusal'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 — FriendRefusalOpen, FriendRefusalAt — 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 (*FriendRefusalCook) Open

func (cook *FriendRefusalCook) 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 (FriendRefusalCook) RegionAlignment

func (c FriendRefusalCook) 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 (FriendRefusalCook) 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 (FriendRefusalCook) RootAlign

func (c FriendRefusalCook) RootAlign() int64

func (FriendRefusalCook) RootSize

func (c FriendRefusalCook) RootSize() int64

func (FriendRefusalCook) Type

func (c FriendRefusalCook) Type() *TableCookInfo

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

type FriendRefusalRow

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

FriendRefusalRow — 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 FriendRefusalAt

func FriendRefusalAt(slot *int64, arena ...*TableArena) *FriendRefusalRow

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

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

func FriendStatusRefusedAdd

func FriendStatusRefusedAdd(worker *TableWorker, holder *TableList[FriendRefusalRow]) *FriendRefusalRow

type FriendStatus

type FriendStatus = FriendStatusRow

func FriendStatusLoad

func FriendStatusLoad(region, wire []byte, report *TableReport) *FriendStatus

func FriendStatusLoadRetain

func FriendStatusLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *FriendStatus

func FriendStatusLoadText

func FriendStatusLoadText(text string, report *TableReport) (*FriendStatus, error)

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

func FriendStatusReadStrict

func FriendStatusReadStrict(wire []byte) (*FriendStatus, error)

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

type FriendStatusBuilder

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

func (*FriendStatusBuilder) AsConst

func (b *FriendStatusBuilder) AsConst() *FriendStatus

func (*FriendStatusBuilder) GetRoot

func (b *FriendStatusBuilder) GetRoot() *FriendStatus

func (*FriendStatusBuilder) Init

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

func (*FriendStatusBuilder) Lock

func (b *FriendStatusBuilder) Lock() bool

func (*FriendStatusBuilder) PackMeasure

func (b *FriendStatusBuilder) PackMeasure() int64

func (*FriendStatusBuilder) PackMeasureReason

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

func (*FriendStatusBuilder) Region

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

func (*FriendStatusBuilder) Shutdown

func (b *FriendStatusBuilder) Shutdown()

type FriendStatusCook

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

FriendStatusCook is FriendStatus'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 — FriendStatusOpen, FriendStatusAt — 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 (*FriendStatusCook) Open

func (cook *FriendStatusCook) 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 (FriendStatusCook) RegionAlignment

func (c FriendStatusCook) 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 (FriendStatusCook) 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 (FriendStatusCook) RootAlign

func (c FriendStatusCook) RootAlign() int64

func (FriendStatusCook) RootSize

func (c FriendStatusCook) RootSize() int64

func (FriendStatusCook) Type

func (c FriendStatusCook) Type() *TableCookInfo

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

type FriendStatusRow

type FriendStatusRow struct {
	FriendName    int64 // *: signed self-relative delta, zero is null (§6.3)
	Harness       int64 // *: signed self-relative delta, zero is null (§6.3)
	Started       int64 // *: signed self-relative delta, zero is null (§6.3)
	At            int64 // *: signed self-relative delta, zero is null (§6.3)
	Seat          int64 // *: signed self-relative delta, zero is null (§6.3)
	Beats         int64
	LastBeat      int64 // *: signed self-relative delta, zero is null (§6.3)
	BeatError     int64 // *: signed self-relative delta, zero is null (§6.3)
	StoreError    int64 // *: signed self-relative delta, zero is null (§6.3)
	Width         int64
	Session       int64 // *: signed self-relative delta, zero is null (§6.3)
	SessionId     int64 // *: signed self-relative delta, zero is null (§6.3)
	SessionReason int64 // *: signed self-relative delta, zero is null (§6.3)
	BrokenAt      int64 // *: signed self-relative delta, zero is null (§6.3)
	LimitKind     int64 // *: signed self-relative delta, zero is null (§6.3)
	LimitUntil    int64 // *: signed self-relative delta, zero is null (§6.3)
	Mode          int64 // *: signed self-relative delta, zero is null (§6.3)
	Lanes         int64 // *: signed self-relative delta, zero is null (§6.3)
	Paced         int64
	PacedPresent  bool // ?: one byte, in Go's model as in C++

	Window    int64 // *: signed self-relative delta, zero is null (§6.3)
	Pacing    int64 // *: signed self-relative delta, zero is null (§6.3)
	HeldKnown bool

	Held          int64
	Inbox         int64
	Missing       int64
	InboxError    int64 // *: signed self-relative delta, zero is null (§6.3)
	HeldFrom      int64 // *: signed self-relative delta, zero is null (§6.3)
	Refused       TableList[FriendRefusalRow]
	LastRefusal   int64 // *: signed self-relative delta, zero is null (§6.3)
	LastRefusalAt int64 // *: signed self-relative delta, zero is null (§6.3)
	Proof         int64 // *: signed self-relative delta, zero is null (§6.3)
	ProofAt       int64 // *: signed self-relative delta, zero is null (§6.3)
	// contains filtered or unexported fields
}

FriendStatusRow — 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 FriendStatusAt

func FriendStatusAt(slot *int64, arena ...*TableArena) *FriendStatusRow

FriendStatusAt 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 FriendTask

type FriendTask = FriendTaskRow

func FriendTaskLoad

func FriendTaskLoad(region, wire []byte, report *TableReport) *FriendTask

func FriendTaskLoadRetain

func FriendTaskLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *FriendTask

func FriendTaskLoadText

func FriendTaskLoadText(text string, report *TableReport) (*FriendTask, error)

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

func FriendTaskReadStrict

func FriendTaskReadStrict(wire []byte) (*FriendTask, error)

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

type FriendTaskBuilder

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

func (*FriendTaskBuilder) AsConst

func (b *FriendTaskBuilder) AsConst() *FriendTask

func (*FriendTaskBuilder) GetRoot

func (b *FriendTaskBuilder) GetRoot() *FriendTask

func (*FriendTaskBuilder) Init

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

func (*FriendTaskBuilder) Lock

func (b *FriendTaskBuilder) Lock() bool

func (*FriendTaskBuilder) PackMeasure

func (b *FriendTaskBuilder) PackMeasure() int64

func (*FriendTaskBuilder) PackMeasureReason

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

func (*FriendTaskBuilder) Region

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

func (*FriendTaskBuilder) Shutdown

func (b *FriendTaskBuilder) Shutdown()

type FriendTaskCook

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

FriendTaskCook is FriendTask'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 — FriendTaskOpen, FriendTaskAt — 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 (*FriendTaskCook) Open

func (cook *FriendTaskCook) 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 (FriendTaskCook) RegionAlignment

func (c FriendTaskCook) 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 (FriendTaskCook) Root

func (c FriendTaskCook) Root() *FriendTaskRow

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 (FriendTaskCook) RootAlign

func (c FriendTaskCook) RootAlign() int64

func (FriendTaskCook) RootSize

func (c FriendTaskCook) RootSize() int64

func (FriendTaskCook) Type

func (c FriendTaskCook) Type() *TableCookInfo

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

type FriendTaskRow

type FriendTaskRow struct {
	Gen         int64
	Job         int64 // *: signed self-relative delta, zero is null (§6.3)
	Id          int64 // *: signed self-relative delta, zero is null (§6.3)
	State       int64 // *: signed self-relative delta, zero is null (§6.3)
	Deliverable int64 // *: signed self-relative delta, zero is null (§6.3)
}

FriendTaskRow — 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 FriendQueueTasksAdd

func FriendQueueTasksAdd(worker *TableWorker, holder *TableList[FriendTaskRow]) *FriendTaskRow

func FriendTaskAt

func FriendTaskAt(slot *int64, arena ...*TableArena) *FriendTaskRow

FriendTaskAt 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 FriendWatch

type FriendWatch = FriendWatchRow

func FriendWatchLoad

func FriendWatchLoad(region, wire []byte, report *TableReport) *FriendWatch

func FriendWatchLoadRetain

func FriendWatchLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *FriendWatch

func FriendWatchLoadText

func FriendWatchLoadText(text string, report *TableReport) (*FriendWatch, error)

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

func FriendWatchReadStrict

func FriendWatchReadStrict(wire []byte) (*FriendWatch, error)

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

type FriendWatchBuilder

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

func (*FriendWatchBuilder) AsConst

func (b *FriendWatchBuilder) AsConst() *FriendWatch

func (*FriendWatchBuilder) GetRoot

func (b *FriendWatchBuilder) GetRoot() *FriendWatch

func (*FriendWatchBuilder) Init

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

func (*FriendWatchBuilder) Lock

func (b *FriendWatchBuilder) Lock() bool

func (*FriendWatchBuilder) PackMeasure

func (b *FriendWatchBuilder) PackMeasure() int64

func (*FriendWatchBuilder) PackMeasureReason

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

func (*FriendWatchBuilder) Region

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

func (*FriendWatchBuilder) Shutdown

func (b *FriendWatchBuilder) Shutdown()

type FriendWatchCook

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

FriendWatchCook is FriendWatch'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 — FriendWatchOpen, FriendWatchAt — 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 (*FriendWatchCook) Open

func (cook *FriendWatchCook) 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 (FriendWatchCook) RegionAlignment

func (c FriendWatchCook) 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 (FriendWatchCook) Root

func (c FriendWatchCook) Root() *FriendWatchRow

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 (FriendWatchCook) RootAlign

func (c FriendWatchCook) RootAlign() int64

func (FriendWatchCook) RootSize

func (c FriendWatchCook) RootSize() int64

func (FriendWatchCook) Type

func (c FriendWatchCook) Type() *TableCookInfo

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

type FriendWatchRow

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

FriendWatchRow — 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 FriendWatchAt

func FriendWatchAt(slot *int64, arena ...*TableArena) *FriendWatchRow

FriendWatchAt 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 LaneEnd

type LaneEnd = LaneEndRow

func LaneEndLoad

func LaneEndLoad(region, wire []byte, report *TableReport) *LaneEnd

func LaneEndLoadRetain

func LaneEndLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *LaneEnd

func LaneEndLoadText

func LaneEndLoadText(text string, report *TableReport) (*LaneEnd, error)

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

func LaneEndReadStrict

func LaneEndReadStrict(wire []byte) (*LaneEnd, error)

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

type LaneEndBuilder

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

func (*LaneEndBuilder) AsConst

func (b *LaneEndBuilder) AsConst() *LaneEnd

func (*LaneEndBuilder) GetRoot

func (b *LaneEndBuilder) GetRoot() *LaneEnd

func (*LaneEndBuilder) Init

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

func (*LaneEndBuilder) Lock

func (b *LaneEndBuilder) Lock() bool

func (*LaneEndBuilder) PackMeasure

func (b *LaneEndBuilder) PackMeasure() int64

func (*LaneEndBuilder) PackMeasureReason

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

func (*LaneEndBuilder) Region

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

func (*LaneEndBuilder) Shutdown

func (b *LaneEndBuilder) Shutdown()

type LaneEndCook

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

LaneEndCook is LaneEnd'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 — LaneEndOpen, LaneEndAt — 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 (*LaneEndCook) Open

func (cook *LaneEndCook) 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 (LaneEndCook) RegionAlignment

func (c LaneEndCook) 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 (LaneEndCook) Root

func (c LaneEndCook) Root() *LaneEndRow

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 (LaneEndCook) RootAlign

func (c LaneEndCook) RootAlign() int64

func (LaneEndCook) RootSize

func (c LaneEndCook) RootSize() int64

func (LaneEndCook) Type

func (c LaneEndCook) Type() *TableCookInfo

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

type LaneEndRow

type LaneEndRow struct {
	Exit     int64
	Err      int64 // *: signed self-relative delta, zero is null (§6.3)
	Wall     int64
	Cap      int64 // *: signed self-relative delta, zero is null (§6.3)
	Rejected int64 // *: signed self-relative delta, zero is null (§6.3)
	Turns    int64
	Restart  int64 // *: signed self-relative delta, zero is null (§6.3)
	Started  int64 // *: signed self-relative delta, zero is null (§6.3)
	NoReport bool

	Capped  int64
	Tier    int64 // *: signed self-relative delta, zero is null (§6.3)
	Overrun int64
	Tail    int64 // *: signed self-relative delta, zero is null (§6.3)
	// contains filtered or unexported fields
}

LaneEndRow — 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 LaneEndAt

func LaneEndAt(slot *int64, arena ...*TableArena) *LaneEndRow

LaneEndAt 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 NoticeEnvelope

type NoticeEnvelope = NoticeEnvelopeRow

func NoticeEnvelopeLoad

func NoticeEnvelopeLoad(region, wire []byte, report *TableReport) *NoticeEnvelope

func NoticeEnvelopeLoadRetain

func NoticeEnvelopeLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NoticeEnvelope

func NoticeEnvelopeLoadText

func NoticeEnvelopeLoadText(text string, report *TableReport) (*NoticeEnvelope, error)

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

func NoticeEnvelopeReadStrict

func NoticeEnvelopeReadStrict(wire []byte) (*NoticeEnvelope, error)

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

type NoticeEnvelopeBuilder

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

func (*NoticeEnvelopeBuilder) AsConst

func (b *NoticeEnvelopeBuilder) AsConst() *NoticeEnvelope

func (*NoticeEnvelopeBuilder) GetRoot

func (b *NoticeEnvelopeBuilder) GetRoot() *NoticeEnvelope

func (*NoticeEnvelopeBuilder) Init

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

func (*NoticeEnvelopeBuilder) Lock

func (b *NoticeEnvelopeBuilder) Lock() bool

func (*NoticeEnvelopeBuilder) PackMeasure

func (b *NoticeEnvelopeBuilder) PackMeasure() int64

func (*NoticeEnvelopeBuilder) PackMeasureReason

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

func (*NoticeEnvelopeBuilder) Region

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

func (*NoticeEnvelopeBuilder) Shutdown

func (b *NoticeEnvelopeBuilder) Shutdown()

type NoticeEnvelopeCook

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

NoticeEnvelopeCook is NoticeEnvelope'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 — NoticeEnvelopeOpen, NoticeEnvelopeAt — 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 (*NoticeEnvelopeCook) Open

func (cook *NoticeEnvelopeCook) 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 (NoticeEnvelopeCook) RegionAlignment

func (c NoticeEnvelopeCook) 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 (NoticeEnvelopeCook) 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 (NoticeEnvelopeCook) RootAlign

func (c NoticeEnvelopeCook) RootAlign() int64

func (NoticeEnvelopeCook) RootSize

func (c NoticeEnvelopeCook) RootSize() int64

func (NoticeEnvelopeCook) Type

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

type NoticeEnvelopeRow

type NoticeEnvelopeRow struct {
	LocalReceiver      NoticeReceiverRow
	SavedAt            int64 // *: signed self-relative delta, zero is null (§6.3)
	HookEpoch          int64
	HookRole           int64 // *: signed self-relative delta, zero is null (§6.3)
	EventId            int64 // *: signed self-relative delta, zero is null (§6.3)
	Challenge          int64 // *NoticeMessage: signed self-relative delta, zero is null (§6.3)
	Messages           int64
	Senders            TableList[NoticeNameRow]
	RecoverySince      int64 // *: signed self-relative delta, zero is null (§6.3)
	RecoveryCoverage   int64 // *: signed self-relative delta, zero is null (§6.3)
	RecoveryMessages   TableList[NoticeMessageRow]
	PossibleDuplicates bool
	// contains filtered or unexported fields
}

NoticeEnvelopeRow — 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 NoticeEnvelopeAt

func NoticeEnvelopeAt(slot *int64, arena ...*TableArena) *NoticeEnvelopeRow

NoticeEnvelopeAt 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 NoticeMark

type NoticeMark = NoticeMarkRow

func NoticeMarkLoad

func NoticeMarkLoad(region, wire []byte, report *TableReport) *NoticeMark

func NoticeMarkLoadRetain

func NoticeMarkLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NoticeMark

func NoticeMarkLoadText

func NoticeMarkLoadText(text string, report *TableReport) (*NoticeMark, error)

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

func NoticeMarkReadStrict

func NoticeMarkReadStrict(wire []byte) (*NoticeMark, error)

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

type NoticeMarkBuilder

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

func (*NoticeMarkBuilder) AsConst

func (b *NoticeMarkBuilder) AsConst() *NoticeMark

func (*NoticeMarkBuilder) GetRoot

func (b *NoticeMarkBuilder) GetRoot() *NoticeMark

func (*NoticeMarkBuilder) Init

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

func (*NoticeMarkBuilder) Lock

func (b *NoticeMarkBuilder) Lock() bool

func (*NoticeMarkBuilder) PackMeasure

func (b *NoticeMarkBuilder) PackMeasure() int64

func (*NoticeMarkBuilder) PackMeasureReason

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

func (*NoticeMarkBuilder) Region

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

func (*NoticeMarkBuilder) Shutdown

func (b *NoticeMarkBuilder) Shutdown()

type NoticeMarkCook

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

NoticeMarkCook is NoticeMark'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 — NoticeMarkOpen, NoticeMarkAt — 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 (*NoticeMarkCook) Open

func (cook *NoticeMarkCook) 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 (NoticeMarkCook) RegionAlignment

func (c NoticeMarkCook) 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 (NoticeMarkCook) Root

func (c NoticeMarkCook) Root() *NoticeMarkRow

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 (NoticeMarkCook) RootAlign

func (c NoticeMarkCook) RootAlign() int64

func (NoticeMarkCook) RootSize

func (c NoticeMarkCook) RootSize() int64

func (NoticeMarkCook) Type

func (c NoticeMarkCook) Type() *TableCookInfo

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

type NoticeMarkRow

type NoticeMarkRow struct {
	Key     int64 // *: signed self-relative delta, zero is null (§6.3)
	Field   int64 // *: signed self-relative delta, zero is null (§6.3)
	Value   int64 // *: signed self-relative delta, zero is null (§6.3)
	Clear   bool
	Forward bool
	Once    bool
	// contains filtered or unexported fields
}

NoticeMarkRow — 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 NoticeMarkAt

func NoticeMarkAt(slot *int64, arena ...*TableArena) *NoticeMarkRow

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

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

func NoticeMessageMarksAdd

func NoticeMessageMarksAdd(worker *TableWorker, holder *TableList[NoticeMarkRow]) *NoticeMarkRow

type NoticeMessage

type NoticeMessage = NoticeMessageRow

func NoticeMessageEmplace

func NoticeMessageEmplace(worker *TableWorker, slot *TableRef) *NoticeMessage

func NoticeMessageLoad

func NoticeMessageLoad(region, wire []byte, report *TableReport) *NoticeMessage

func NoticeMessageLoadRetain

func NoticeMessageLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NoticeMessage

func NoticeMessageLoadText

func NoticeMessageLoadText(text string, report *TableReport) (*NoticeMessage, error)

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

func NoticeMessageReadStrict

func NoticeMessageReadStrict(wire []byte) (*NoticeMessage, error)

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

type NoticeMessageBuilder

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

func (*NoticeMessageBuilder) AsConst

func (b *NoticeMessageBuilder) AsConst() *NoticeMessage

func (*NoticeMessageBuilder) GetRoot

func (b *NoticeMessageBuilder) GetRoot() *NoticeMessage

func (*NoticeMessageBuilder) Init

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

func (*NoticeMessageBuilder) Lock

func (b *NoticeMessageBuilder) Lock() bool

func (*NoticeMessageBuilder) PackMeasure

func (b *NoticeMessageBuilder) PackMeasure() int64

func (*NoticeMessageBuilder) PackMeasureReason

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

func (*NoticeMessageBuilder) Region

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

func (*NoticeMessageBuilder) Shutdown

func (b *NoticeMessageBuilder) Shutdown()

type NoticeMessageCook

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

NoticeMessageCook is NoticeMessage'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 — NoticeMessageOpen, NoticeMessageAt — 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 (*NoticeMessageCook) Open

func (cook *NoticeMessageCook) 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 (NoticeMessageCook) RegionAlignment

func (c NoticeMessageCook) 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 (NoticeMessageCook) 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 (NoticeMessageCook) RootAlign

func (c NoticeMessageCook) RootAlign() int64

func (NoticeMessageCook) RootSize

func (c NoticeMessageCook) RootSize() int64

func (NoticeMessageCook) Type

func (c NoticeMessageCook) Type() *TableCookInfo

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

type NoticeMessageRow

type NoticeMessageRow struct {
	ModelActivity bool

	Id   int64    // *: signed self-relative delta, zero is null (§6.3)
	From [65]byte // string(64): buffer, used length beside it

	FromLength int32
	To         TableList[NoticeNameRow]
	Cc         TableList[NoticeNameRow]
	Subject    int64         // *: signed self-relative delta, zero is null (§6.3)
	Re         int64         // *: signed self-relative delta, zero is null (§6.3)
	Card       int64         // *: signed self-relative delta, zero is null (§6.3)
	Head       int64         // *: signed self-relative delta, zero is null (§6.3)
	Kind       int64         // *: signed self-relative delta, zero is null (§6.3)
	At         int64         // *: signed self-relative delta, zero is null (§6.3)
	Body       [1048577]byte // string(1048576): buffer, used length beside it

	BodyLength int32
	Wait       int64
	Due        int64     // *: signed self-relative delta, zero is null (§6.3)
	Token      [129]byte // string(128): buffer, used length beside it

	TokenLength int32
	Once        int64 // *: signed self-relative delta, zero is null (§6.3)
	Marks       TableList[NoticeMarkRow]
	// contains filtered or unexported fields
}

NoticeMessageRow — 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 NoticeEnvelopeRecoveryMessagesAdd

func NoticeEnvelopeRecoveryMessagesAdd(worker *TableWorker, holder *TableList[NoticeMessageRow]) *NoticeMessageRow

func NoticeMessageAt

func NoticeMessageAt(slot *int64, arena ...*TableArena) *NoticeMessageRow

NoticeMessageAt 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 NoticeName

type NoticeName = NoticeNameRow

func NoticeNameLoad

func NoticeNameLoad(region, wire []byte, report *TableReport) *NoticeName

func NoticeNameLoadRetain

func NoticeNameLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NoticeName

func NoticeNameLoadText

func NoticeNameLoadText(text string, report *TableReport) (*NoticeName, error)

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

func NoticeNameReadStrict

func NoticeNameReadStrict(wire []byte) (*NoticeName, error)

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

type NoticeNameBuilder

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

func (*NoticeNameBuilder) AsConst

func (b *NoticeNameBuilder) AsConst() *NoticeName

func (*NoticeNameBuilder) GetRoot

func (b *NoticeNameBuilder) GetRoot() *NoticeName

func (*NoticeNameBuilder) Init

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

func (*NoticeNameBuilder) Lock

func (b *NoticeNameBuilder) Lock() bool

func (*NoticeNameBuilder) PackMeasure

func (b *NoticeNameBuilder) PackMeasure() int64

func (*NoticeNameBuilder) PackMeasureReason

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

func (*NoticeNameBuilder) Region

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

func (*NoticeNameBuilder) Shutdown

func (b *NoticeNameBuilder) Shutdown()

type NoticeNameCook

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

NoticeNameCook is NoticeName'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 — NoticeNameOpen, NoticeNameAt — 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 (*NoticeNameCook) Open

func (cook *NoticeNameCook) 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 (NoticeNameCook) RegionAlignment

func (c NoticeNameCook) 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 (NoticeNameCook) Root

func (c NoticeNameCook) Root() *NoticeNameRow

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 (NoticeNameCook) RootAlign

func (c NoticeNameCook) RootAlign() int64

func (NoticeNameCook) RootSize

func (c NoticeNameCook) RootSize() int64

func (NoticeNameCook) Type

func (c NoticeNameCook) Type() *TableCookInfo

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

type NoticeNameRow

type NoticeNameRow struct {
	S [65]byte // string(64): buffer, used length beside it

	SLength int32
	// contains filtered or unexported fields
}

NoticeNameRow — 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 NoticeEnvelopeSendersAdd

func NoticeEnvelopeSendersAdd(worker *TableWorker, holder *TableList[NoticeNameRow]) *NoticeNameRow

func NoticeMessageCcAdd

func NoticeMessageCcAdd(worker *TableWorker, holder *TableList[NoticeNameRow]) *NoticeNameRow

func NoticeMessageToAdd

func NoticeMessageToAdd(worker *TableWorker, holder *TableList[NoticeNameRow]) *NoticeNameRow

func NoticeNameAt

func NoticeNameAt(slot *int64, arena ...*TableArena) *NoticeNameRow

NoticeNameAt 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 NoticeReceiver

type NoticeReceiver = NoticeReceiverRow

func NoticeReceiverLoad

func NoticeReceiverLoad(region, wire []byte, report *TableReport) *NoticeReceiver

func NoticeReceiverLoadRetain

func NoticeReceiverLoadRetain(region, wire []byte, retain *TableRetain, report *TableReport) *NoticeReceiver

func NoticeReceiverLoadText

func NoticeReceiverLoadText(text string, report *TableReport) (*NoticeReceiver, error)

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

func NoticeReceiverReadStrict

func NoticeReceiverReadStrict(wire []byte) (*NoticeReceiver, error)

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

type NoticeReceiverBuilder

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

func (*NoticeReceiverBuilder) AsConst

func (b *NoticeReceiverBuilder) AsConst() *NoticeReceiver

func (*NoticeReceiverBuilder) GetRoot

func (b *NoticeReceiverBuilder) GetRoot() *NoticeReceiver

func (*NoticeReceiverBuilder) Init

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

func (*NoticeReceiverBuilder) Lock

func (b *NoticeReceiverBuilder) Lock() bool

func (*NoticeReceiverBuilder) PackMeasure

func (b *NoticeReceiverBuilder) PackMeasure() int64

func (*NoticeReceiverBuilder) PackMeasureReason

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

func (*NoticeReceiverBuilder) Region

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

func (*NoticeReceiverBuilder) Shutdown

func (b *NoticeReceiverBuilder) Shutdown()

type NoticeReceiverCook

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

NoticeReceiverCook is NoticeReceiver'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 — NoticeReceiverOpen, NoticeReceiverAt — 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 (*NoticeReceiverCook) Open

func (cook *NoticeReceiverCook) 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 (NoticeReceiverCook) RegionAlignment

func (c NoticeReceiverCook) 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 (NoticeReceiverCook) 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 (NoticeReceiverCook) RootAlign

func (c NoticeReceiverCook) RootAlign() int64

func (NoticeReceiverCook) RootSize

func (c NoticeReceiverCook) RootSize() int64

func (NoticeReceiverCook) Type

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

type NoticeReceiverRow

type NoticeReceiverRow struct {
	Identity    int64 // *: signed self-relative delta, zero is null (§6.3)
	Redis       int64 // *: signed self-relative delta, zero is null (§6.3)
	Proof       int64 // *: signed self-relative delta, zero is null (§6.3)
	Acknowledge int64 // *: signed self-relative delta, zero is null (§6.3)
}

NoticeReceiverRow — 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 NoticeReceiverAt

func NoticeReceiverAt(slot *int64, arena ...*TableArena) *NoticeReceiverRow

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

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

type TableAllocator

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

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

type TableArena

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

func (*TableArena) At

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

func (*TableArena) Init

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

func (*TableArena) Shutdown

func (a *TableArena) Shutdown()

type TableBitReader

type TableBitReader struct {
	Buffer []byte
	Offset int64
}

func (*TableBitReader) Align

func (r *TableBitReader) Align() bool

func (*TableBitReader) Get

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

func (*TableBitReader) Skip

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

type TableBitWriter

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

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

func (*TableBitWriter) Align

func (w *TableBitWriter) Align()

func (*TableBitWriter) Put

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

func (*TableBitWriter) Raw

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

type TableBlob

type TableBlob struct {
	Length uint32
	Zero   uint32
}

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

func TableBlobAt

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

type TableBuildVersionMismatch

type TableBuildVersionMismatch struct{ Peer, Own uint64 }

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

func (TableBuildVersionMismatch) Error

type TableByteOrder

type TableByteOrder uint8

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

const (
	TableByteOrderLittle TableByteOrder = 1
	TableByteOrderBig    TableByteOrder = 2
)

type TableBytesView

type TableBytesView struct {
	Data   []byte
	Length int64
}

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

func TableBytesAt

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

type TableCookFieldInfo

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

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

type TableCookInfo

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

TableCookInfo is one cooked record's layout as DATA.

type TableCookStorage

type TableCookStorage uint8

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

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

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

type TableExtentCarve

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

func (*TableExtentCarve) Alloc

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

type TableFieldInfo

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

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

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

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

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

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

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

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

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

TableFieldInfo is one field's descriptor.

type TableFixedDst

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

type TableFixedEntry

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

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

type TableFixedGuardLink struct {
	Guard uint32
	Arg   uint64
	ArgW  uint8
}

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

type TableFixedKnownLayout

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

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

type TableIds

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

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

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

func (*TableIds) Ref

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

func (*TableIds) RefAt

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

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

func (*TableIds) Truncate

func (ids *TableIds) Truncate(mark int)

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

type TableList

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

func (*TableList[T]) At

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

func (*TableList[T]) Clear

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

type TableMap

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

func (*TableMap[T]) At

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

func (*TableMap[T]) Clear

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

type TableMapIndex

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

type TableMessageEntry

type TableMessageEntry struct {
	Id             uint64
	Shape, Element TableMessageShape
}

type TableMessageReader

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

type TableMessageShape

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

type TableMessageWriter

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

type TableMissingRequired

type TableMissingRequired struct{ Fields string }

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

func (TableMissingRequired) Error

func (m TableMissingRequired) Error() string

type TableNodeDirEntry

type TableNodeDirEntry struct{ Offset, TypeId uint64 }

type TableNodeMap

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

func (TableNodeMap) Resolve

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

type TableNumbering

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

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

func (*TableNumbering) Index

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

func (*TableNumbering) Release

func (n *TableNumbering) Release()

type TableOpenVerdict

type TableOpenVerdict uint8

TableOpenVerdict distinguishes an unsupported form from framing damage.

const (
	TableOpenOk TableOpenVerdict = iota
	TableOpenRefused
	TableOpenDamaged
	TableOpenBodyStopped
)

type TableReader

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

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

func (*TableReader) Body

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

func (TableReader) EndsEarly

func (r TableReader) EndsEarly() bool

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

func (*TableReader) Get8

func (r *TableReader) Get8() uint8

func (*TableReader) Get16

func (r *TableReader) Get16() uint16

func (*TableReader) Get32

func (r *TableReader) Get32() uint32

func (*TableReader) Get64

func (r *TableReader) Get64() uint64

func (*TableReader) Has

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

func (*TableReader) Leb

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

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

func (*TableReader) Resolve

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

func (*TableReader) Room

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

func (*TableReader) Signed

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

func (*TableReader) Skip

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

func (*TableReader) Sub

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

func (*TableReader) Take

func (r *TableReader) Take(sub TableReader)

func (*TableReader) Unsigned

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

type TableRef

type TableRef = int64

type TableRefuseReason

type TableRefuseReason uint8

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

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

func (TableRefuseReason) Error

func (r TableRefuseReason) Error() string

type TableReport

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

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

func (*TableReport) Err

func (r *TableReport) Err() error

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

type TableRetain

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

type TableRetainId

type TableRetainId struct {
	Id   uint64
	Slot int
}

type TableRetainIds

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

func (*TableRetainIds) Ref

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

func (*TableRetainIds) RefAt

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

func (*TableRetainIds) Truncate

func (i *TableRetainIds) Truncate(mark int)

type TableRetainMessageReader

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

type TableRetainReader

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

func (*TableRetainReader) Body

func (*TableRetainReader) Take

func (r *TableRetainReader) Take(sub TableRetainReader)

type TableRetainWriter

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

func (*TableRetainWriter) Advance

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

func (*TableRetainWriter) Header

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

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

func (*TableRetainWriter) Id

func (w *TableRetainWriter) Id(id uint64)

func (*TableRetainWriter) IdAt

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

func (*TableRetainWriter) Put8

func (w *TableRetainWriter) Put8(v uint8)

func (*TableRetainWriter) Put16

func (w *TableRetainWriter) Put16(v uint16)

func (*TableRetainWriter) Put32

func (w *TableRetainWriter) Put32(v uint32)

func (*TableRetainWriter) Put64

func (w *TableRetainWriter) Put64(v uint64)

func (*TableRetainWriter) Put128

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

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

func (*TableRetainWriter) PutLeb

func (w *TableRetainWriter) PutLeb(v uint64)

func (*TableRetainWriter) Raw

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

func (*TableRetainWriter) Trailer

func (w *TableRetainWriter) Trailer()

type TableStringView

type TableStringView struct {
	Data   []byte
	Length int64
}

TableStringView has the same borrowed lifetime as TableBytesView.

func TableStringAt

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

type TableTimestampError

type TableTimestampError struct {
	Field string
	Time  time.Time
}

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

func (TableTimestampError) Error

func (e TableTimestampError) Error() string

type TableTypeInfo

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

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

TableTypeInfo is one type's descriptor.

var DeliveryCardTableInfo TableTypeInfo

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

var DeliveryTableInfo TableTypeInfo

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

var FriendQueueTableInfo TableTypeInfo

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

var FriendRefusalTableInfo TableTypeInfo

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

var FriendStatusTableInfo TableTypeInfo

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

var FriendTaskTableInfo TableTypeInfo

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

var FriendWatchTableInfo TableTypeInfo

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

var LaneEndTableInfo TableTypeInfo

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

var NoticeEnvelopeTableInfo TableTypeInfo

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

var NoticeMarkTableInfo TableTypeInfo

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

var NoticeMessageTableInfo TableTypeInfo

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

var NoticeNameTableInfo TableTypeInfo

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

var NoticeReceiverTableInfo TableTypeInfo

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

func DeliveryCardTableType

func DeliveryCardTableType() *TableTypeInfo

DeliveryCardTableType returns DeliveryCard's reflection descriptor.

func DeliveryTableType

func DeliveryTableType() *TableTypeInfo

DeliveryTableType returns Delivery's reflection descriptor.

func FriendQueueTableType

func FriendQueueTableType() *TableTypeInfo

FriendQueueTableType returns FriendQueue's reflection descriptor.

func FriendRefusalTableType

func FriendRefusalTableType() *TableTypeInfo

FriendRefusalTableType returns FriendRefusal's reflection descriptor.

func FriendStatusTableType

func FriendStatusTableType() *TableTypeInfo

FriendStatusTableType returns FriendStatus's reflection descriptor.

func FriendTaskTableType

func FriendTaskTableType() *TableTypeInfo

FriendTaskTableType returns FriendTask's reflection descriptor.

func FriendWatchTableType

func FriendWatchTableType() *TableTypeInfo

FriendWatchTableType returns FriendWatch's reflection descriptor.

func LaneEndTableType

func LaneEndTableType() *TableTypeInfo

LaneEndTableType returns LaneEnd's reflection descriptor.

func NoticeEnvelopeTableType

func NoticeEnvelopeTableType() *TableTypeInfo

NoticeEnvelopeTableType returns NoticeEnvelope's reflection descriptor.

func NoticeMarkTableType

func NoticeMarkTableType() *TableTypeInfo

NoticeMarkTableType returns NoticeMark's reflection descriptor.

func NoticeMessageTableType

func NoticeMessageTableType() *TableTypeInfo

NoticeMessageTableType returns NoticeMessage's reflection descriptor.

func NoticeNameTableType

func NoticeNameTableType() *TableTypeInfo

NoticeNameTableType returns NoticeName's reflection descriptor.

func NoticeReceiverTableType

func NoticeReceiverTableType() *TableTypeInfo

NoticeReceiverTableType returns NoticeReceiver's reflection descriptor.

type TableUnionArmInfo

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

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

type TableUnionInfo

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

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

type TableVocabulary

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

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

func (*TableVocabulary) Entry

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

func (*TableVocabulary) Init

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

func (*TableVocabulary) Name

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

type TableWorker

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

func (*TableWorker) Alloc

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

func (*TableWorker) AllocBytes

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

func (*TableWorker) AllocString

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

type TableWriteContext

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

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

type TableWriter

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

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

func (*TableWriter) Advance

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

func (*TableWriter) Header

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

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

func (*TableWriter) Id

func (w *TableWriter) Id(id uint64)

func (*TableWriter) IdAt

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

func (*TableWriter) Put8

func (w *TableWriter) Put8(v uint8)

func (*TableWriter) Put16

func (w *TableWriter) Put16(v uint16)

func (*TableWriter) Put32

func (w *TableWriter) Put32(v uint32)

func (*TableWriter) Put64

func (w *TableWriter) Put64(v uint64)

func (*TableWriter) Put128

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

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

func (*TableWriter) PutLeb

func (w *TableWriter) PutLeb(v uint64)

func (*TableWriter) Raw

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

func (*TableWriter) Trailer

func (w *TableWriter) Trailer()

type UnitViewInfo

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

func UnitView

func UnitView() *UnitViewInfo

type ViewConstant

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

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

type ViewType

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

type ViewVariant

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

type ViewVocabulary

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

Jump to

Keyboard shortcuts

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