boot.capnp.go

// Code generated by capnpc-go. DO NOT EDIT.

package boot

import (
	capnp "capnproto.org/go/capnp/v3"
	text "capnproto.org/go/capnp/v3/encoding/text"
	schemas "capnproto.org/go/capnp/v3/schemas"
	strconv "strconv"
)

type Packet capnp.Struct
type Packet_request Packet
type Packet_survey Packet
type Packet_response Packet
type Packet_Which uint16

const (
	Packet_Which_request  Packet_Which = 0
	Packet_Which_survey   Packet_Which = 1
	Packet_Which_response Packet_Which = 2
)

func (w Packet_Which) String() string {
	const s = "requestsurveyresponse"
	switch w {
	case Packet_Which_request:
		return s[0:7]
	case Packet_Which_survey:
		return s[7:13]
	case Packet_Which_response:
		return s[13:21]

	}
	return "Packet_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}

// Packet_TypeID is the unique identifier for the type Packet.
const Packet_TypeID = 0xe12a1e555ca80e30

func NewPacket(s *capnp.Segment) (Packet, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
	return Packet(st), err
}

func NewRootPacket(s *capnp.Segment) (Packet, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
	return Packet(st), err
}

func ReadRootPacket(msg *capnp.Message) (Packet, error) {
	root, err := msg.Root()
	return Packet(root.Struct()), err
}

func (s Packet) String() string {
	str, _ := text.Marshal(0xe12a1e555ca80e30, capnp.Struct(s))
	return str
}

func (s Packet) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (Packet) DecodeFromPtr(p capnp.Ptr) Packet {
	return Packet(capnp.Struct{}.DecodeFromPtr(p))
}

func (s Packet) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}

func (s Packet) Which() Packet_Which {
	return Packet_Which(capnp.Struct(s).Uint16(0))
}
func (s Packet) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Packet) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Packet) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Packet) Namespace() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Packet) HasNamespace() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Packet) NamespaceBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.TextBytes(), err
}

func (s Packet) SetNamespace(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Packet) Request() Packet_request { return Packet_request(s) }

func (s Packet) SetRequest() {
	capnp.Struct(s).SetUint16(0, 0)
}

func (s Packet_request) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Packet_request) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Packet_request) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Packet_request) From() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Packet_request) HasFrom() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Packet_request) FromBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.TextBytes(), err
}

func (s Packet_request) SetFrom(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

func (s Packet) Survey() Packet_survey { return Packet_survey(s) }

func (s Packet) SetSurvey() {
	capnp.Struct(s).SetUint16(0, 1)
}

func (s Packet_survey) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Packet_survey) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Packet_survey) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Packet_survey) From() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Packet_survey) HasFrom() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Packet_survey) FromBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.TextBytes(), err
}

func (s Packet_survey) SetFrom(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

func (s Packet_survey) Distance() uint8 {
	return capnp.Struct(s).Uint8(2)
}

func (s Packet_survey) SetDistance(v uint8) {
	capnp.Struct(s).SetUint8(2, v)
}

func (s Packet) Response() Packet_response { return Packet_response(s) }

func (s Packet) SetResponse() {
	capnp.Struct(s).SetUint16(0, 2)
}

func (s Packet_response) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Packet_response) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Packet_response) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Packet_response) Peer() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Packet_response) HasPeer() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Packet_response) PeerBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.TextBytes(), err
}

func (s Packet_response) SetPeer(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

func (s Packet_response) Addrs() (capnp.DataList, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return capnp.DataList(p.List()), err
}

func (s Packet_response) HasAddrs() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Packet_response) SetAddrs(v capnp.DataList) error {
	return capnp.Struct(s).SetPtr(2, v.ToPtr())
}

// NewAddrs sets the addrs field to a newly
// allocated capnp.DataList, preferring placement in s's segment.
func (s Packet_response) NewAddrs(n int32) (capnp.DataList, error) {
	l, err := capnp.NewDataList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.DataList{}, err
	}
	err = capnp.Struct(s).SetPtr(2, l.ToPtr())
	return l, err
}

// Packet_List is a list of Packet.
type Packet_List = capnp.StructList[Packet]

// NewPacket creates a new list of Packet.
func NewPacket_List(s *capnp.Segment, sz int32) (Packet_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz)
	return capnp.StructList[Packet](l), err
}

// Packet_Future is a wrapper for a Packet promised by a client call.
type Packet_Future struct{ *capnp.Future }

func (f Packet_Future) Struct() (Packet, error) {
	p, err := f.Future.Ptr()
	return Packet(p.Struct()), err
}
func (p Packet_Future) Request() Packet_request_Future { return Packet_request_Future{p.Future} }

// Packet_request_Future is a wrapper for a Packet_request promised by a client call.
type Packet_request_Future struct{ *capnp.Future }

func (f Packet_request_Future) Struct() (Packet_request, error) {
	p, err := f.Future.Ptr()
	return Packet_request(p.Struct()), err
}
func (p Packet_Future) Survey() Packet_survey_Future { return Packet_survey_Future{p.Future} }

// Packet_survey_Future is a wrapper for a Packet_survey promised by a client call.
type Packet_survey_Future struct{ *capnp.Future }

func (f Packet_survey_Future) Struct() (Packet_survey, error) {
	p, err := f.Future.Ptr()
	return Packet_survey(p.Struct()), err
}
func (p Packet_Future) Response() Packet_response_Future { return Packet_response_Future{p.Future} }

// Packet_response_Future is a wrapper for a Packet_response promised by a client call.
type Packet_response_Future struct{ *capnp.Future }

func (f Packet_response_Future) Struct() (Packet_response, error) {
	p, err := f.Future.Ptr()
	return Packet_response(p.Struct()), err
}

const schema_fa005a3c690f4a62 = "x\xdal\x921\x8b\x13A\x14\xc7\xff\xff7{\xc9\x81" +
	"\xb7\x97\xac\x1b\xb1S\x0b\x0b\x0dw\xe7i\xa5A8\x15" +
	"S\\\xe0$O\xb0\x11\x0b\xf7\x92\x11\x82^v\xdd\xd9" +
	"S\xacD?\x82\x9f\xc1B\x10\x91\xeb\xecl\x04El" +
	"\x14D\xd0\xca\xca\xe2>\x81\x82\x8elB\x82\xc8v\xc3" +
	"\x9b\xc7\xff\xf7\x9b\xf7\xa6\xb9\x7f!8\x1d\xbe\x15\x88\x1e" +
	"[\xa8\xf97_\x9e\xbf\\|\xfa\xe11\xf4 \xe9\xd7" +
	"\x97\x9f\xdd\xb8v\xa4\xfd\x1d\x87L\x9d@\xbc\xc9\xf7`" +
	"\xbc\xc5\xfb\xa0?\xd5\xd9\xef\xbez\xf4m\xaf\xba\xf3\x05" +
	"?\x81\xf1\x1e7@\x7fe\xe5\xe7\xe1\xd4n\xbd\xab\xee" +
	"\xfc\xc8\xaf`\xfcy\x929\xbf\xd3\x03\xe4\xeb\xed^c" +
	"t\xfe\xfa\xaf\xae\xa9\x1b \xbe(O\xe2M\xa9\x03q" +
	"W~`\xd5o\xa7i\xb16H2\x19g\x9d~2" +
	"\xb8m\x8b5\xb7\x9b\xdf\xb3\x0f\x00]4A\x93-\x0a" +
	"\x10\x9dl\x03z\xdcP\xd7\x85\x11\xa5E\x03D\xab=" +
	"@W\x0c\xf5\xac\xb0q+Ow\xb8\x04\xe1\x12\xe8\x87" +
	"#W$\xe3\x81\x05\xc0\x1a\x845\xb0\x8a\x94\xdb\xbb\xbb" +
	"\xd6\xb1\xd0`J\"\x10\x85\xed\x09\x99\xda\xfa?\xb42" +
	"\xc0e\xe9\xd88;s\x0d\xaa\\\x17J\xd73\x80\x9e" +
	"0\xd4\xcb\xc2Ffm>\x8b=\x9a\x0c\x87\xb9\xe32" +
	"\xd87d\x08)\x8fs\x16g,\x16}R\x9b&\x00" +
	"\x82R3\xb9\x0a\xe8MC\xbd#\x0c\xe9=\xffYe" +
	"4\xba\x04\x09\xe5OY\x9c\xff\x84H;\x90\xd0\xfc." +
	"\x8b\xf3UF\xe7z\x10?Nv\xac\xcb\x92\x01hg" +
	"V\x0f\xa7\xa3)6\xa6\xcb\xf0\xd3\x87\xbar\xa0\x7f\x03" +
	"\x00\x00\xff\xff\x8f\x0c\x99p"

func RegisterSchema(reg *schemas.Registry) {
	reg.Register(&schemas.Schema{
		String: schema_fa005a3c690f4a62,
		Nodes: []uint64{
			0x82cca408afabd7c4,
			0xb1db81b845eb3a2f,
			0xc84d656f17f92c4e,
			0xe12a1e555ca80e30,
		},
		Compressed: true,
	})
}