patch.capnp.go

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

package capnp

import (
	capnp2 "github.com/sahib/brig/catfs/nodes/capnp"
	capnp "zombiezen.com/go/capnproto2"
	text "zombiezen.com/go/capnproto2/encoding/text"
	schemas "zombiezen.com/go/capnproto2/schemas"
)

// Change describes a single change
type Change struct{ capnp.Struct }

// Change_TypeID is the unique identifier for the type Change.
const Change_TypeID = 0x9592300df48789af

func NewChange(s *capnp.Segment) (Change, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
	return Change{st}, err
}

func NewRootChange(s *capnp.Segment) (Change, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
	return Change{st}, err
}

func ReadRootChange(msg *capnp.Message) (Change, error) {
	root, err := msg.RootPtr()
	return Change{root.Struct()}, err
}

func (s Change) String() string {
	str, _ := text.Marshal(0x9592300df48789af, s.Struct)
	return str
}

func (s Change) Mask() uint64 {
	return s.Struct.Uint64(0)
}

func (s Change) SetMask(v uint64) {
	s.Struct.SetUint64(0, v)
}

func (s Change) Head() (capnp2.Node, error) {
	p, err := s.Struct.Ptr(0)
	return capnp2.Node{Struct: p.Struct()}, err
}

func (s Change) HasHead() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s Change) SetHead(v capnp2.Node) error {
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewHead sets the head field to a newly
// allocated capnp2.Node struct, preferring placement in s's segment.
func (s Change) NewHead() (capnp2.Node, error) {
	ss, err := capnp2.NewNode(s.Struct.Segment())
	if err != nil {
		return capnp2.Node{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s Change) Next() (capnp2.Node, error) {
	p, err := s.Struct.Ptr(1)
	return capnp2.Node{Struct: p.Struct()}, err
}

func (s Change) HasNext() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s Change) SetNext(v capnp2.Node) error {
	return s.Struct.SetPtr(1, v.Struct.ToPtr())
}

// NewNext sets the next field to a newly
// allocated capnp2.Node struct, preferring placement in s's segment.
func (s Change) NewNext() (capnp2.Node, error) {
	ss, err := capnp2.NewNode(s.Struct.Segment())
	if err != nil {
		return capnp2.Node{}, err
	}
	err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
	return ss, err
}

func (s Change) Curr() (capnp2.Node, error) {
	p, err := s.Struct.Ptr(2)
	return capnp2.Node{Struct: p.Struct()}, err
}

func (s Change) HasCurr() bool {
	p, err := s.Struct.Ptr(2)
	return p.IsValid() || err != nil
}

func (s Change) SetCurr(v capnp2.Node) error {
	return s.Struct.SetPtr(2, v.Struct.ToPtr())
}

// NewCurr sets the curr field to a newly
// allocated capnp2.Node struct, preferring placement in s's segment.
func (s Change) NewCurr() (capnp2.Node, error) {
	ss, err := capnp2.NewNode(s.Struct.Segment())
	if err != nil {
		return capnp2.Node{}, err
	}
	err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
	return ss, err
}

func (s Change) MovedTo() (string, error) {
	p, err := s.Struct.Ptr(3)
	return p.Text(), err
}

func (s Change) HasMovedTo() bool {
	p, err := s.Struct.Ptr(3)
	return p.IsValid() || err != nil
}

func (s Change) MovedToBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(3)
	return p.TextBytes(), err
}

func (s Change) SetMovedTo(v string) error {
	return s.Struct.SetText(3, v)
}

func (s Change) WasPreviouslyAt() (string, error) {
	p, err := s.Struct.Ptr(4)
	return p.Text(), err
}

func (s Change) HasWasPreviouslyAt() bool {
	p, err := s.Struct.Ptr(4)
	return p.IsValid() || err != nil
}

func (s Change) WasPreviouslyAtBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(4)
	return p.TextBytes(), err
}

func (s Change) SetWasPreviouslyAt(v string) error {
	return s.Struct.SetText(4, v)
}

// Change_List is a list of Change.
type Change_List struct{ capnp.List }

// NewChange creates a new list of Change.
func NewChange_List(s *capnp.Segment, sz int32) (Change_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}, sz)
	return Change_List{l}, err
}

func (s Change_List) At(i int) Change { return Change{s.List.Struct(i)} }

func (s Change_List) Set(i int, v Change) error { return s.List.SetStruct(i, v.Struct) }

func (s Change_List) String() string {
	str, _ := text.MarshalList(0x9592300df48789af, s.List)
	return str
}

// Change_Promise is a wrapper for a Change promised by a client call.
type Change_Promise struct{ *capnp.Pipeline }

func (p Change_Promise) Struct() (Change, error) {
	s, err := p.Pipeline.Struct()
	return Change{s}, err
}

func (p Change_Promise) Head() capnp2.Node_Promise {
	return capnp2.Node_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p Change_Promise) Next() capnp2.Node_Promise {
	return capnp2.Node_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}

func (p Change_Promise) Curr() capnp2.Node_Promise {
	return capnp2.Node_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
}

// Patch contains a single change
type Patch struct{ capnp.Struct }

// Patch_TypeID is the unique identifier for the type Patch.
const Patch_TypeID = 0x927c7336e3054805

func NewPatch(s *capnp.Segment) (Patch, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
	return Patch{st}, err
}

func NewRootPatch(s *capnp.Segment) (Patch, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
	return Patch{st}, err
}

func ReadRootPatch(msg *capnp.Message) (Patch, error) {
	root, err := msg.RootPtr()
	return Patch{root.Struct()}, err
}

func (s Patch) String() string {
	str, _ := text.Marshal(0x927c7336e3054805, s.Struct)
	return str
}

func (s Patch) FromIndex() int64 {
	return int64(s.Struct.Uint64(0))
}

func (s Patch) SetFromIndex(v int64) {
	s.Struct.SetUint64(0, uint64(v))
}

func (s Patch) CurrIndex() int64 {
	return int64(s.Struct.Uint64(8))
}

func (s Patch) SetCurrIndex(v int64) {
	s.Struct.SetUint64(8, uint64(v))
}

func (s Patch) Changes() (Change_List, error) {
	p, err := s.Struct.Ptr(0)
	return Change_List{List: p.List()}, err
}

func (s Patch) HasChanges() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s Patch) SetChanges(v Change_List) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewChanges sets the changes field to a newly
// allocated Change_List, preferring placement in s's segment.
func (s Patch) NewChanges(n int32) (Change_List, error) {
	l, err := NewChange_List(s.Struct.Segment(), n)
	if err != nil {
		return Change_List{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

// Patch_List is a list of Patch.
type Patch_List struct{ capnp.List }

// NewPatch creates a new list of Patch.
func NewPatch_List(s *capnp.Segment, sz int32) (Patch_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
	return Patch_List{l}, err
}

func (s Patch_List) At(i int) Patch { return Patch{s.List.Struct(i)} }

func (s Patch_List) Set(i int, v Patch) error { return s.List.SetStruct(i, v.Struct) }

func (s Patch_List) String() string {
	str, _ := text.MarshalList(0x927c7336e3054805, s.List)
	return str
}

// Patch_Promise is a wrapper for a Patch promised by a client call.
type Patch_Promise struct{ *capnp.Pipeline }

func (p Patch_Promise) Struct() (Patch, error) {
	s, err := p.Pipeline.Struct()
	return Patch{s}, err
}

const schema_b943b54bf1683782 = "x\xda|\x90Ak\x13]\x18\x85\xcfy\xef\xcc\x17\xfa" +
	"\x11M\xc6d!R\xe8luaZ\x0a\x0a\"h\x8d" +
	"\x82\xa2\xc2\\QtU\x18'\x93L0\x99\x84\xcc4" +
	"6\xa0\x04\xba\x11\x85\x82T\x05\x05\xc5\x0aU,T\xea" +
	"F\xb0\x0b\x97\xfe\x05\xff@\x97\xae\x04W\xdd\x8c\xdc\xd4" +
	"j\xd1\xe2\xee\xf2\xdc\x03/\xcf39\xcb\xd32eW" +
	"l@\x9f\xb4\xff\xcb\xec\xf3\xf6\xe6\xb1\xe4\xce\x12\xf48" +
	"%[8\x1e}\xbb\xf8\xa1\xba\x01\x9b9`\xfa\xae\x1c" +
	"`iQr\xa5E\x99(m\xc8:\x98\xad\xdf\xbf\xf7" +
	"}\xdf\xe4\xd2\x13\xb3\xe7\xae\xbdm\xf6Mu\x88\xa5\x81" +
	"\xca\x95\x06jbzU]'\x1ef\x81\x9f\xd6\x93J" +
	"?PI%\xf0\xbbq\xb7\xd2\xf5\xd3 ::z\x9f" +
	"\xf0\xfc4`\xe4\x91\xda\xa2d\xb3\x8f^\xeaO_\x1e" +
	"|\x86\xb6\x843\xe3d\x1ep\xb8\x95\x99U\xe4\x06\x1d" +
	"\x89S\xbf\x19'\xae\xef&\xcd\xb8\xd1\x0a\xddSA\xe4" +
	"\xc7\x8d\x10\xd0ye\x01\x16\x01\xe7\xdc\x15@\x9fU\xd4" +
	"\x9e\xd0!\xcb4\xf0\xb2\x81\x97\x14\xf5\x0d!\xa5L\x01" +
	"\x9ckg\x00\xed)\xea\x960\xab\xf7:\xed\x0bq-" +
	"\x04\xe7iCh\x83Y0\xd7\xeb\xfd\xc1\x86\xdb\x07\x13" +
	"\xee\x07=E\x16\x7f\xf7\x00\x0d\xfc\xb7n5\xf2c\xd5" +
	"\x08\xf7\xf6uG\xbeS\xfc\x9fYut\xc5\xad\xa90" +
	"\x09z\xcd\x9b\xe1.\xe5\x9f\xc6\xd4\x07\x7f\x19?;\x02" +
	"\xe8\xc7\x8azY\xb8#\xfc\xc2\xb0\xa7\x8azE\xe8\x08" +
	"\xb7\x8d_\x19\xf8\\Q\xbf\x15:J\xcaT\x80\xf3\xda" +
	"\xc0eE\xbd&t,U\xa6\x058\xab\xa6\xcd\x8a\xa2" +
	"~/tl\xabL\x1bp\xde-\x00zMQ\x7f\x14" +
	"\x16\xda~r\x8bc\x10\x8e\x81\x85(\xf4k,f\x9b" +
	"[\xf5\xee\xf0\xeb\xe17\xa6E\x11,\xc4\xe1|\xba\x07" +
	"6]\xff\xc6\xc3v\xa7\x1f\xd6\xaev\x98\x870\x0ff" +
	"\xb7\xfd\xc4\xeb\x85\xfd&;sIk0\x93b\xe7\xe7" +
	"G\x00\x00\x00\xff\xff\x0b\xcf\xb1-"

func init() {
	schemas.Register(schema_b943b54bf1683782,
		0x927c7336e3054805,
		0x9592300df48789af)
}