curben
/
cloudflared-mirror
mirror of https://github.com/cloudflare/cloudflared.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
cloudflared-mirror/vendor/zombiezen.com/go/capnproto2/internal/schema/schema.capnp.go

3072 lines
81 KiB
Go
Raw Blame History

// Code generated by capnpc-go. DO NOT EDIT.
package schema
import (
math "math"
strconv "strconv"
capnp "zombiezen.com/go/capnproto2"
)
// Constants defined in schema.capnp.
const (
Field_noDiscriminant = uint16(65535)
)
type Node struct{ capnp.Struct }
type Node_structNode Node
type Node_enum Node
type Node_interface Node
type Node_const Node
type Node_annotation Node
type Node_Which uint16
const (
Node_Which_file Node_Which = 0
Node_Which_structNode Node_Which = 1
Node_Which_enum Node_Which = 2
Node_Which_interface Node_Which = 3
Node_Which_const Node_Which = 4
Node_Which_annotation Node_Which = 5
)
func (w Node_Which) String() string {
const s = "filestructNodeenuminterfaceconstannotation"
switch w {
case Node_Which_file:
return s[0:4]
case Node_Which_structNode:
return s[4:14]
case Node_Which_enum:
return s[14:18]
case Node_Which_interface:
return s[18:27]
case Node_Which_const:
return s[27:32]
case Node_Which_annotation:
return s[32:42]
}
return "Node_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
// Node_TypeID is the unique identifier for the type Node.
const Node_TypeID = 0xe682ab4cf923a417
func NewNode(s *capnp.Segment) (Node, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 40, PointerCount: 6})
return Node{st}, err
}
func NewRootNode(s *capnp.Segment) (Node, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 40, PointerCount: 6})
return Node{st}, err
}
func ReadRootNode(msg *capnp.Message) (Node, error) {
root, err := msg.RootPtr()
return Node{root.Struct()}, err
}
func (s Node) Which() Node_Which {
return Node_Which(s.Struct.Uint16(12))
}
func (s Node) Id() uint64 {
return s.Struct.Uint64(0)
}
func (s Node) SetId(v uint64) {
s.Struct.SetUint64(0, v)
}
func (s Node) DisplayName() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Node) HasDisplayName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Node) DisplayNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Node) SetDisplayName(v string) error {
return s.Struct.SetText(0, v)
}
func (s Node) DisplayNamePrefixLength() uint32 {
return s.Struct.Uint32(8)
}
func (s Node) SetDisplayNamePrefixLength(v uint32) {
s.Struct.SetUint32(8, v)
}
func (s Node) ScopeId() uint64 {
return s.Struct.Uint64(16)
}
func (s Node) SetScopeId(v uint64) {
s.Struct.SetUint64(16, v)
}
func (s Node) Parameters() (Node_Parameter_List, error) {
p, err := s.Struct.Ptr(5)
return Node_Parameter_List{List: p.List()}, err
}
func (s Node) HasParameters() bool {
p, err := s.Struct.Ptr(5)
return p.IsValid() || err != nil
}
func (s Node) SetParameters(v Node_Parameter_List) error {
return s.Struct.SetPtr(5, v.List.ToPtr())
}
// NewParameters sets the parameters field to a newly
// allocated Node_Parameter_List, preferring placement in s's segment.
func (s Node) NewParameters(n int32) (Node_Parameter_List, error) {
l, err := NewNode_Parameter_List(s.Struct.Segment(), n)
if err != nil {
return Node_Parameter_List{}, err
}
err = s.Struct.SetPtr(5, l.List.ToPtr())
return l, err
}
func (s Node) IsGeneric() bool {
return s.Struct.Bit(288)
}
func (s Node) SetIsGeneric(v bool) {
s.Struct.SetBit(288, v)
}
func (s Node) NestedNodes() (Node_NestedNode_List, error) {
p, err := s.Struct.Ptr(1)
return Node_NestedNode_List{List: p.List()}, err
}
func (s Node) HasNestedNodes() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Node) SetNestedNodes(v Node_NestedNode_List) error {
return s.Struct.SetPtr(1, v.List.ToPtr())
}
// NewNestedNodes sets the nestedNodes field to a newly
// allocated Node_NestedNode_List, preferring placement in s's segment.
func (s Node) NewNestedNodes(n int32) (Node_NestedNode_List, error) {
l, err := NewNode_NestedNode_List(s.Struct.Segment(), n)
if err != nil {
return Node_NestedNode_List{}, err
}
err = s.Struct.SetPtr(1, l.List.ToPtr())
return l, err
}
func (s Node) Annotations() (Annotation_List, error) {
p, err := s.Struct.Ptr(2)
return Annotation_List{List: p.List()}, err
}
func (s Node) HasAnnotations() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s Node) SetAnnotations(v Annotation_List) error {
return s.Struct.SetPtr(2, v.List.ToPtr())
}
// NewAnnotations sets the annotations field to a newly
// allocated Annotation_List, preferring placement in s's segment.
func (s Node) NewAnnotations(n int32) (Annotation_List, error) {
l, err := NewAnnotation_List(s.Struct.Segment(), n)
if err != nil {
return Annotation_List{}, err
}
err = s.Struct.SetPtr(2, l.List.ToPtr())
return l, err
}
func (s Node) SetFile() {
s.Struct.SetUint16(12, 0)
}
func (s Node) StructNode() Node_structNode { return Node_structNode(s) }
func (s Node) SetStructNode() {
s.Struct.SetUint16(12, 1)
}
func (s Node_structNode) DataWordCount() uint16 {
return s.Struct.Uint16(14)
}
func (s Node_structNode) SetDataWordCount(v uint16) {
s.Struct.SetUint16(14, v)
}
func (s Node_structNode) PointerCount() uint16 {
return s.Struct.Uint16(24)
}
func (s Node_structNode) SetPointerCount(v uint16) {
s.Struct.SetUint16(24, v)
}
func (s Node_structNode) PreferredListEncoding() ElementSize {
return ElementSize(s.Struct.Uint16(26))
}
func (s Node_structNode) SetPreferredListEncoding(v ElementSize) {
s.Struct.SetUint16(26, uint16(v))
}
func (s Node_structNode) IsGroup() bool {
return s.Struct.Bit(224)
}
func (s Node_structNode) SetIsGroup(v bool) {
s.Struct.SetBit(224, v)
}
func (s Node_structNode) DiscriminantCount() uint16 {
return s.Struct.Uint16(30)
}
func (s Node_structNode) SetDiscriminantCount(v uint16) {
s.Struct.SetUint16(30, v)
}
func (s Node_structNode) DiscriminantOffset() uint32 {
return s.Struct.Uint32(32)
}
func (s Node_structNode) SetDiscriminantOffset(v uint32) {
s.Struct.SetUint32(32, v)
}
func (s Node_structNode) Fields() (Field_List, error) {
p, err := s.Struct.Ptr(3)
return Field_List{List: p.List()}, err
}
func (s Node_structNode) HasFields() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s Node_structNode) SetFields(v Field_List) error {
return s.Struct.SetPtr(3, v.List.ToPtr())
}
// NewFields sets the fields field to a newly
// allocated Field_List, preferring placement in s's segment.
func (s Node_structNode) NewFields(n int32) (Field_List, error) {
l, err := NewField_List(s.Struct.Segment(), n)
if err != nil {
return Field_List{}, err
}
err = s.Struct.SetPtr(3, l.List.ToPtr())
return l, err
}
func (s Node) Enum() Node_enum { return Node_enum(s) }
func (s Node) SetEnum() {
s.Struct.SetUint16(12, 2)
}
func (s Node_enum) Enumerants() (Enumerant_List, error) {
p, err := s.Struct.Ptr(3)
return Enumerant_List{List: p.List()}, err
}
func (s Node_enum) HasEnumerants() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s Node_enum) SetEnumerants(v Enumerant_List) error {
return s.Struct.SetPtr(3, v.List.ToPtr())
}
// NewEnumerants sets the enumerants field to a newly
// allocated Enumerant_List, preferring placement in s's segment.
func (s Node_enum) NewEnumerants(n int32) (Enumerant_List, error) {
l, err := NewEnumerant_List(s.Struct.Segment(), n)
if err != nil {
return Enumerant_List{}, err
}
err = s.Struct.SetPtr(3, l.List.ToPtr())
return l, err
}
func (s Node) Interface() Node_interface { return Node_interface(s) }
func (s Node) SetInterface() {
s.Struct.SetUint16(12, 3)
}
func (s Node_interface) Methods() (Method_List, error) {
p, err := s.Struct.Ptr(3)
return Method_List{List: p.List()}, err
}
func (s Node_interface) HasMethods() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s Node_interface) SetMethods(v Method_List) error {
return s.Struct.SetPtr(3, v.List.ToPtr())
}
// NewMethods sets the methods field to a newly
// allocated Method_List, preferring placement in s's segment.
func (s Node_interface) NewMethods(n int32) (Method_List, error) {
l, err := NewMethod_List(s.Struct.Segment(), n)
if err != nil {
return Method_List{}, err
}
err = s.Struct.SetPtr(3, l.List.ToPtr())
return l, err
}
func (s Node_interface) Superclasses() (Superclass_List, error) {
p, err := s.Struct.Ptr(4)
return Superclass_List{List: p.List()}, err
}
func (s Node_interface) HasSuperclasses() bool {
p, err := s.Struct.Ptr(4)
return p.IsValid() || err != nil
}
func (s Node_interface) SetSuperclasses(v Superclass_List) error {
return s.Struct.SetPtr(4, v.List.ToPtr())
}
// NewSuperclasses sets the superclasses field to a newly
// allocated Superclass_List, preferring placement in s's segment.
func (s Node_interface) NewSuperclasses(n int32) (Superclass_List, error) {
l, err := NewSuperclass_List(s.Struct.Segment(), n)
if err != nil {
return Superclass_List{}, err
}
err = s.Struct.SetPtr(4, l.List.ToPtr())
return l, err
}
func (s Node) Const() Node_const { return Node_const(s) }
func (s Node) SetConst() {
s.Struct.SetUint16(12, 4)
}
func (s Node_const) Type() (Type, error) {
p, err := s.Struct.Ptr(3)
return Type{Struct: p.Struct()}, err
}
func (s Node_const) HasType() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s Node_const) SetType(v Type) error {
return s.Struct.SetPtr(3, v.Struct.ToPtr())
}
// NewType sets the type field to a newly
// allocated Type struct, preferring placement in s's segment.
func (s Node_const) NewType() (Type, error) {
ss, err := NewType(s.Struct.Segment())
if err != nil {
return Type{}, err
}
err = s.Struct.SetPtr(3, ss.Struct.ToPtr())
return ss, err
}
func (s Node_const) Value() (Value, error) {
p, err := s.Struct.Ptr(4)
return Value{Struct: p.Struct()}, err
}
func (s Node_const) HasValue() bool {
p, err := s.Struct.Ptr(4)
return p.IsValid() || err != nil
}
func (s Node_const) SetValue(v Value) error {
return s.Struct.SetPtr(4, v.Struct.ToPtr())
}
// NewValue sets the value field to a newly
// allocated Value struct, preferring placement in s's segment.
func (s Node_const) NewValue() (Value, error) {
ss, err := NewValue(s.Struct.Segment())
if err != nil {
return Value{}, err
}
err = s.Struct.SetPtr(4, ss.Struct.ToPtr())
return ss, err
}
func (s Node) Annotation() Node_annotation { return Node_annotation(s) }
func (s Node) SetAnnotation() {
s.Struct.SetUint16(12, 5)
}
func (s Node_annotation) Type() (Type, error) {
p, err := s.Struct.Ptr(3)
return Type{Struct: p.Struct()}, err
}
func (s Node_annotation) HasType() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s Node_annotation) SetType(v Type) error {
return s.Struct.SetPtr(3, v.Struct.ToPtr())
}
// NewType sets the type field to a newly
// allocated Type struct, preferring placement in s's segment.
func (s Node_annotation) NewType() (Type, error) {
ss, err := NewType(s.Struct.Segment())
if err != nil {
return Type{}, err
}
err = s.Struct.SetPtr(3, ss.Struct.ToPtr())
return ss, err
}
func (s Node_annotation) TargetsFile() bool {
return s.Struct.Bit(112)
}
func (s Node_annotation) SetTargetsFile(v bool) {
s.Struct.SetBit(112, v)
}
func (s Node_annotation) TargetsConst() bool {
return s.Struct.Bit(113)
}
func (s Node_annotation) SetTargetsConst(v bool) {
s.Struct.SetBit(113, v)
}
func (s Node_annotation) TargetsEnum() bool {
return s.Struct.Bit(114)
}
func (s Node_annotation) SetTargetsEnum(v bool) {
s.Struct.SetBit(114, v)
}
func (s Node_annotation) TargetsEnumerant() bool {
return s.Struct.Bit(115)
}
func (s Node_annotation) SetTargetsEnumerant(v bool) {
s.Struct.SetBit(115, v)
}
func (s Node_annotation) TargetsStruct() bool {
return s.Struct.Bit(116)
}
func (s Node_annotation) SetTargetsStruct(v bool) {
s.Struct.SetBit(116, v)
}
func (s Node_annotation) TargetsField() bool {
return s.Struct.Bit(117)
}
func (s Node_annotation) SetTargetsField(v bool) {
s.Struct.SetBit(117, v)
}
func (s Node_annotation) TargetsUnion() bool {
return s.Struct.Bit(118)
}
func (s Node_annotation) SetTargetsUnion(v bool) {
s.Struct.SetBit(118, v)
}
func (s Node_annotation) TargetsGroup() bool {
return s.Struct.Bit(119)
}
func (s Node_annotation) SetTargetsGroup(v bool) {
s.Struct.SetBit(119, v)
}
func (s Node_annotation) TargetsInterface() bool {
return s.Struct.Bit(120)
}
func (s Node_annotation) SetTargetsInterface(v bool) {
s.Struct.SetBit(120, v)
}
func (s Node_annotation) TargetsMethod() bool {
return s.Struct.Bit(121)
}
func (s Node_annotation) SetTargetsMethod(v bool) {
s.Struct.SetBit(121, v)
}
func (s Node_annotation) TargetsParam() bool {
return s.Struct.Bit(122)
}
func (s Node_annotation) SetTargetsParam(v bool) {
s.Struct.SetBit(122, v)
}
func (s Node_annotation) TargetsAnnotation() bool {
return s.Struct.Bit(123)
}
func (s Node_annotation) SetTargetsAnnotation(v bool) {
s.Struct.SetBit(123, v)
}
// Node_List is a list of Node.
type Node_List struct{ capnp.List }
// NewNode creates a new list of Node.
func NewNode_List(s *capnp.Segment, sz int32) (Node_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 40, PointerCount: 6}, sz)
return Node_List{l}, err
}
func (s Node_List) At(i int) Node { return Node{s.List.Struct(i)} }
func (s Node_List) Set(i int, v Node) error { return s.List.SetStruct(i, v.Struct) }
// Node_Promise is a wrapper for a Node promised by a client call.
type Node_Promise struct{ *capnp.Pipeline }
func (p Node_Promise) Struct() (Node, error) {
s, err := p.Pipeline.Struct()
return Node{s}, err
}
func (p Node_Promise) StructNode() Node_structNode_Promise { return Node_structNode_Promise{p.Pipeline} }
// Node_structNode_Promise is a wrapper for a Node_structNode promised by a client call.
type Node_structNode_Promise struct{ *capnp.Pipeline }
func (p Node_structNode_Promise) Struct() (Node_structNode, error) {
s, err := p.Pipeline.Struct()
return Node_structNode{s}, err
}
func (p Node_Promise) Enum() Node_enum_Promise { return Node_enum_Promise{p.Pipeline} }
// Node_enum_Promise is a wrapper for a Node_enum promised by a client call.
type Node_enum_Promise struct{ *capnp.Pipeline }
func (p Node_enum_Promise) Struct() (Node_enum, error) {
s, err := p.Pipeline.Struct()
return Node_enum{s}, err
}
func (p Node_Promise) Interface() Node_interface_Promise { return Node_interface_Promise{p.Pipeline} }
// Node_interface_Promise is a wrapper for a Node_interface promised by a client call.
type Node_interface_Promise struct{ *capnp.Pipeline }
func (p Node_interface_Promise) Struct() (Node_interface, error) {
s, err := p.Pipeline.Struct()
return Node_interface{s}, err
}
func (p Node_Promise) Const() Node_const_Promise { return Node_const_Promise{p.Pipeline} }
// Node_const_Promise is a wrapper for a Node_const promised by a client call.
type Node_const_Promise struct{ *capnp.Pipeline }
func (p Node_const_Promise) Struct() (Node_const, error) {
s, err := p.Pipeline.Struct()
return Node_const{s}, err
}
func (p Node_const_Promise) Type() Type_Promise {
return Type_Promise{Pipeline: p.Pipeline.GetPipeline(3)}
}
func (p Node_const_Promise) Value() Value_Promise {
return Value_Promise{Pipeline: p.Pipeline.GetPipeline(4)}
}
func (p Node_Promise) Annotation() Node_annotation_Promise { return Node_annotation_Promise{p.Pipeline} }
// Node_annotation_Promise is a wrapper for a Node_annotation promised by a client call.
type Node_annotation_Promise struct{ *capnp.Pipeline }
func (p Node_annotation_Promise) Struct() (Node_annotation, error) {
s, err := p.Pipeline.Struct()
return Node_annotation{s}, err
}
func (p Node_annotation_Promise) Type() Type_Promise {
return Type_Promise{Pipeline: p.Pipeline.GetPipeline(3)}
}
type Node_Parameter struct{ capnp.Struct }
// Node_Parameter_TypeID is the unique identifier for the type Node_Parameter.
const Node_Parameter_TypeID = 0xb9521bccf10fa3b1
func NewNode_Parameter(s *capnp.Segment) (Node_Parameter, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return Node_Parameter{st}, err
}
func NewRootNode_Parameter(s *capnp.Segment) (Node_Parameter, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return Node_Parameter{st}, err
}
func ReadRootNode_Parameter(msg *capnp.Message) (Node_Parameter, error) {
root, err := msg.RootPtr()
return Node_Parameter{root.Struct()}, err
}
func (s Node_Parameter) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Node_Parameter) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Node_Parameter) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Node_Parameter) SetName(v string) error {
return s.Struct.SetText(0, v)
}
// Node_Parameter_List is a list of Node_Parameter.
type Node_Parameter_List struct{ capnp.List }
// NewNode_Parameter creates a new list of Node_Parameter.
func NewNode_Parameter_List(s *capnp.Segment, sz int32) (Node_Parameter_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return Node_Parameter_List{l}, err
}
func (s Node_Parameter_List) At(i int) Node_Parameter { return Node_Parameter{s.List.Struct(i)} }
func (s Node_Parameter_List) Set(i int, v Node_Parameter) error { return s.List.SetStruct(i, v.Struct) }
// Node_Parameter_Promise is a wrapper for a Node_Parameter promised by a client call.
type Node_Parameter_Promise struct{ *capnp.Pipeline }
func (p Node_Parameter_Promise) Struct() (Node_Parameter, error) {
s, err := p.Pipeline.Struct()
return Node_Parameter{s}, err
}
type Node_NestedNode struct{ capnp.Struct }
// Node_NestedNode_TypeID is the unique identifier for the type Node_NestedNode.
const Node_NestedNode_TypeID = 0xdebf55bbfa0fc242
func NewNode_NestedNode(s *capnp.Segment) (Node_NestedNode, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return Node_NestedNode{st}, err
}
func NewRootNode_NestedNode(s *capnp.Segment) (Node_NestedNode, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return Node_NestedNode{st}, err
}
func ReadRootNode_NestedNode(msg *capnp.Message) (Node_NestedNode, error) {
root, err := msg.RootPtr()
return Node_NestedNode{root.Struct()}, err
}
func (s Node_NestedNode) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Node_NestedNode) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Node_NestedNode) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Node_NestedNode) SetName(v string) error {
return s.Struct.SetText(0, v)
}
func (s Node_NestedNode) Id() uint64 {
return s.Struct.Uint64(0)
}
func (s Node_NestedNode) SetId(v uint64) {
s.Struct.SetUint64(0, v)
}
// Node_NestedNode_List is a list of Node_NestedNode.
type Node_NestedNode_List struct{ capnp.List }
// NewNode_NestedNode creates a new list of Node_NestedNode.
func NewNode_NestedNode_List(s *capnp.Segment, sz int32) (Node_NestedNode_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
return Node_NestedNode_List{l}, err
}
func (s Node_NestedNode_List) At(i int) Node_NestedNode { return Node_NestedNode{s.List.Struct(i)} }
func (s Node_NestedNode_List) Set(i int, v Node_NestedNode) error {
return s.List.SetStruct(i, v.Struct)
}
// Node_NestedNode_Promise is a wrapper for a Node_NestedNode promised by a client call.
type Node_NestedNode_Promise struct{ *capnp.Pipeline }
func (p Node_NestedNode_Promise) Struct() (Node_NestedNode, error) {
s, err := p.Pipeline.Struct()
return Node_NestedNode{s}, err
}
type Field struct{ capnp.Struct }
type Field_slot Field
type Field_group Field
type Field_ordinal Field
type Field_Which uint16
const (
Field_Which_slot Field_Which = 0
Field_Which_group Field_Which = 1
)
func (w Field_Which) String() string {
const s = "slotgroup"
switch w {
case Field_Which_slot:
return s[0:4]
case Field_Which_group:
return s[4:9]
}
return "Field_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
type Field_ordinal_Which uint16
const (
Field_ordinal_Which_implicit Field_ordinal_Which = 0
Field_ordinal_Which_explicit Field_ordinal_Which = 1
)
func (w Field_ordinal_Which) String() string {
const s = "implicitexplicit"
switch w {
case Field_ordinal_Which_implicit:
return s[0:8]
case Field_ordinal_Which_explicit:
return s[8:16]
}
return "Field_ordinal_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
// Field_TypeID is the unique identifier for the type Field.
const Field_TypeID = 0x9aad50a41f4af45f
func NewField(s *capnp.Segment) (Field, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 4})
return Field{st}, err
}
func NewRootField(s *capnp.Segment) (Field, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 4})
return Field{st}, err
}
func ReadRootField(msg *capnp.Message) (Field, error) {
root, err := msg.RootPtr()
return Field{root.Struct()}, err
}
func (s Field) Which() Field_Which {
return Field_Which(s.Struct.Uint16(8))
}
func (s Field) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Field) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Field) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Field) SetName(v string) error {
return s.Struct.SetText(0, v)
}
func (s Field) CodeOrder() uint16 {
return s.Struct.Uint16(0)
}
func (s Field) SetCodeOrder(v uint16) {
s.Struct.SetUint16(0, v)
}
func (s Field) Annotations() (Annotation_List, error) {
p, err := s.Struct.Ptr(1)
return Annotation_List{List: p.List()}, err
}
func (s Field) HasAnnotations() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Field) SetAnnotations(v Annotation_List) error {
return s.Struct.SetPtr(1, v.List.ToPtr())
}
// NewAnnotations sets the annotations field to a newly
// allocated Annotation_List, preferring placement in s's segment.
func (s Field) NewAnnotations(n int32) (Annotation_List, error) {
l, err := NewAnnotation_List(s.Struct.Segment(), n)
if err != nil {
return Annotation_List{}, err
}
err = s.Struct.SetPtr(1, l.List.ToPtr())
return l, err
}
func (s Field) DiscriminantValue() uint16 {
return s.Struct.Uint16(2) ^ 65535
}
func (s Field) SetDiscriminantValue(v uint16) {
s.Struct.SetUint16(2, v^65535)
}
func (s Field) Slot() Field_slot { return Field_slot(s) }
func (s Field) SetSlot() {
s.Struct.SetUint16(8, 0)
}
func (s Field_slot) Offset() uint32 {
return s.Struct.Uint32(4)
}
func (s Field_slot) SetOffset(v uint32) {
s.Struct.SetUint32(4, v)
}
func (s Field_slot) Type() (Type, error) {
p, err := s.Struct.Ptr(2)
return Type{Struct: p.Struct()}, err
}
func (s Field_slot) HasType() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s Field_slot) SetType(v Type) error {
return s.Struct.SetPtr(2, v.Struct.ToPtr())
}
// NewType sets the type field to a newly
// allocated Type struct, preferring placement in s's segment.
func (s Field_slot) NewType() (Type, error) {
ss, err := NewType(s.Struct.Segment())
if err != nil {
return Type{}, err
}
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
return ss, err
}
func (s Field_slot) DefaultValue() (Value, error) {
p, err := s.Struct.Ptr(3)
return Value{Struct: p.Struct()}, err
}
func (s Field_slot) HasDefaultValue() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s Field_slot) SetDefaultValue(v Value) error {
return s.Struct.SetPtr(3, v.Struct.ToPtr())
}
// NewDefaultValue sets the defaultValue field to a newly
// allocated Value struct, preferring placement in s's segment.
func (s Field_slot) NewDefaultValue() (Value, error) {
ss, err := NewValue(s.Struct.Segment())
if err != nil {
return Value{}, err
}
err = s.Struct.SetPtr(3, ss.Struct.ToPtr())
return ss, err
}
func (s Field_slot) HadExplicitDefault() bool {
return s.Struct.Bit(128)
}
func (s Field_slot) SetHadExplicitDefault(v bool) {
s.Struct.SetBit(128, v)
}
func (s Field) Group() Field_group { return Field_group(s) }
func (s Field) SetGroup() {
s.Struct.SetUint16(8, 1)
}
func (s Field_group) TypeId() uint64 {
return s.Struct.Uint64(16)
}
func (s Field_group) SetTypeId(v uint64) {
s.Struct.SetUint64(16, v)
}
func (s Field) Ordinal() Field_ordinal { return Field_ordinal(s) }
func (s Field_ordinal) Which() Field_ordinal_Which {
return Field_ordinal_Which(s.Struct.Uint16(10))
}
func (s Field_ordinal) SetImplicit() {
s.Struct.SetUint16(10, 0)
}
func (s Field_ordinal) Explicit() uint16 {
return s.Struct.Uint16(12)
}
func (s Field_ordinal) SetExplicit(v uint16) {
s.Struct.SetUint16(10, 1)
s.Struct.SetUint16(12, v)
}
// Field_List is a list of Field.
type Field_List struct{ capnp.List }
// NewField creates a new list of Field.
func NewField_List(s *capnp.Segment, sz int32) (Field_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 4}, sz)
return Field_List{l}, err
}
func (s Field_List) At(i int) Field { return Field{s.List.Struct(i)} }
func (s Field_List) Set(i int, v Field) error { return s.List.SetStruct(i, v.Struct) }
// Field_Promise is a wrapper for a Field promised by a client call.
type Field_Promise struct{ *capnp.Pipeline }
func (p Field_Promise) Struct() (Field, error) {
s, err := p.Pipeline.Struct()
return Field{s}, err
}
func (p Field_Promise) Slot() Field_slot_Promise { return Field_slot_Promise{p.Pipeline} }
// Field_slot_Promise is a wrapper for a Field_slot promised by a client call.
type Field_slot_Promise struct{ *capnp.Pipeline }
func (p Field_slot_Promise) Struct() (Field_slot, error) {
s, err := p.Pipeline.Struct()
return Field_slot{s}, err
}
func (p Field_slot_Promise) Type() Type_Promise {
return Type_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
}
func (p Field_slot_Promise) DefaultValue() Value_Promise {
return Value_Promise{Pipeline: p.Pipeline.GetPipeline(3)}
}
func (p Field_Promise) Group() Field_group_Promise { return Field_group_Promise{p.Pipeline} }
// Field_group_Promise is a wrapper for a Field_group promised by a client call.
type Field_group_Promise struct{ *capnp.Pipeline }
func (p Field_group_Promise) Struct() (Field_group, error) {
s, err := p.Pipeline.Struct()
return Field_group{s}, err
}
func (p Field_Promise) Ordinal() Field_ordinal_Promise { return Field_ordinal_Promise{p.Pipeline} }
// Field_ordinal_Promise is a wrapper for a Field_ordinal promised by a client call.
type Field_ordinal_Promise struct{ *capnp.Pipeline }
func (p Field_ordinal_Promise) Struct() (Field_ordinal, error) {
s, err := p.Pipeline.Struct()
return Field_ordinal{s}, err
}
type Enumerant struct{ capnp.Struct }
// Enumerant_TypeID is the unique identifier for the type Enumerant.
const Enumerant_TypeID = 0x978a7cebdc549a4d
func NewEnumerant(s *capnp.Segment) (Enumerant, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return Enumerant{st}, err
}
func NewRootEnumerant(s *capnp.Segment) (Enumerant, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return Enumerant{st}, err
}
func ReadRootEnumerant(msg *capnp.Message) (Enumerant, error) {
root, err := msg.RootPtr()
return Enumerant{root.Struct()}, err
}
func (s Enumerant) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Enumerant) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Enumerant) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Enumerant) SetName(v string) error {
return s.Struct.SetText(0, v)
}
func (s Enumerant) CodeOrder() uint16 {
return s.Struct.Uint16(0)
}
func (s Enumerant) SetCodeOrder(v uint16) {
s.Struct.SetUint16(0, v)
}
func (s Enumerant) Annotations() (Annotation_List, error) {
p, err := s.Struct.Ptr(1)
return Annotation_List{List: p.List()}, err
}
func (s Enumerant) HasAnnotations() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Enumerant) SetAnnotations(v Annotation_List) error {
return s.Struct.SetPtr(1, v.List.ToPtr())
}
// NewAnnotations sets the annotations field to a newly
// allocated Annotation_List, preferring placement in s's segment.
func (s Enumerant) NewAnnotations(n int32) (Annotation_List, error) {
l, err := NewAnnotation_List(s.Struct.Segment(), n)
if err != nil {
return Annotation_List{}, err
}
err = s.Struct.SetPtr(1, l.List.ToPtr())
return l, err
}
// Enumerant_List is a list of Enumerant.
type Enumerant_List struct{ capnp.List }
// NewEnumerant creates a new list of Enumerant.
func NewEnumerant_List(s *capnp.Segment, sz int32) (Enumerant_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
return Enumerant_List{l}, err
}
func (s Enumerant_List) At(i int) Enumerant { return Enumerant{s.List.Struct(i)} }
func (s Enumerant_List) Set(i int, v Enumerant) error { return s.List.SetStruct(i, v.Struct) }
// Enumerant_Promise is a wrapper for a Enumerant promised by a client call.
type Enumerant_Promise struct{ *capnp.Pipeline }
func (p Enumerant_Promise) Struct() (Enumerant, error) {
s, err := p.Pipeline.Struct()
return Enumerant{s}, err
}
type Superclass struct{ capnp.Struct }
// Superclass_TypeID is the unique identifier for the type Superclass.
const Superclass_TypeID = 0xa9962a9ed0a4d7f8
func NewSuperclass(s *capnp.Segment) (Superclass, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return Superclass{st}, err
}
func NewRootSuperclass(s *capnp.Segment) (Superclass, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return Superclass{st}, err
}
func ReadRootSuperclass(msg *capnp.Message) (Superclass, error) {
root, err := msg.RootPtr()
return Superclass{root.Struct()}, err
}
func (s Superclass) Id() uint64 {
return s.Struct.Uint64(0)
}
func (s Superclass) SetId(v uint64) {
s.Struct.SetUint64(0, v)
}
func (s Superclass) Brand() (Brand, error) {
p, err := s.Struct.Ptr(0)
return Brand{Struct: p.Struct()}, err
}
func (s Superclass) HasBrand() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Superclass) SetBrand(v Brand) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewBrand sets the brand field to a newly
// allocated Brand struct, preferring placement in s's segment.
func (s Superclass) NewBrand() (Brand, error) {
ss, err := NewBrand(s.Struct.Segment())
if err != nil {
return Brand{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// Superclass_List is a list of Superclass.
type Superclass_List struct{ capnp.List }
// NewSuperclass creates a new list of Superclass.
func NewSuperclass_List(s *capnp.Segment, sz int32) (Superclass_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
return Superclass_List{l}, err
}
func (s Superclass_List) At(i int) Superclass { return Superclass{s.List.Struct(i)} }
func (s Superclass_List) Set(i int, v Superclass) error { return s.List.SetStruct(i, v.Struct) }
// Superclass_Promise is a wrapper for a Superclass promised by a client call.
type Superclass_Promise struct{ *capnp.Pipeline }
func (p Superclass_Promise) Struct() (Superclass, error) {
s, err := p.Pipeline.Struct()
return Superclass{s}, err
}
func (p Superclass_Promise) Brand() Brand_Promise {
return Brand_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type Method struct{ capnp.Struct }
// Method_TypeID is the unique identifier for the type Method.
const Method_TypeID = 0x9500cce23b334d80
func NewMethod(s *capnp.Segment) (Method, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 5})
return Method{st}, err
}
func NewRootMethod(s *capnp.Segment) (Method, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 5})
return Method{st}, err
}
func ReadRootMethod(msg *capnp.Message) (Method, error) {
root, err := msg.RootPtr()
return Method{root.Struct()}, err
}
func (s Method) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Method) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Method) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Method) SetName(v string) error {
return s.Struct.SetText(0, v)
}
func (s Method) CodeOrder() uint16 {
return s.Struct.Uint16(0)
}
func (s Method) SetCodeOrder(v uint16) {
s.Struct.SetUint16(0, v)
}
func (s Method) ImplicitParameters() (Node_Parameter_List, error) {
p, err := s.Struct.Ptr(4)
return Node_Parameter_List{List: p.List()}, err
}
func (s Method) HasImplicitParameters() bool {
p, err := s.Struct.Ptr(4)
return p.IsValid() || err != nil
}
func (s Method) SetImplicitParameters(v Node_Parameter_List) error {
return s.Struct.SetPtr(4, v.List.ToPtr())
}
// NewImplicitParameters sets the implicitParameters field to a newly
// allocated Node_Parameter_List, preferring placement in s's segment.
func (s Method) NewImplicitParameters(n int32) (Node_Parameter_List, error) {
l, err := NewNode_Parameter_List(s.Struct.Segment(), n)
if err != nil {
return Node_Parameter_List{}, err
}
err = s.Struct.SetPtr(4, l.List.ToPtr())
return l, err
}
func (s Method) ParamStructType() uint64 {
return s.Struct.Uint64(8)
}
func (s Method) SetParamStructType(v uint64) {
s.Struct.SetUint64(8, v)
}
func (s Method) ParamBrand() (Brand, error) {
p, err := s.Struct.Ptr(2)
return Brand{Struct: p.Struct()}, err
}
func (s Method) HasParamBrand() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s Method) SetParamBrand(v Brand) error {
return s.Struct.SetPtr(2, v.Struct.ToPtr())
}
// NewParamBrand sets the paramBrand field to a newly
// allocated Brand struct, preferring placement in s's segment.
func (s Method) NewParamBrand() (Brand, error) {
ss, err := NewBrand(s.Struct.Segment())
if err != nil {
return Brand{}, err
}
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
return ss, err
}
func (s Method) ResultStructType() uint64 {
return s.Struct.Uint64(16)
}
func (s Method) SetResultStructType(v uint64) {
s.Struct.SetUint64(16, v)
}
func (s Method) ResultBrand() (Brand, error) {
p, err := s.Struct.Ptr(3)
return Brand{Struct: p.Struct()}, err
}
func (s Method) HasResultBrand() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s Method) SetResultBrand(v Brand) error {
return s.Struct.SetPtr(3, v.Struct.ToPtr())
}
// NewResultBrand sets the resultBrand field to a newly
// allocated Brand struct, preferring placement in s's segment.
func (s Method) NewResultBrand() (Brand, error) {
ss, err := NewBrand(s.Struct.Segment())
if err != nil {
return Brand{}, err
}
err = s.Struct.SetPtr(3, ss.Struct.ToPtr())
return ss, err
}
func (s Method) Annotations() (Annotation_List, error) {
p, err := s.Struct.Ptr(1)
return Annotation_List{List: p.List()}, err
}
func (s Method) HasAnnotations() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Method) SetAnnotations(v Annotation_List) error {
return s.Struct.SetPtr(1, v.List.ToPtr())
}
// NewAnnotations sets the annotations field to a newly
// allocated Annotation_List, preferring placement in s's segment.
func (s Method) NewAnnotations(n int32) (Annotation_List, error) {
l, err := NewAnnotation_List(s.Struct.Segment(), n)
if err != nil {
return Annotation_List{}, err
}
err = s.Struct.SetPtr(1, l.List.ToPtr())
return l, err
}
// Method_List is a list of Method.
type Method_List struct{ capnp.List }
// NewMethod creates a new list of Method.
func NewMethod_List(s *capnp.Segment, sz int32) (Method_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 5}, sz)
return Method_List{l}, err
}
func (s Method_List) At(i int) Method { return Method{s.List.Struct(i)} }
func (s Method_List) Set(i int, v Method) error { return s.List.SetStruct(i, v.Struct) }
// Method_Promise is a wrapper for a Method promised by a client call.
type Method_Promise struct{ *capnp.Pipeline }
func (p Method_Promise) Struct() (Method, error) {
s, err := p.Pipeline.Struct()
return Method{s}, err
}
func (p Method_Promise) ParamBrand() Brand_Promise {
return Brand_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
}
func (p Method_Promise) ResultBrand() Brand_Promise {
return Brand_Promise{Pipeline: p.Pipeline.GetPipeline(3)}
}
type Type struct{ capnp.Struct }
type Type_list Type
type Type_enum Type
type Type_structType Type
type Type_interface Type
type Type_anyPointer Type
type Type_anyPointer_unconstrained Type
type Type_anyPointer_parameter Type
type Type_anyPointer_implicitMethodParameter Type
type Type_Which uint16
const (
Type_Which_void Type_Which = 0
Type_Which_bool Type_Which = 1
Type_Which_int8 Type_Which = 2
Type_Which_int16 Type_Which = 3
Type_Which_int32 Type_Which = 4
Type_Which_int64 Type_Which = 5
Type_Which_uint8 Type_Which = 6
Type_Which_uint16 Type_Which = 7
Type_Which_uint32 Type_Which = 8
Type_Which_uint64 Type_Which = 9
Type_Which_float32 Type_Which = 10
Type_Which_float64 Type_Which = 11
Type_Which_text Type_Which = 12
Type_Which_data Type_Which = 13
Type_Which_list Type_Which = 14
Type_Which_enum Type_Which = 15
Type_Which_structType Type_Which = 16
Type_Which_interface Type_Which = 17
Type_Which_anyPointer Type_Which = 18
)
func (w Type_Which) String() string {
const s = "voidboolint8int16int32int64uint8uint16uint32uint64float32float64textdatalistenumstructTypeinterfaceanyPointer"
switch w {
case Type_Which_void:
return s[0:4]
case Type_Which_bool:
return s[4:8]
case Type_Which_int8:
return s[8:12]
case Type_Which_int16:
return s[12:17]
case Type_Which_int32:
return s[17:22]
case Type_Which_int64:
return s[22:27]
case Type_Which_uint8:
return s[27:32]
case Type_Which_uint16:
return s[32:38]
case Type_Which_uint32:
return s[38:44]
case Type_Which_uint64:
return s[44:50]
case Type_Which_float32:
return s[50:57]
case Type_Which_float64:
return s[57:64]
case Type_Which_text:
return s[64:68]
case Type_Which_data:
return s[68:72]
case Type_Which_list:
return s[72:76]
case Type_Which_enum:
return s[76:80]
case Type_Which_structType:
return s[80:90]
case Type_Which_interface:
return s[90:99]
case Type_Which_anyPointer:
return s[99:109]
}
return "Type_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
type Type_anyPointer_Which uint16
const (
Type_anyPointer_Which_unconstrained Type_anyPointer_Which = 0
Type_anyPointer_Which_parameter Type_anyPointer_Which = 1
Type_anyPointer_Which_implicitMethodParameter Type_anyPointer_Which = 2
)
func (w Type_anyPointer_Which) String() string {
const s = "unconstrainedparameterimplicitMethodParameter"
switch w {
case Type_anyPointer_Which_unconstrained:
return s[0:13]
case Type_anyPointer_Which_parameter:
return s[13:22]
case Type_anyPointer_Which_implicitMethodParameter:
return s[22:45]
}
return "Type_anyPointer_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
type Type_anyPointer_unconstrained_Which uint16
const (
Type_anyPointer_unconstrained_Which_anyKind Type_anyPointer_unconstrained_Which = 0
Type_anyPointer_unconstrained_Which_struct Type_anyPointer_unconstrained_Which = 1
Type_anyPointer_unconstrained_Which_list Type_anyPointer_unconstrained_Which = 2
Type_anyPointer_unconstrained_Which_capability Type_anyPointer_unconstrained_Which = 3
)
func (w Type_anyPointer_unconstrained_Which) String() string {
const s = "anyKindstructlistcapability"
switch w {
case Type_anyPointer_unconstrained_Which_anyKind:
return s[0:7]
case Type_anyPointer_unconstrained_Which_struct:
return s[7:13]
case Type_anyPointer_unconstrained_Which_list:
return s[13:17]
case Type_anyPointer_unconstrained_Which_capability:
return s[17:27]
}
return "Type_anyPointer_unconstrained_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
// Type_TypeID is the unique identifier for the type Type.
const Type_TypeID = 0xd07378ede1f9cc60
func NewType(s *capnp.Segment) (Type, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 1})
return Type{st}, err
}
func NewRootType(s *capnp.Segment) (Type, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 1})
return Type{st}, err
}
func ReadRootType(msg *capnp.Message) (Type, error) {
root, err := msg.RootPtr()
return Type{root.Struct()}, err
}
func (s Type) Which() Type_Which {
return Type_Which(s.Struct.Uint16(0))
}
func (s Type) SetVoid() {
s.Struct.SetUint16(0, 0)
}
func (s Type) SetBool() {
s.Struct.SetUint16(0, 1)
}
func (s Type) SetInt8() {
s.Struct.SetUint16(0, 2)
}
func (s Type) SetInt16() {
s.Struct.SetUint16(0, 3)
}
func (s Type) SetInt32() {
s.Struct.SetUint16(0, 4)
}
func (s Type) SetInt64() {
s.Struct.SetUint16(0, 5)
}
func (s Type) SetUint8() {
s.Struct.SetUint16(0, 6)
}
func (s Type) SetUint16() {
s.Struct.SetUint16(0, 7)
}
func (s Type) SetUint32() {
s.Struct.SetUint16(0, 8)
}
func (s Type) SetUint64() {
s.Struct.SetUint16(0, 9)
}
func (s Type) SetFloat32() {
s.Struct.SetUint16(0, 10)
}
func (s Type) SetFloat64() {
s.Struct.SetUint16(0, 11)
}
func (s Type) SetText() {
s.Struct.SetUint16(0, 12)
}
func (s Type) SetData() {
s.Struct.SetUint16(0, 13)
}
func (s Type) List() Type_list { return Type_list(s) }
func (s Type) SetList() {
s.Struct.SetUint16(0, 14)
}
func (s Type_list) ElementType() (Type, error) {
p, err := s.Struct.Ptr(0)
return Type{Struct: p.Struct()}, err
}
func (s Type_list) HasElementType() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Type_list) SetElementType(v Type) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewElementType sets the elementType field to a newly
// allocated Type struct, preferring placement in s's segment.
func (s Type_list) NewElementType() (Type, error) {
ss, err := NewType(s.Struct.Segment())
if err != nil {
return Type{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s Type) Enum() Type_enum { return Type_enum(s) }
func (s Type) SetEnum() {
s.Struct.SetUint16(0, 15)
}
func (s Type_enum) TypeId() uint64 {
return s.Struct.Uint64(8)
}
func (s Type_enum) SetTypeId(v uint64) {
s.Struct.SetUint64(8, v)
}
func (s Type_enum) Brand() (Brand, error) {
p, err := s.Struct.Ptr(0)
return Brand{Struct: p.Struct()}, err
}
func (s Type_enum) HasBrand() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Type_enum) SetBrand(v Brand) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewBrand sets the brand field to a newly
// allocated Brand struct, preferring placement in s's segment.
func (s Type_enum) NewBrand() (Brand, error) {
ss, err := NewBrand(s.Struct.Segment())
if err != nil {
return Brand{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s Type) StructType() Type_structType { return Type_structType(s) }
func (s Type) SetStructType() {
s.Struct.SetUint16(0, 16)
}
func (s Type_structType) TypeId() uint64 {
return s.Struct.Uint64(8)
}
func (s Type_structType) SetTypeId(v uint64) {
s.Struct.SetUint64(8, v)
}
func (s Type_structType) Brand() (Brand, error) {
p, err := s.Struct.Ptr(0)
return Brand{Struct: p.Struct()}, err
}
func (s Type_structType) HasBrand() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Type_structType) SetBrand(v Brand) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewBrand sets the brand field to a newly
// allocated Brand struct, preferring placement in s's segment.
func (s Type_structType) NewBrand() (Brand, error) {
ss, err := NewBrand(s.Struct.Segment())
if err != nil {
return Brand{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s Type) Interface() Type_interface { return Type_interface(s) }
func (s Type) SetInterface() {
s.Struct.SetUint16(0, 17)
}
func (s Type_interface) TypeId() uint64 {
return s.Struct.Uint64(8)
}
func (s Type_interface) SetTypeId(v uint64) {
s.Struct.SetUint64(8, v)
}
func (s Type_interface) Brand() (Brand, error) {
p, err := s.Struct.Ptr(0)
return Brand{Struct: p.Struct()}, err
}
func (s Type_interface) HasBrand() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Type_interface) SetBrand(v Brand) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewBrand sets the brand field to a newly
// allocated Brand struct, preferring placement in s's segment.
func (s Type_interface) NewBrand() (Brand, error) {
ss, err := NewBrand(s.Struct.Segment())
if err != nil {
return Brand{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s Type) AnyPointer() Type_anyPointer { return Type_anyPointer(s) }
func (s Type) SetAnyPointer() {
s.Struct.SetUint16(0, 18)
}
func (s Type_anyPointer) Which() Type_anyPointer_Which {
return Type_anyPointer_Which(s.Struct.Uint16(8))
}
func (s Type_anyPointer) Unconstrained() Type_anyPointer_unconstrained {
return Type_anyPointer_unconstrained(s)
}
func (s Type_anyPointer) SetUnconstrained() {
s.Struct.SetUint16(8, 0)
}
func (s Type_anyPointer_unconstrained) Which() Type_anyPointer_unconstrained_Which {
return Type_anyPointer_unconstrained_Which(s.Struct.Uint16(10))
}
func (s Type_anyPointer_unconstrained) SetAnyKind() {
s.Struct.SetUint16(10, 0)
}
func (s Type_anyPointer_unconstrained) SetStruct() {
s.Struct.SetUint16(10, 1)
}
func (s Type_anyPointer_unconstrained) SetList() {
s.Struct.SetUint16(10, 2)
}
func (s Type_anyPointer_unconstrained) SetCapability() {
s.Struct.SetUint16(10, 3)
}
func (s Type_anyPointer) Parameter() Type_anyPointer_parameter { return Type_anyPointer_parameter(s) }
func (s Type_anyPointer) SetParameter() {
s.Struct.SetUint16(8, 1)
}
func (s Type_anyPointer_parameter) ScopeId() uint64 {
return s.Struct.Uint64(16)
}
func (s Type_anyPointer_parameter) SetScopeId(v uint64) {
s.Struct.SetUint64(16, v)
}
func (s Type_anyPointer_parameter) ParameterIndex() uint16 {
return s.Struct.Uint16(10)
}
func (s Type_anyPointer_parameter) SetParameterIndex(v uint16) {
s.Struct.SetUint16(10, v)
}
func (s Type_anyPointer) ImplicitMethodParameter() Type_anyPointer_implicitMethodParameter {
return Type_anyPointer_implicitMethodParameter(s)
}
func (s Type_anyPointer) SetImplicitMethodParameter() {
s.Struct.SetUint16(8, 2)
}
func (s Type_anyPointer_implicitMethodParameter) ParameterIndex() uint16 {
return s.Struct.Uint16(10)
}
func (s Type_anyPointer_implicitMethodParameter) SetParameterIndex(v uint16) {
s.Struct.SetUint16(10, v)
}
// Type_List is a list of Type.
type Type_List struct{ capnp.List }
// NewType creates a new list of Type.
func NewType_List(s *capnp.Segment, sz int32) (Type_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 1}, sz)
return Type_List{l}, err
}
func (s Type_List) At(i int) Type { return Type{s.List.Struct(i)} }
func (s Type_List) Set(i int, v Type) error { return s.List.SetStruct(i, v.Struct) }
// Type_Promise is a wrapper for a Type promised by a client call.
type Type_Promise struct{ *capnp.Pipeline }
func (p Type_Promise) Struct() (Type, error) {
s, err := p.Pipeline.Struct()
return Type{s}, err
}
func (p Type_Promise) List() Type_list_Promise { return Type_list_Promise{p.Pipeline} }
// Type_list_Promise is a wrapper for a Type_list promised by a client call.
type Type_list_Promise struct{ *capnp.Pipeline }
func (p Type_list_Promise) Struct() (Type_list, error) {
s, err := p.Pipeline.Struct()
return Type_list{s}, err
}
func (p Type_list_Promise) ElementType() Type_Promise {
return Type_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p Type_Promise) Enum() Type_enum_Promise { return Type_enum_Promise{p.Pipeline} }
// Type_enum_Promise is a wrapper for a Type_enum promised by a client call.
type Type_enum_Promise struct{ *capnp.Pipeline }
func (p Type_enum_Promise) Struct() (Type_enum, error) {
s, err := p.Pipeline.Struct()
return Type_enum{s}, err
}
func (p Type_enum_Promise) Brand() Brand_Promise {
return Brand_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p Type_Promise) StructType() Type_structType_Promise { return Type_structType_Promise{p.Pipeline} }
// Type_structType_Promise is a wrapper for a Type_structType promised by a client call.
type Type_structType_Promise struct{ *capnp.Pipeline }
func (p Type_structType_Promise) Struct() (Type_structType, error) {
s, err := p.Pipeline.Struct()
return Type_structType{s}, err
}
func (p Type_structType_Promise) Brand() Brand_Promise {
return Brand_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p Type_Promise) Interface() Type_interface_Promise { return Type_interface_Promise{p.Pipeline} }
// Type_interface_Promise is a wrapper for a Type_interface promised by a client call.
type Type_interface_Promise struct{ *capnp.Pipeline }
func (p Type_interface_Promise) Struct() (Type_interface, error) {
s, err := p.Pipeline.Struct()
return Type_interface{s}, err
}
func (p Type_interface_Promise) Brand() Brand_Promise {
return Brand_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p Type_Promise) AnyPointer() Type_anyPointer_Promise { return Type_anyPointer_Promise{p.Pipeline} }
// Type_anyPointer_Promise is a wrapper for a Type_anyPointer promised by a client call.
type Type_anyPointer_Promise struct{ *capnp.Pipeline }
func (p Type_anyPointer_Promise) Struct() (Type_anyPointer, error) {
s, err := p.Pipeline.Struct()
return Type_anyPointer{s}, err
}
func (p Type_anyPointer_Promise) Unconstrained() Type_anyPointer_unconstrained_Promise {
return Type_anyPointer_unconstrained_Promise{p.Pipeline}
}
// Type_anyPointer_unconstrained_Promise is a wrapper for a Type_anyPointer_unconstrained promised by a client call.
type Type_anyPointer_unconstrained_Promise struct{ *capnp.Pipeline }
func (p Type_anyPointer_unconstrained_Promise) Struct() (Type_anyPointer_unconstrained, error) {
s, err := p.Pipeline.Struct()
return Type_anyPointer_unconstrained{s}, err
}
func (p Type_anyPointer_Promise) Parameter() Type_anyPointer_parameter_Promise {
return Type_anyPointer_parameter_Promise{p.Pipeline}
}
// Type_anyPointer_parameter_Promise is a wrapper for a Type_anyPointer_parameter promised by a client call.
type Type_anyPointer_parameter_Promise struct{ *capnp.Pipeline }
func (p Type_anyPointer_parameter_Promise) Struct() (Type_anyPointer_parameter, error) {
s, err := p.Pipeline.Struct()
return Type_anyPointer_parameter{s}, err
}
func (p Type_anyPointer_Promise) ImplicitMethodParameter() Type_anyPointer_implicitMethodParameter_Promise {
return Type_anyPointer_implicitMethodParameter_Promise{p.Pipeline}
}
// Type_anyPointer_implicitMethodParameter_Promise is a wrapper for a Type_anyPointer_implicitMethodParameter promised by a client call.
type Type_anyPointer_implicitMethodParameter_Promise struct{ *capnp.Pipeline }
func (p Type_anyPointer_implicitMethodParameter_Promise) Struct() (Type_anyPointer_implicitMethodParameter, error) {
s, err := p.Pipeline.Struct()
return Type_anyPointer_implicitMethodParameter{s}, err
}
type Brand struct{ capnp.Struct }
// Brand_TypeID is the unique identifier for the type Brand.
const Brand_TypeID = 0x903455f06065422b
func NewBrand(s *capnp.Segment) (Brand, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return Brand{st}, err
}
func NewRootBrand(s *capnp.Segment) (Brand, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return Brand{st}, err
}
func ReadRootBrand(msg *capnp.Message) (Brand, error) {
root, err := msg.RootPtr()
return Brand{root.Struct()}, err
}
func (s Brand) Scopes() (Brand_Scope_List, error) {
p, err := s.Struct.Ptr(0)
return Brand_Scope_List{List: p.List()}, err
}
func (s Brand) HasScopes() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Brand) SetScopes(v Brand_Scope_List) error {
return s.Struct.SetPtr(0, v.List.ToPtr())
}
// NewScopes sets the scopes field to a newly
// allocated Brand_Scope_List, preferring placement in s's segment.
func (s Brand) NewScopes(n int32) (Brand_Scope_List, error) {
l, err := NewBrand_Scope_List(s.Struct.Segment(), n)
if err != nil {
return Brand_Scope_List{}, err
}
err = s.Struct.SetPtr(0, l.List.ToPtr())
return l, err
}
// Brand_List is a list of Brand.
type Brand_List struct{ capnp.List }
// NewBrand creates a new list of Brand.
func NewBrand_List(s *capnp.Segment, sz int32) (Brand_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return Brand_List{l}, err
}
func (s Brand_List) At(i int) Brand { return Brand{s.List.Struct(i)} }
func (s Brand_List) Set(i int, v Brand) error { return s.List.SetStruct(i, v.Struct) }
// Brand_Promise is a wrapper for a Brand promised by a client call.
type Brand_Promise struct{ *capnp.Pipeline }
func (p Brand_Promise) Struct() (Brand, error) {
s, err := p.Pipeline.Struct()
return Brand{s}, err
}
type Brand_Scope struct{ capnp.Struct }
type Brand_Scope_Which uint16
const (
Brand_Scope_Which_bind Brand_Scope_Which = 0
Brand_Scope_Which_inherit Brand_Scope_Which = 1
)
func (w Brand_Scope_Which) String() string {
const s = "bindinherit"
switch w {
case Brand_Scope_Which_bind:
return s[0:4]
case Brand_Scope_Which_inherit:
return s[4:11]
}
return "Brand_Scope_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
// Brand_Scope_TypeID is the unique identifier for the type Brand_Scope.
const Brand_Scope_TypeID = 0xabd73485a9636bc9
func NewBrand_Scope(s *capnp.Segment) (Brand_Scope, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
return Brand_Scope{st}, err
}
func NewRootBrand_Scope(s *capnp.Segment) (Brand_Scope, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
return Brand_Scope{st}, err
}
func ReadRootBrand_Scope(msg *capnp.Message) (Brand_Scope, error) {
root, err := msg.RootPtr()
return Brand_Scope{root.Struct()}, err
}
func (s Brand_Scope) Which() Brand_Scope_Which {
return Brand_Scope_Which(s.Struct.Uint16(8))
}
func (s Brand_Scope) ScopeId() uint64 {
return s.Struct.Uint64(0)
}
func (s Brand_Scope) SetScopeId(v uint64) {
s.Struct.SetUint64(0, v)
}
func (s Brand_Scope) Bind() (Brand_Binding_List, error) {
p, err := s.Struct.Ptr(0)
return Brand_Binding_List{List: p.List()}, err
}
func (s Brand_Scope) HasBind() bool {
if s.Struct.Uint16(8) != 0 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Brand_Scope) SetBind(v Brand_Binding_List) error {
s.Struct.SetUint16(8, 0)
return s.Struct.SetPtr(0, v.List.ToPtr())
}
// NewBind sets the bind field to a newly
// allocated Brand_Binding_List, preferring placement in s's segment.
func (s Brand_Scope) NewBind(n int32) (Brand_Binding_List, error) {
s.Struct.SetUint16(8, 0)
l, err := NewBrand_Binding_List(s.Struct.Segment(), n)
if err != nil {
return Brand_Binding_List{}, err
}
err = s.Struct.SetPtr(0, l.List.ToPtr())
return l, err
}
func (s Brand_Scope) SetInherit() {
s.Struct.SetUint16(8, 1)
}
// Brand_Scope_List is a list of Brand_Scope.
type Brand_Scope_List struct{ capnp.List }
// NewBrand_Scope creates a new list of Brand_Scope.
func NewBrand_Scope_List(s *capnp.Segment, sz int32) (Brand_Scope_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
return Brand_Scope_List{l}, err
}
func (s Brand_Scope_List) At(i int) Brand_Scope { return Brand_Scope{s.List.Struct(i)} }
func (s Brand_Scope_List) Set(i int, v Brand_Scope) error { return s.List.SetStruct(i, v.Struct) }
// Brand_Scope_Promise is a wrapper for a Brand_Scope promised by a client call.
type Brand_Scope_Promise struct{ *capnp.Pipeline }
func (p Brand_Scope_Promise) Struct() (Brand_Scope, error) {
s, err := p.Pipeline.Struct()
return Brand_Scope{s}, err
}
type Brand_Binding struct{ capnp.Struct }
type Brand_Binding_Which uint16
const (
Brand_Binding_Which_unbound Brand_Binding_Which = 0
Brand_Binding_Which_type Brand_Binding_Which = 1
)
func (w Brand_Binding_Which) String() string {
const s = "unboundtype"
switch w {
case Brand_Binding_Which_unbound:
return s[0:7]
case Brand_Binding_Which_type:
return s[7:11]
}
return "Brand_Binding_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
// Brand_Binding_TypeID is the unique identifier for the type Brand_Binding.
const Brand_Binding_TypeID = 0xc863cd16969ee7fc
func NewBrand_Binding(s *capnp.Segment) (Brand_Binding, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return Brand_Binding{st}, err
}
func NewRootBrand_Binding(s *capnp.Segment) (Brand_Binding, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return Brand_Binding{st}, err
}
func ReadRootBrand_Binding(msg *capnp.Message) (Brand_Binding, error) {
root, err := msg.RootPtr()
return Brand_Binding{root.Struct()}, err
}
func (s Brand_Binding) Which() Brand_Binding_Which {
return Brand_Binding_Which(s.Struct.Uint16(0))
}
func (s Brand_Binding) SetUnbound() {
s.Struct.SetUint16(0, 0)
}
func (s Brand_Binding) Type() (Type, error) {
p, err := s.Struct.Ptr(0)
return Type{Struct: p.Struct()}, err
}
func (s Brand_Binding) HasType() bool {
if s.Struct.Uint16(0) != 1 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Brand_Binding) SetType(v Type) error {
s.Struct.SetUint16(0, 1)
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewType sets the type field to a newly
// allocated Type struct, preferring placement in s's segment.
func (s Brand_Binding) NewType() (Type, error) {
s.Struct.SetUint16(0, 1)
ss, err := NewType(s.Struct.Segment())
if err != nil {
return Type{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// Brand_Binding_List is a list of Brand_Binding.
type Brand_Binding_List struct{ capnp.List }
// NewBrand_Binding creates a new list of Brand_Binding.
func NewBrand_Binding_List(s *capnp.Segment, sz int32) (Brand_Binding_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
return Brand_Binding_List{l}, err
}
func (s Brand_Binding_List) At(i int) Brand_Binding { return Brand_Binding{s.List.Struct(i)} }
func (s Brand_Binding_List) Set(i int, v Brand_Binding) error { return s.List.SetStruct(i, v.Struct) }
// Brand_Binding_Promise is a wrapper for a Brand_Binding promised by a client call.
type Brand_Binding_Promise struct{ *capnp.Pipeline }
func (p Brand_Binding_Promise) Struct() (Brand_Binding, error) {
s, err := p.Pipeline.Struct()
return Brand_Binding{s}, err
}
func (p Brand_Binding_Promise) Type() Type_Promise {
return Type_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type Value struct{ capnp.Struct }
type Value_Which uint16
const (
Value_Which_void Value_Which = 0
Value_Which_bool Value_Which = 1
Value_Which_int8 Value_Which = 2
Value_Which_int16 Value_Which = 3
Value_Which_int32 Value_Which = 4
Value_Which_int64 Value_Which = 5
Value_Which_uint8 Value_Which = 6
Value_Which_uint16 Value_Which = 7
Value_Which_uint32 Value_Which = 8
Value_Which_uint64 Value_Which = 9
Value_Which_float32 Value_Which = 10
Value_Which_float64 Value_Which = 11
Value_Which_text Value_Which = 12
Value_Which_data Value_Which = 13
Value_Which_list Value_Which = 14
Value_Which_enum Value_Which = 15
Value_Which_structValue Value_Which = 16
Value_Which_interface Value_Which = 17
Value_Which_anyPointer Value_Which = 18
)
func (w Value_Which) String() string {
const s = "voidboolint8int16int32int64uint8uint16uint32uint64float32float64textdatalistenumstructValueinterfaceanyPointer"
switch w {
case Value_Which_void:
return s[0:4]
case Value_Which_bool:
return s[4:8]
case Value_Which_int8:
return s[8:12]
case Value_Which_int16:
return s[12:17]
case Value_Which_int32:
return s[17:22]
case Value_Which_int64:
return s[22:27]
case Value_Which_uint8:
return s[27:32]
case Value_Which_uint16:
return s[32:38]
case Value_Which_uint32:
return s[38:44]
case Value_Which_uint64:
return s[44:50]
case Value_Which_float32:
return s[50:57]
case Value_Which_float64:
return s[57:64]
case Value_Which_text:
return s[64:68]
case Value_Which_data:
return s[68:72]
case Value_Which_list:
return s[72:76]
case Value_Which_enum:
return s[76:80]
case Value_Which_structValue:
return s[80:91]
case Value_Which_interface:
return s[91:100]
case Value_Which_anyPointer:
return s[100:110]
}
return "Value_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
// Value_TypeID is the unique identifier for the type Value.
const Value_TypeID = 0xce23dcd2d7b00c9b
func NewValue(s *capnp.Segment) (Value, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
return Value{st}, err
}
func NewRootValue(s *capnp.Segment) (Value, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
return Value{st}, err
}
func ReadRootValue(msg *capnp.Message) (Value, error) {
root, err := msg.RootPtr()
return Value{root.Struct()}, err
}
func (s Value) Which() Value_Which {
return Value_Which(s.Struct.Uint16(0))
}
func (s Value) SetVoid() {
s.Struct.SetUint16(0, 0)
}
func (s Value) Bool() bool {
return s.Struct.Bit(16)
}
func (s Value) SetBool(v bool) {
s.Struct.SetUint16(0, 1)
s.Struct.SetBit(16, v)
}
func (s Value) Int8() int8 {
return int8(s.Struct.Uint8(2))
}
func (s Value) SetInt8(v int8) {
s.Struct.SetUint16(0, 2)
s.Struct.SetUint8(2, uint8(v))
}
func (s Value) Int16() int16 {
return int16(s.Struct.Uint16(2))
}
func (s Value) SetInt16(v int16) {
s.Struct.SetUint16(0, 3)
s.Struct.SetUint16(2, uint16(v))
}
func (s Value) Int32() int32 {
return int32(s.Struct.Uint32(4))
}
func (s Value) SetInt32(v int32) {
s.Struct.SetUint16(0, 4)
s.Struct.SetUint32(4, uint32(v))
}
func (s Value) Int64() int64 {
return int64(s.Struct.Uint64(8))
}
func (s Value) SetInt64(v int64) {
s.Struct.SetUint16(0, 5)
s.Struct.SetUint64(8, uint64(v))
}
func (s Value) Uint8() uint8 {
return s.Struct.Uint8(2)
}
func (s Value) SetUint8(v uint8) {
s.Struct.SetUint16(0, 6)
s.Struct.SetUint8(2, v)
}
func (s Value) Uint16() uint16 {
return s.Struct.Uint16(2)
}
func (s Value) SetUint16(v uint16) {
s.Struct.SetUint16(0, 7)
s.Struct.SetUint16(2, v)
}
func (s Value) Uint32() uint32 {
return s.Struct.Uint32(4)
}
func (s Value) SetUint32(v uint32) {
s.Struct.SetUint16(0, 8)
s.Struct.SetUint32(4, v)
}
func (s Value) Uint64() uint64 {
return s.Struct.Uint64(8)
}
func (s Value) SetUint64(v uint64) {
s.Struct.SetUint16(0, 9)
s.Struct.SetUint64(8, v)
}
func (s Value) Float32() float32 {
return math.Float32frombits(s.Struct.Uint32(4))
}
func (s Value) SetFloat32(v float32) {
s.Struct.SetUint16(0, 10)
s.Struct.SetUint32(4, math.Float32bits(v))
}
func (s Value) Float64() float64 {
return math.Float64frombits(s.Struct.Uint64(8))
}
func (s Value) SetFloat64(v float64) {
s.Struct.SetUint16(0, 11)
s.Struct.SetUint64(8, math.Float64bits(v))
}
func (s Value) Text() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Value) HasText() bool {
if s.Struct.Uint16(0) != 12 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Value) TextBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Value) SetText(v string) error {
s.Struct.SetUint16(0, 12)
return s.Struct.SetText(0, v)
}
func (s Value) Data() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return []byte(p.Data()), err
}
func (s Value) HasData() bool {
if s.Struct.Uint16(0) != 13 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Value) SetData(v []byte) error {
s.Struct.SetUint16(0, 13)
return s.Struct.SetData(0, v)
}
func (s Value) List() (capnp.Pointer, error) {
return s.Struct.Pointer(0)
}
func (s Value) HasList() bool {
if s.Struct.Uint16(0) != 14 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Value) ListPtr() (capnp.Ptr, error) {
return s.Struct.Ptr(0)
}
func (s Value) SetList(v capnp.Pointer) error {
s.Struct.SetUint16(0, 14)
return s.Struct.SetPointer(0, v)
}
func (s Value) SetListPtr(v capnp.Ptr) error {
s.Struct.SetUint16(0, 14)
return s.Struct.SetPtr(0, v)
}
func (s Value) Enum() uint16 {
return s.Struct.Uint16(2)
}
func (s Value) SetEnum(v uint16) {
s.Struct.SetUint16(0, 15)
s.Struct.SetUint16(2, v)
}
func (s Value) StructValue() (capnp.Pointer, error) {
return s.Struct.Pointer(0)
}
func (s Value) HasStructValue() bool {
if s.Struct.Uint16(0) != 16 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Value) StructValuePtr() (capnp.Ptr, error) {
return s.Struct.Ptr(0)
}
func (s Value) SetStructValue(v capnp.Pointer) error {
s.Struct.SetUint16(0, 16)
return s.Struct.SetPointer(0, v)
}
func (s Value) SetStructValuePtr(v capnp.Ptr) error {
s.Struct.SetUint16(0, 16)
return s.Struct.SetPtr(0, v)
}
func (s Value) SetInterface() {
s.Struct.SetUint16(0, 17)
}
func (s Value) AnyPointer() (capnp.Pointer, error) {
return s.Struct.Pointer(0)
}
func (s Value) HasAnyPointer() bool {
if s.Struct.Uint16(0) != 18 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Value) AnyPointerPtr() (capnp.Ptr, error) {
return s.Struct.Ptr(0)
}
func (s Value) SetAnyPointer(v capnp.Pointer) error {
s.Struct.SetUint16(0, 18)
return s.Struct.SetPointer(0, v)
}
func (s Value) SetAnyPointerPtr(v capnp.Ptr) error {
s.Struct.SetUint16(0, 18)
return s.Struct.SetPtr(0, v)
}
// Value_List is a list of Value.
type Value_List struct{ capnp.List }
// NewValue creates a new list of Value.
func NewValue_List(s *capnp.Segment, sz int32) (Value_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
return Value_List{l}, err
}
func (s Value_List) At(i int) Value { return Value{s.List.Struct(i)} }
func (s Value_List) Set(i int, v Value) error { return s.List.SetStruct(i, v.Struct) }
// Value_Promise is a wrapper for a Value promised by a client call.
type Value_Promise struct{ *capnp.Pipeline }
func (p Value_Promise) Struct() (Value, error) {
s, err := p.Pipeline.Struct()
return Value{s}, err
}
func (p Value_Promise) List() *capnp.Pipeline {
return p.Pipeline.GetPipeline(0)
}
func (p Value_Promise) StructValue() *capnp.Pipeline {
return p.Pipeline.GetPipeline(0)
}
func (p Value_Promise) AnyPointer() *capnp.Pipeline {
return p.Pipeline.GetPipeline(0)
}
type Annotation struct{ capnp.Struct }
// Annotation_TypeID is the unique identifier for the type Annotation.
const Annotation_TypeID = 0xf1c8950dab257542
func NewAnnotation(s *capnp.Segment) (Annotation, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return Annotation{st}, err
}
func NewRootAnnotation(s *capnp.Segment) (Annotation, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return Annotation{st}, err
}
func ReadRootAnnotation(msg *capnp.Message) (Annotation, error) {
root, err := msg.RootPtr()
return Annotation{root.Struct()}, err
}
func (s Annotation) Id() uint64 {
return s.Struct.Uint64(0)
}
func (s Annotation) SetId(v uint64) {
s.Struct.SetUint64(0, v)
}
func (s Annotation) Brand() (Brand, error) {
p, err := s.Struct.Ptr(1)
return Brand{Struct: p.Struct()}, err
}
func (s Annotation) HasBrand() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Annotation) SetBrand(v Brand) error {
return s.Struct.SetPtr(1, v.Struct.ToPtr())
}
// NewBrand sets the brand field to a newly
// allocated Brand struct, preferring placement in s's segment.
func (s Annotation) NewBrand() (Brand, error) {
ss, err := NewBrand(s.Struct.Segment())
if err != nil {
return Brand{}, err
}
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
return ss, err
}
func (s Annotation) Value() (Value, error) {
p, err := s.Struct.Ptr(0)
return Value{Struct: p.Struct()}, err
}
func (s Annotation) HasValue() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Annotation) SetValue(v Value) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewValue sets the value field to a newly
// allocated Value struct, preferring placement in s's segment.
func (s Annotation) NewValue() (Value, error) {
ss, err := NewValue(s.Struct.Segment())
if err != nil {
return Value{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// Annotation_List is a list of Annotation.
type Annotation_List struct{ capnp.List }
// NewAnnotation creates a new list of Annotation.
func NewAnnotation_List(s *capnp.Segment, sz int32) (Annotation_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
return Annotation_List{l}, err
}
func (s Annotation_List) At(i int) Annotation { return Annotation{s.List.Struct(i)} }
func (s Annotation_List) Set(i int, v Annotation) error { return s.List.SetStruct(i, v.Struct) }
// Annotation_Promise is a wrapper for a Annotation promised by a client call.
type Annotation_Promise struct{ *capnp.Pipeline }
func (p Annotation_Promise) Struct() (Annotation, error) {
s, err := p.Pipeline.Struct()
return Annotation{s}, err
}
func (p Annotation_Promise) Brand() Brand_Promise {
return Brand_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}
func (p Annotation_Promise) Value() Value_Promise {
return Value_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type ElementSize uint16
// ElementSize_TypeID is the unique identifier for the type ElementSize.
const ElementSize_TypeID = 0xd1958f7dba521926
// Values of ElementSize.
const (
ElementSize_empty ElementSize = 0
ElementSize_bit ElementSize = 1
ElementSize_byte ElementSize = 2
ElementSize_twoBytes ElementSize = 3
ElementSize_fourBytes ElementSize = 4
ElementSize_eightBytes ElementSize = 5
ElementSize_pointer ElementSize = 6
ElementSize_inlineComposite ElementSize = 7
)
// String returns the enum's constant name.
func (c ElementSize) String() string {
switch c {
case ElementSize_empty:
return "empty"
case ElementSize_bit:
return "bit"
case ElementSize_byte:
return "byte"
case ElementSize_twoBytes:
return "twoBytes"
case ElementSize_fourBytes:
return "fourBytes"
case ElementSize_eightBytes:
return "eightBytes"
case ElementSize_pointer:
return "pointer"
case ElementSize_inlineComposite:
return "inlineComposite"
default:
return ""
}
}
// ElementSizeFromString returns the enum value with a name,
// or the zero value if there's no such value.
func ElementSizeFromString(c string) ElementSize {
switch c {
case "empty":
return ElementSize_empty
case "bit":
return ElementSize_bit
case "byte":
return ElementSize_byte
case "twoBytes":
return ElementSize_twoBytes
case "fourBytes":
return ElementSize_fourBytes
case "eightBytes":
return ElementSize_eightBytes
case "pointer":
return ElementSize_pointer
case "inlineComposite":
return ElementSize_inlineComposite
default:
return 0
}
}
type ElementSize_List struct{ capnp.List }
func NewElementSize_List(s *capnp.Segment, sz int32) (ElementSize_List, error) {
l, err := capnp.NewUInt16List(s, sz)
return ElementSize_List{l.List}, err
}
func (l ElementSize_List) At(i int) ElementSize {
ul := capnp.UInt16List{List: l.List}
return ElementSize(ul.At(i))
}
func (l ElementSize_List) Set(i int, v ElementSize) {
ul := capnp.UInt16List{List: l.List}
ul.Set(i, uint16(v))
}
type CodeGeneratorRequest struct{ capnp.Struct }
// CodeGeneratorRequest_TypeID is the unique identifier for the type CodeGeneratorRequest.
const CodeGeneratorRequest_TypeID = 0xbfc546f6210ad7ce
func NewCodeGeneratorRequest(s *capnp.Segment) (CodeGeneratorRequest, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return CodeGeneratorRequest{st}, err
}
func NewRootCodeGeneratorRequest(s *capnp.Segment) (CodeGeneratorRequest, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return CodeGeneratorRequest{st}, err
}
func ReadRootCodeGeneratorRequest(msg *capnp.Message) (CodeGeneratorRequest, error) {
root, err := msg.RootPtr()
return CodeGeneratorRequest{root.Struct()}, err
}
func (s CodeGeneratorRequest) Nodes() (Node_List, error) {
p, err := s.Struct.Ptr(0)
return Node_List{List: p.List()}, err
}
func (s CodeGeneratorRequest) HasNodes() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s CodeGeneratorRequest) SetNodes(v Node_List) error {
return s.Struct.SetPtr(0, v.List.ToPtr())
}
// NewNodes sets the nodes field to a newly
// allocated Node_List, preferring placement in s's segment.
func (s CodeGeneratorRequest) NewNodes(n int32) (Node_List, error) {
l, err := NewNode_List(s.Struct.Segment(), n)
if err != nil {
return Node_List{}, err
}
err = s.Struct.SetPtr(0, l.List.ToPtr())
return l, err
}
func (s CodeGeneratorRequest) RequestedFiles() (CodeGeneratorRequest_RequestedFile_List, error) {
p, err := s.Struct.Ptr(1)
return CodeGeneratorRequest_RequestedFile_List{List: p.List()}, err
}
func (s CodeGeneratorRequest) HasRequestedFiles() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s CodeGeneratorRequest) SetRequestedFiles(v CodeGeneratorRequest_RequestedFile_List) error {
return s.Struct.SetPtr(1, v.List.ToPtr())
}
// NewRequestedFiles sets the requestedFiles field to a newly
// allocated CodeGeneratorRequest_RequestedFile_List, preferring placement in s's segment.
func (s CodeGeneratorRequest) NewRequestedFiles(n int32) (CodeGeneratorRequest_RequestedFile_List, error) {
l, err := NewCodeGeneratorRequest_RequestedFile_List(s.Struct.Segment(), n)
if err != nil {
return CodeGeneratorRequest_RequestedFile_List{}, err
}
err = s.Struct.SetPtr(1, l.List.ToPtr())
return l, err
}
// CodeGeneratorRequest_List is a list of CodeGeneratorRequest.
type CodeGeneratorRequest_List struct{ capnp.List }
// NewCodeGeneratorRequest creates a new list of CodeGeneratorRequest.
func NewCodeGeneratorRequest_List(s *capnp.Segment, sz int32) (CodeGeneratorRequest_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
return CodeGeneratorRequest_List{l}, err
}
func (s CodeGeneratorRequest_List) At(i int) CodeGeneratorRequest {
return CodeGeneratorRequest{s.List.Struct(i)}
}
func (s CodeGeneratorRequest_List) Set(i int, v CodeGeneratorRequest) error {
return s.List.SetStruct(i, v.Struct)
}
// CodeGeneratorRequest_Promise is a wrapper for a CodeGeneratorRequest promised by a client call.
type CodeGeneratorRequest_Promise struct{ *capnp.Pipeline }
func (p CodeGeneratorRequest_Promise) Struct() (CodeGeneratorRequest, error) {
s, err := p.Pipeline.Struct()
return CodeGeneratorRequest{s}, err
}
type CodeGeneratorRequest_RequestedFile struct{ capnp.Struct }
// CodeGeneratorRequest_RequestedFile_TypeID is the unique identifier for the type CodeGeneratorRequest_RequestedFile.
const CodeGeneratorRequest_RequestedFile_TypeID = 0xcfea0eb02e810062
func NewCodeGeneratorRequest_RequestedFile(s *capnp.Segment) (CodeGeneratorRequest_RequestedFile, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return CodeGeneratorRequest_RequestedFile{st}, err
}
func NewRootCodeGeneratorRequest_RequestedFile(s *capnp.Segment) (CodeGeneratorRequest_RequestedFile, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return CodeGeneratorRequest_RequestedFile{st}, err
}
func ReadRootCodeGeneratorRequest_RequestedFile(msg *capnp.Message) (CodeGeneratorRequest_RequestedFile, error) {
root, err := msg.RootPtr()
return CodeGeneratorRequest_RequestedFile{root.Struct()}, err
}
func (s CodeGeneratorRequest_RequestedFile) Id() uint64 {
return s.Struct.Uint64(0)
}
func (s CodeGeneratorRequest_RequestedFile) SetId(v uint64) {
s.Struct.SetUint64(0, v)
}
func (s CodeGeneratorRequest_RequestedFile) Filename() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s CodeGeneratorRequest_RequestedFile) HasFilename() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s CodeGeneratorRequest_RequestedFile) FilenameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s CodeGeneratorRequest_RequestedFile) SetFilename(v string) error {
return s.Struct.SetText(0, v)
}
func (s CodeGeneratorRequest_RequestedFile) Imports() (CodeGeneratorRequest_RequestedFile_Import_List, error) {
p, err := s.Struct.Ptr(1)
return CodeGeneratorRequest_RequestedFile_Import_List{List: p.List()}, err
}
func (s CodeGeneratorRequest_RequestedFile) HasImports() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s CodeGeneratorRequest_RequestedFile) SetImports(v CodeGeneratorRequest_RequestedFile_Import_List) error {
return s.Struct.SetPtr(1, v.List.ToPtr())
}
// NewImports sets the imports field to a newly
// allocated CodeGeneratorRequest_RequestedFile_Import_List, preferring placement in s's segment.
func (s CodeGeneratorRequest_RequestedFile) NewImports(n int32) (CodeGeneratorRequest_RequestedFile_Import_List, error) {
l, err := NewCodeGeneratorRequest_RequestedFile_Import_List(s.Struct.Segment(), n)
if err != nil {
return CodeGeneratorRequest_RequestedFile_Import_List{}, err
}
err = s.Struct.SetPtr(1, l.List.ToPtr())
return l, err
}
// CodeGeneratorRequest_RequestedFile_List is a list of CodeGeneratorRequest_RequestedFile.
type CodeGeneratorRequest_RequestedFile_List struct{ capnp.List }
// NewCodeGeneratorRequest_RequestedFile creates a new list of CodeGeneratorRequest_RequestedFile.
func NewCodeGeneratorRequest_RequestedFile_List(s *capnp.Segment, sz int32) (CodeGeneratorRequest_RequestedFile_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
return CodeGeneratorRequest_RequestedFile_List{l}, err
}
func (s CodeGeneratorRequest_RequestedFile_List) At(i int) CodeGeneratorRequest_RequestedFile {
return CodeGeneratorRequest_RequestedFile{s.List.Struct(i)}
}
func (s CodeGeneratorRequest_RequestedFile_List) Set(i int, v CodeGeneratorRequest_RequestedFile) error {
return s.List.SetStruct(i, v.Struct)
}
// CodeGeneratorRequest_RequestedFile_Promise is a wrapper for a CodeGeneratorRequest_RequestedFile promised by a client call.
type CodeGeneratorRequest_RequestedFile_Promise struct{ *capnp.Pipeline }
func (p CodeGeneratorRequest_RequestedFile_Promise) Struct() (CodeGeneratorRequest_RequestedFile, error) {
s, err := p.Pipeline.Struct()
return CodeGeneratorRequest_RequestedFile{s}, err
}
type CodeGeneratorRequest_RequestedFile_Import struct{ capnp.Struct }
// CodeGeneratorRequest_RequestedFile_Import_TypeID is the unique identifier for the type CodeGeneratorRequest_RequestedFile_Import.
const CodeGeneratorRequest_RequestedFile_Import_TypeID = 0xae504193122357e5
func NewCodeGeneratorRequest_RequestedFile_Import(s *capnp.Segment) (CodeGeneratorRequest_RequestedFile_Import, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return CodeGeneratorRequest_RequestedFile_Import{st}, err
}
func NewRootCodeGeneratorRequest_RequestedFile_Import(s *capnp.Segment) (CodeGeneratorRequest_RequestedFile_Import, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return CodeGeneratorRequest_RequestedFile_Import{st}, err
}
func ReadRootCodeGeneratorRequest_RequestedFile_Import(msg *capnp.Message) (CodeGeneratorRequest_RequestedFile_Import, error) {
root, err := msg.RootPtr()
return CodeGeneratorRequest_RequestedFile_Import{root.Struct()}, err
}
func (s CodeGeneratorRequest_RequestedFile_Import) Id() uint64 {
return s.Struct.Uint64(0)
}
func (s CodeGeneratorRequest_RequestedFile_Import) SetId(v uint64) {
s.Struct.SetUint64(0, v)
}
func (s CodeGeneratorRequest_RequestedFile_Import) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s CodeGeneratorRequest_RequestedFile_Import) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s CodeGeneratorRequest_RequestedFile_Import) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s CodeGeneratorRequest_RequestedFile_Import) SetName(v string) error {
return s.Struct.SetText(0, v)
}
// CodeGeneratorRequest_RequestedFile_Import_List is a list of CodeGeneratorRequest_RequestedFile_Import.
type CodeGeneratorRequest_RequestedFile_Import_List struct{ capnp.List }
// NewCodeGeneratorRequest_RequestedFile_Import creates a new list of CodeGeneratorRequest_RequestedFile_Import.
func NewCodeGeneratorRequest_RequestedFile_Import_List(s *capnp.Segment, sz int32) (CodeGeneratorRequest_RequestedFile_Import_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
return CodeGeneratorRequest_RequestedFile_Import_List{l}, err
}
func (s CodeGeneratorRequest_RequestedFile_Import_List) At(i int) CodeGeneratorRequest_RequestedFile_Import {
return CodeGeneratorRequest_RequestedFile_Import{s.List.Struct(i)}
}
func (s CodeGeneratorRequest_RequestedFile_Import_List) Set(i int, v CodeGeneratorRequest_RequestedFile_Import) error {
return s.List.SetStruct(i, v.Struct)
}
// CodeGeneratorRequest_RequestedFile_Import_Promise is a wrapper for a CodeGeneratorRequest_RequestedFile_Import promised by a client call.
type CodeGeneratorRequest_RequestedFile_Import_Promise struct{ *capnp.Pipeline }
func (p CodeGeneratorRequest_RequestedFile_Import_Promise) Struct() (CodeGeneratorRequest_RequestedFile_Import, error) {
s, err := p.Pipeline.Struct()
return CodeGeneratorRequest_RequestedFile_Import{s}, err
}
Reference in New Issue View Git Blame Copy Permalink