blob: 4b67d753c2d87a42926fd114bb1954bee2a9eae6 [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen
////////////////////////////////////////////////////////////////////////////////
package test
import (
"fmt"
"android.googlesource.com/platform/tools/gpu/binary"
"android.googlesource.com/platform/tools/gpu/binary/registry"
"android.googlesource.com/platform/tools/gpu/binary/schema"
)
var Namespace = registry.NewNamespace()
func init() {
registry.Global.AddFallbacks(Namespace)
Namespace.Add((*ListNode)(nil).Class())
Namespace.Add((*Resource)(nil).Class())
Namespace.Add((*Struct)(nil).Class())
Namespace.Add((*callAdd)(nil).Class())
Namespace.Add((*callEnumToString)(nil).Class())
Namespace.Add((*callGetListNodeChain)(nil).Class())
Namespace.Add((*callGetListNodeChainArray)(nil).Class())
Namespace.Add((*callGetResource)(nil).Class())
Namespace.Add((*callGetSingleListNode)(nil).Class())
Namespace.Add((*callGetStruct)(nil).Class())
Namespace.Add((*callResolveResource)(nil).Class())
Namespace.Add((*callSetStruct)(nil).Class())
Namespace.Add((*callUseResource)(nil).Class())
Namespace.Add((*resultAdd)(nil).Class())
Namespace.Add((*resultEnumToString)(nil).Class())
Namespace.Add((*resultGetListNodeChain)(nil).Class())
Namespace.Add((*resultGetListNodeChainArray)(nil).Class())
Namespace.Add((*resultGetResource)(nil).Class())
Namespace.Add((*resultGetSingleListNode)(nil).Class())
Namespace.Add((*resultGetStruct)(nil).Class())
Namespace.Add((*resultResolveResource)(nil).Class())
Namespace.Add((*resultSetStruct)(nil).Class())
Namespace.Add((*resultUseResource)(nil).Class())
}
var (
binaryIDListNode = binary.ID{0xd4, 0x62, 0x72, 0x4c, 0xa0, 0x8b, 0xae, 0x1b, 0xad, 0x98, 0x12, 0x6d, 0x2f, 0x95, 0x38, 0xe7, 0x74, 0x4f, 0xb7, 0x6e}
binaryIDResource = binary.ID{0x28, 0x69, 0x24, 0xfd, 0x18, 0x32, 0x76, 0xf6, 0x52, 0x91, 0xd4, 0xf3, 0x70, 0x6e, 0xc9, 0x55, 0x30, 0x59, 0x55, 0x1a}
binaryIDStruct = binary.ID{0x1b, 0x23, 0x6b, 0xfa, 0x68, 0x0a, 0x1a, 0x1a, 0xa6, 0x15, 0xfe, 0x89, 0x8c, 0x05, 0x91, 0xa2, 0x92, 0x56, 0x1d, 0x58}
binaryIDcallAdd = binary.ID{0x9c, 0xb8, 0x89, 0x5a, 0x48, 0xc9, 0x85, 0x6e, 0x1d, 0x35, 0x40, 0x50, 0xa1, 0x38, 0x3b, 0x6f, 0xcb, 0xa0, 0x6c, 0xb8}
binaryIDcallEnumToString = binary.ID{0x58, 0x2d, 0x2b, 0xe3, 0x41, 0xac, 0xce, 0x57, 0x0c, 0x0e, 0x45, 0x50, 0xfd, 0xab, 0xae, 0x64, 0x1b, 0xca, 0x46, 0xca}
binaryIDcallGetListNodeChain = binary.ID{0xe4, 0x4b, 0x9d, 0xdf, 0xeb, 0x01, 0x49, 0x16, 0x20, 0x05, 0xcc, 0x24, 0x3f, 0x13, 0xb3, 0x4d, 0x50, 0x44, 0x78, 0x51}
binaryIDcallGetListNodeChainArray = binary.ID{0x6c, 0xbf, 0x17, 0x6a, 0xd0, 0x21, 0x13, 0x21, 0x81, 0xd0, 0x9c, 0x51, 0x14, 0xea, 0x88, 0x4a, 0x57, 0x7a, 0x00, 0x2a}
binaryIDcallGetResource = binary.ID{0x77, 0x3f, 0xbc, 0xe2, 0x64, 0xc6, 0x25, 0xb9, 0xd3, 0x1e, 0x82, 0xa5, 0x29, 0x94, 0x99, 0x60, 0x63, 0x66, 0xde, 0x5f}
binaryIDcallGetSingleListNode = binary.ID{0x6d, 0x63, 0x54, 0xb7, 0x28, 0xf3, 0x2c, 0x5f, 0xcf, 0xc5, 0x61, 0xef, 0xa6, 0xd8, 0x89, 0x67, 0x46, 0xb1, 0x87, 0x34}
binaryIDcallGetStruct = binary.ID{0xf1, 0xb4, 0x06, 0x21, 0xfa, 0x76, 0x1d, 0x55, 0x86, 0x0a, 0x96, 0x85, 0x34, 0x26, 0x05, 0x30, 0xd6, 0xb2, 0x97, 0xeb}
binaryIDcallResolveResource = binary.ID{0x70, 0x71, 0x92, 0x48, 0x7c, 0x3e, 0x65, 0x58, 0x27, 0xa5, 0x0c, 0xc0, 0x87, 0x65, 0x61, 0x8a, 0xb3, 0x28, 0xc0, 0x0a}
binaryIDcallSetStruct = binary.ID{0x63, 0x7e, 0x8e, 0x85, 0x9d, 0x23, 0x3f, 0x28, 0xd8, 0x3d, 0x81, 0x27, 0x0e, 0x8d, 0xe2, 0x11, 0x75, 0xbf, 0x73, 0x76}
binaryIDcallUseResource = binary.ID{0x58, 0x91, 0xd1, 0x9c, 0x05, 0x9c, 0xe5, 0x96, 0xf1, 0x22, 0xf9, 0x61, 0x83, 0xfb, 0x34, 0x4e, 0x2d, 0xad, 0x3d, 0x02}
binaryIDresultAdd = binary.ID{0x1c, 0x34, 0x05, 0xbf, 0x9a, 0x3c, 0xe5, 0xce, 0x1f, 0x5c, 0x2d, 0xf9, 0xdd, 0xab, 0x33, 0xb6, 0xfa, 0xa1, 0xd5, 0x2b}
binaryIDresultEnumToString = binary.ID{0x82, 0xf6, 0xd5, 0x1a, 0x4d, 0xec, 0x38, 0xa6, 0x47, 0xa2, 0x1f, 0x6c, 0xc6, 0xa8, 0x69, 0x7f, 0x28, 0x5b, 0x21, 0x2e}
binaryIDresultGetListNodeChain = binary.ID{0x8f, 0x0f, 0xb2, 0x7b, 0xbe, 0x33, 0x17, 0x99, 0x39, 0x6b, 0x64, 0x9b, 0xe5, 0x6a, 0x99, 0x14, 0x59, 0xc3, 0x6b, 0x94}
binaryIDresultGetListNodeChainArray = binary.ID{0x36, 0xbe, 0x44, 0x9b, 0x46, 0x33, 0x15, 0x48, 0x1d, 0x66, 0xd0, 0x2c, 0xad, 0x5d, 0x15, 0x8c, 0x2a, 0xc4, 0x17, 0x86}
binaryIDresultGetResource = binary.ID{0xd9, 0xc1, 0x1d, 0xc1, 0xa6, 0x84, 0x25, 0x9a, 0x59, 0x1e, 0xe1, 0x29, 0x92, 0x6b, 0x7b, 0x04, 0x27, 0x68, 0xcd, 0xfd}
binaryIDresultGetSingleListNode = binary.ID{0x53, 0x57, 0x00, 0x9c, 0xea, 0x9d, 0x01, 0x7e, 0xbb, 0x14, 0x01, 0x8e, 0x15, 0xe5, 0x12, 0xbd, 0x50, 0xd3, 0x82, 0x13}
binaryIDresultGetStruct = binary.ID{0xd5, 0x07, 0x0f, 0x6d, 0xf2, 0x2d, 0xdf, 0x7b, 0x43, 0xaf, 0x9e, 0x3d, 0x5b, 0x82, 0xb1, 0xa2, 0x26, 0xc1, 0x9b, 0x35}
binaryIDresultResolveResource = binary.ID{0x04, 0xe4, 0x8a, 0xdd, 0x2c, 0xf1, 0x1b, 0xf4, 0xeb, 0x48, 0xf1, 0xd3, 0x69, 0xe0, 0x2d, 0x75, 0xdd, 0x76, 0xa7, 0x5f}
binaryIDresultSetStruct = binary.ID{0x3d, 0xec, 0x2e, 0x5f, 0x2b, 0x8d, 0xd4, 0x91, 0xfe, 0x57, 0x57, 0x33, 0x8c, 0x50, 0x56, 0x14, 0xa8, 0xa0, 0x85, 0x2a}
binaryIDresultUseResource = binary.ID{0x81, 0x83, 0x0d, 0xf2, 0xfa, 0x0d, 0x75, 0x4c, 0xfa, 0xee, 0x14, 0x0e, 0xe5, 0x89, 0xa4, 0x27, 0x06, 0xdb, 0xf9, 0x2e}
)
type binaryClassListNode struct{}
func (*ListNode) Class() binary.Class {
return (*binaryClassListNode)(nil)
}
func doEncodeListNode(e binary.Encoder, o *ListNode) error {
if err := e.String(o.Name); err != nil {
return err
}
if o.Next != nil {
if err := e.Object(o.Next); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
return nil
}
func doDecodeListNode(d binary.Decoder, o *ListNode) error {
if obj, err := d.String(); err != nil {
return err
} else {
o.Name = string(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
o.Next = obj.(*ListNode)
} else {
o.Next = nil
}
return nil
}
func doSkipListNode(d binary.Decoder) error {
if err := d.SkipString(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
return nil
}
func (*binaryClassListNode) ID() binary.ID { return binaryIDListNode }
func (*binaryClassListNode) New() binary.Object { return &ListNode{} }
func (*binaryClassListNode) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeListNode(e, obj.(*ListNode))
}
func (*binaryClassListNode) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ListNode{}
return obj, doDecodeListNode(d, obj)
}
func (*binaryClassListNode) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeListNode(d, obj.(*ListNode))
}
func (*binaryClassListNode) Skip(d binary.Decoder) error { return doSkipListNode(d) }
func (*binaryClassListNode) Schema() *schema.Class { return schemaListNode }
var schemaListNode = &schema.Class{
TypeID: binaryIDListNode,
Package: "test",
Name: "ListNode",
Fields: []schema.Field{
{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
{Declared: "Next", Type: &schema.Pointer{Type: &schema.Struct{Name: "ListNode", ID: (*ListNode)(nil).Class().ID()}}},
},
}
type binaryClassResource struct{}
func (*Resource) Class() binary.Class {
return (*binaryClassResource)(nil)
}
func doEncodeResource(e binary.Encoder, o *Resource) error {
if err := e.Uint32(o.Int); err != nil {
return err
}
if err := e.Float32(o.Float); err != nil {
return err
}
if err := e.String(o.String); err != nil {
return err
}
return nil
}
func doDecodeResource(d binary.Decoder, o *Resource) error {
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Int = uint32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Float = float32(obj)
}
if obj, err := d.String(); err != nil {
return err
} else {
o.String = string(obj)
}
return nil
}
func doSkipResource(d binary.Decoder) error {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if err := d.SkipString(); err != nil {
return err
}
return nil
}
func (*binaryClassResource) ID() binary.ID { return binaryIDResource }
func (*binaryClassResource) New() binary.Object { return &Resource{} }
func (*binaryClassResource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeResource(e, obj.(*Resource))
}
func (*binaryClassResource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Resource{}
return obj, doDecodeResource(d, obj)
}
func (*binaryClassResource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeResource(d, obj.(*Resource))
}
func (*binaryClassResource) Skip(d binary.Decoder) error { return doSkipResource(d) }
func (*binaryClassResource) Schema() *schema.Class { return schemaResource }
var schemaResource = &schema.Class{
TypeID: binaryIDResource,
Package: "test",
Name: "Resource",
Fields: []schema.Field{
{Declared: "Int", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
{Declared: "Float", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
{Declared: "String", Type: &schema.Primitive{Name: "string", Method: schema.String}},
},
}
type binaryClassStruct struct{}
func (*Struct) Class() binary.Class {
return (*binaryClassStruct)(nil)
}
func doEncodeStruct(e binary.Encoder, o *Struct) error {
if err := e.String(o.String); err != nil {
return err
}
if err := e.Uint32(o.U32); err != nil {
return err
}
if err := e.Int32(int32(o.Enum)); err != nil {
return err
}
return nil
}
func doDecodeStruct(d binary.Decoder, o *Struct) error {
if obj, err := d.String(); err != nil {
return err
} else {
o.String = string(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.U32 = uint32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Enum = Enum(obj)
}
return nil
}
func doSkipStruct(d binary.Decoder) error {
if err := d.SkipString(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassStruct) ID() binary.ID { return binaryIDStruct }
func (*binaryClassStruct) New() binary.Object { return &Struct{} }
func (*binaryClassStruct) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeStruct(e, obj.(*Struct))
}
func (*binaryClassStruct) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Struct{}
return obj, doDecodeStruct(d, obj)
}
func (*binaryClassStruct) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeStruct(d, obj.(*Struct))
}
func (*binaryClassStruct) Skip(d binary.Decoder) error { return doSkipStruct(d) }
func (*binaryClassStruct) Schema() *schema.Class { return schemaStruct }
var schemaStruct = &schema.Class{
TypeID: binaryIDStruct,
Package: "test",
Name: "Struct",
Fields: []schema.Field{
{Declared: "String", Type: &schema.Primitive{Name: "string", Method: schema.String}},
{Declared: "U32", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
{Declared: "Enum", Type: &schema.Primitive{Name: "Enum", Method: schema.Int32}},
},
}
type binaryClasscallAdd struct{}
func (*callAdd) Class() binary.Class {
return (*binaryClasscallAdd)(nil)
}
func doEncodecallAdd(e binary.Encoder, o *callAdd) error {
if err := e.Uint32(o.a); err != nil {
return err
}
if err := e.Uint32(o.b); err != nil {
return err
}
return nil
}
func doDecodecallAdd(d binary.Decoder, o *callAdd) error {
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.a = uint32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.b = uint32(obj)
}
return nil
}
func doSkipcallAdd(d binary.Decoder) error {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClasscallAdd) ID() binary.ID { return binaryIDcallAdd }
func (*binaryClasscallAdd) New() binary.Object { return &callAdd{} }
func (*binaryClasscallAdd) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallAdd(e, obj.(*callAdd))
}
func (*binaryClasscallAdd) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callAdd{}
return obj, doDecodecallAdd(d, obj)
}
func (*binaryClasscallAdd) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallAdd(d, obj.(*callAdd))
}
func (*binaryClasscallAdd) Skip(d binary.Decoder) error { return doSkipcallAdd(d) }
func (*binaryClasscallAdd) Schema() *schema.Class { return schemacallAdd }
var schemacallAdd = &schema.Class{
TypeID: binaryIDcallAdd,
Package: "test",
Name: "callAdd",
Fields: []schema.Field{
{Declared: "a", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
{Declared: "b", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
},
}
type binaryClasscallEnumToString struct{}
func (*callEnumToString) Class() binary.Class {
return (*binaryClasscallEnumToString)(nil)
}
func doEncodecallEnumToString(e binary.Encoder, o *callEnumToString) error {
if err := e.Int32(int32(o.e)); err != nil {
return err
}
return nil
}
func doDecodecallEnumToString(d binary.Decoder, o *callEnumToString) error {
if obj, err := d.Int32(); err != nil {
return err
} else {
o.e = Enum(obj)
}
return nil
}
func doSkipcallEnumToString(d binary.Decoder) error {
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClasscallEnumToString) ID() binary.ID { return binaryIDcallEnumToString }
func (*binaryClasscallEnumToString) New() binary.Object { return &callEnumToString{} }
func (*binaryClasscallEnumToString) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallEnumToString(e, obj.(*callEnumToString))
}
func (*binaryClasscallEnumToString) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callEnumToString{}
return obj, doDecodecallEnumToString(d, obj)
}
func (*binaryClasscallEnumToString) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallEnumToString(d, obj.(*callEnumToString))
}
func (*binaryClasscallEnumToString) Skip(d binary.Decoder) error { return doSkipcallEnumToString(d) }
func (*binaryClasscallEnumToString) Schema() *schema.Class { return schemacallEnumToString }
var schemacallEnumToString = &schema.Class{
TypeID: binaryIDcallEnumToString,
Package: "test",
Name: "callEnumToString",
Fields: []schema.Field{
{Declared: "e", Type: &schema.Primitive{Name: "Enum", Method: schema.Int32}},
},
}
type binaryClasscallGetListNodeChain struct{}
func (*callGetListNodeChain) Class() binary.Class {
return (*binaryClasscallGetListNodeChain)(nil)
}
func doEncodecallGetListNodeChain(e binary.Encoder, o *callGetListNodeChain) error {
return nil
}
func doDecodecallGetListNodeChain(d binary.Decoder, o *callGetListNodeChain) error {
return nil
}
func doSkipcallGetListNodeChain(d binary.Decoder) error {
return nil
}
func (*binaryClasscallGetListNodeChain) ID() binary.ID { return binaryIDcallGetListNodeChain }
func (*binaryClasscallGetListNodeChain) New() binary.Object { return &callGetListNodeChain{} }
func (*binaryClasscallGetListNodeChain) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallGetListNodeChain(e, obj.(*callGetListNodeChain))
}
func (*binaryClasscallGetListNodeChain) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callGetListNodeChain{}
return obj, doDecodecallGetListNodeChain(d, obj)
}
func (*binaryClasscallGetListNodeChain) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallGetListNodeChain(d, obj.(*callGetListNodeChain))
}
func (*binaryClasscallGetListNodeChain) Skip(d binary.Decoder) error {
return doSkipcallGetListNodeChain(d)
}
func (*binaryClasscallGetListNodeChain) Schema() *schema.Class { return schemacallGetListNodeChain }
var schemacallGetListNodeChain = &schema.Class{
TypeID: binaryIDcallGetListNodeChain,
Package: "test",
Name: "callGetListNodeChain",
Fields: []schema.Field{},
}
type binaryClasscallGetListNodeChainArray struct{}
func (*callGetListNodeChainArray) Class() binary.Class {
return (*binaryClasscallGetListNodeChainArray)(nil)
}
func doEncodecallGetListNodeChainArray(e binary.Encoder, o *callGetListNodeChainArray) error {
return nil
}
func doDecodecallGetListNodeChainArray(d binary.Decoder, o *callGetListNodeChainArray) error {
return nil
}
func doSkipcallGetListNodeChainArray(d binary.Decoder) error {
return nil
}
func (*binaryClasscallGetListNodeChainArray) ID() binary.ID { return binaryIDcallGetListNodeChainArray }
func (*binaryClasscallGetListNodeChainArray) New() binary.Object { return &callGetListNodeChainArray{} }
func (*binaryClasscallGetListNodeChainArray) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallGetListNodeChainArray(e, obj.(*callGetListNodeChainArray))
}
func (*binaryClasscallGetListNodeChainArray) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callGetListNodeChainArray{}
return obj, doDecodecallGetListNodeChainArray(d, obj)
}
func (*binaryClasscallGetListNodeChainArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallGetListNodeChainArray(d, obj.(*callGetListNodeChainArray))
}
func (*binaryClasscallGetListNodeChainArray) Skip(d binary.Decoder) error {
return doSkipcallGetListNodeChainArray(d)
}
func (*binaryClasscallGetListNodeChainArray) Schema() *schema.Class {
return schemacallGetListNodeChainArray
}
var schemacallGetListNodeChainArray = &schema.Class{
TypeID: binaryIDcallGetListNodeChainArray,
Package: "test",
Name: "callGetListNodeChainArray",
Fields: []schema.Field{},
}
type binaryClasscallGetResource struct{}
func (*callGetResource) Class() binary.Class {
return (*binaryClasscallGetResource)(nil)
}
func doEncodecallGetResource(e binary.Encoder, o *callGetResource) error {
return nil
}
func doDecodecallGetResource(d binary.Decoder, o *callGetResource) error {
return nil
}
func doSkipcallGetResource(d binary.Decoder) error {
return nil
}
func (*binaryClasscallGetResource) ID() binary.ID { return binaryIDcallGetResource }
func (*binaryClasscallGetResource) New() binary.Object { return &callGetResource{} }
func (*binaryClasscallGetResource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallGetResource(e, obj.(*callGetResource))
}
func (*binaryClasscallGetResource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callGetResource{}
return obj, doDecodecallGetResource(d, obj)
}
func (*binaryClasscallGetResource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallGetResource(d, obj.(*callGetResource))
}
func (*binaryClasscallGetResource) Skip(d binary.Decoder) error { return doSkipcallGetResource(d) }
func (*binaryClasscallGetResource) Schema() *schema.Class { return schemacallGetResource }
var schemacallGetResource = &schema.Class{
TypeID: binaryIDcallGetResource,
Package: "test",
Name: "callGetResource",
Fields: []schema.Field{},
}
type binaryClasscallGetSingleListNode struct{}
func (*callGetSingleListNode) Class() binary.Class {
return (*binaryClasscallGetSingleListNode)(nil)
}
func doEncodecallGetSingleListNode(e binary.Encoder, o *callGetSingleListNode) error {
return nil
}
func doDecodecallGetSingleListNode(d binary.Decoder, o *callGetSingleListNode) error {
return nil
}
func doSkipcallGetSingleListNode(d binary.Decoder) error {
return nil
}
func (*binaryClasscallGetSingleListNode) ID() binary.ID { return binaryIDcallGetSingleListNode }
func (*binaryClasscallGetSingleListNode) New() binary.Object { return &callGetSingleListNode{} }
func (*binaryClasscallGetSingleListNode) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallGetSingleListNode(e, obj.(*callGetSingleListNode))
}
func (*binaryClasscallGetSingleListNode) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callGetSingleListNode{}
return obj, doDecodecallGetSingleListNode(d, obj)
}
func (*binaryClasscallGetSingleListNode) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallGetSingleListNode(d, obj.(*callGetSingleListNode))
}
func (*binaryClasscallGetSingleListNode) Skip(d binary.Decoder) error {
return doSkipcallGetSingleListNode(d)
}
func (*binaryClasscallGetSingleListNode) Schema() *schema.Class { return schemacallGetSingleListNode }
var schemacallGetSingleListNode = &schema.Class{
TypeID: binaryIDcallGetSingleListNode,
Package: "test",
Name: "callGetSingleListNode",
Fields: []schema.Field{},
}
type binaryClasscallGetStruct struct{}
func (*callGetStruct) Class() binary.Class {
return (*binaryClasscallGetStruct)(nil)
}
func doEncodecallGetStruct(e binary.Encoder, o *callGetStruct) error {
return nil
}
func doDecodecallGetStruct(d binary.Decoder, o *callGetStruct) error {
return nil
}
func doSkipcallGetStruct(d binary.Decoder) error {
return nil
}
func (*binaryClasscallGetStruct) ID() binary.ID { return binaryIDcallGetStruct }
func (*binaryClasscallGetStruct) New() binary.Object { return &callGetStruct{} }
func (*binaryClasscallGetStruct) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallGetStruct(e, obj.(*callGetStruct))
}
func (*binaryClasscallGetStruct) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callGetStruct{}
return obj, doDecodecallGetStruct(d, obj)
}
func (*binaryClasscallGetStruct) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallGetStruct(d, obj.(*callGetStruct))
}
func (*binaryClasscallGetStruct) Skip(d binary.Decoder) error { return doSkipcallGetStruct(d) }
func (*binaryClasscallGetStruct) Schema() *schema.Class { return schemacallGetStruct }
var schemacallGetStruct = &schema.Class{
TypeID: binaryIDcallGetStruct,
Package: "test",
Name: "callGetStruct",
Fields: []schema.Field{},
}
type binaryClasscallResolveResource struct{}
func (*callResolveResource) Class() binary.Class {
return (*binaryClasscallResolveResource)(nil)
}
func doEncodecallResolveResource(e binary.Encoder, o *callResolveResource) error {
if err := e.ID(binary.ID(o.r)); err != nil {
return err
}
return nil
}
func doDecodecallResolveResource(d binary.Decoder, o *callResolveResource) error {
if obj, err := d.ID(); err != nil {
return err
} else {
o.r = ResourceID(obj)
}
return nil
}
func doSkipcallResolveResource(d binary.Decoder) error {
if err := d.SkipID(); err != nil {
return err
}
return nil
}
func (*binaryClasscallResolveResource) ID() binary.ID { return binaryIDcallResolveResource }
func (*binaryClasscallResolveResource) New() binary.Object { return &callResolveResource{} }
func (*binaryClasscallResolveResource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallResolveResource(e, obj.(*callResolveResource))
}
func (*binaryClasscallResolveResource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callResolveResource{}
return obj, doDecodecallResolveResource(d, obj)
}
func (*binaryClasscallResolveResource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallResolveResource(d, obj.(*callResolveResource))
}
func (*binaryClasscallResolveResource) Skip(d binary.Decoder) error {
return doSkipcallResolveResource(d)
}
func (*binaryClasscallResolveResource) Schema() *schema.Class { return schemacallResolveResource }
var schemacallResolveResource = &schema.Class{
TypeID: binaryIDcallResolveResource,
Package: "test",
Name: "callResolveResource",
Fields: []schema.Field{
{Declared: "r", Type: &schema.Primitive{Name: "ResourceID", Method: schema.ID}},
},
}
type binaryClasscallSetStruct struct{}
func (*callSetStruct) Class() binary.Class {
return (*binaryClasscallSetStruct)(nil)
}
func doEncodecallSetStruct(e binary.Encoder, o *callSetStruct) error {
if err := e.Value(&o.s); err != nil {
return err
}
return nil
}
func doDecodecallSetStruct(d binary.Decoder, o *callSetStruct) error {
if err := d.Value(&o.s); err != nil {
return err
}
return nil
}
func doSkipcallSetStruct(d binary.Decoder) error {
if err := d.SkipValue((*Struct)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClasscallSetStruct) ID() binary.ID { return binaryIDcallSetStruct }
func (*binaryClasscallSetStruct) New() binary.Object { return &callSetStruct{} }
func (*binaryClasscallSetStruct) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallSetStruct(e, obj.(*callSetStruct))
}
func (*binaryClasscallSetStruct) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callSetStruct{}
return obj, doDecodecallSetStruct(d, obj)
}
func (*binaryClasscallSetStruct) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallSetStruct(d, obj.(*callSetStruct))
}
func (*binaryClasscallSetStruct) Skip(d binary.Decoder) error { return doSkipcallSetStruct(d) }
func (*binaryClasscallSetStruct) Schema() *schema.Class { return schemacallSetStruct }
var schemacallSetStruct = &schema.Class{
TypeID: binaryIDcallSetStruct,
Package: "test",
Name: "callSetStruct",
Fields: []schema.Field{
{Declared: "s", Type: &schema.Struct{Name: "Struct", ID: (*Struct)(nil).Class().ID()}},
},
}
type binaryClasscallUseResource struct{}
func (*callUseResource) Class() binary.Class {
return (*binaryClasscallUseResource)(nil)
}
func doEncodecallUseResource(e binary.Encoder, o *callUseResource) error {
if err := e.ID(binary.ID(o.r)); err != nil {
return err
}
return nil
}
func doDecodecallUseResource(d binary.Decoder, o *callUseResource) error {
if obj, err := d.ID(); err != nil {
return err
} else {
o.r = ResourceID(obj)
}
return nil
}
func doSkipcallUseResource(d binary.Decoder) error {
if err := d.SkipID(); err != nil {
return err
}
return nil
}
func (*binaryClasscallUseResource) ID() binary.ID { return binaryIDcallUseResource }
func (*binaryClasscallUseResource) New() binary.Object { return &callUseResource{} }
func (*binaryClasscallUseResource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodecallUseResource(e, obj.(*callUseResource))
}
func (*binaryClasscallUseResource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &callUseResource{}
return obj, doDecodecallUseResource(d, obj)
}
func (*binaryClasscallUseResource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodecallUseResource(d, obj.(*callUseResource))
}
func (*binaryClasscallUseResource) Skip(d binary.Decoder) error { return doSkipcallUseResource(d) }
func (*binaryClasscallUseResource) Schema() *schema.Class { return schemacallUseResource }
var schemacallUseResource = &schema.Class{
TypeID: binaryIDcallUseResource,
Package: "test",
Name: "callUseResource",
Fields: []schema.Field{
{Declared: "r", Type: &schema.Primitive{Name: "ResourceID", Method: schema.ID}},
},
}
type binaryClassresultAdd struct{}
func (*resultAdd) Class() binary.Class {
return (*binaryClassresultAdd)(nil)
}
func doEncoderesultAdd(e binary.Encoder, o *resultAdd) error {
if err := e.Uint32(o.value); err != nil {
return err
}
return nil
}
func doDecoderesultAdd(d binary.Decoder, o *resultAdd) error {
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.value = uint32(obj)
}
return nil
}
func doSkipresultAdd(d binary.Decoder) error {
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassresultAdd) ID() binary.ID { return binaryIDresultAdd }
func (*binaryClassresultAdd) New() binary.Object { return &resultAdd{} }
func (*binaryClassresultAdd) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultAdd(e, obj.(*resultAdd))
}
func (*binaryClassresultAdd) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultAdd{}
return obj, doDecoderesultAdd(d, obj)
}
func (*binaryClassresultAdd) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultAdd(d, obj.(*resultAdd))
}
func (*binaryClassresultAdd) Skip(d binary.Decoder) error { return doSkipresultAdd(d) }
func (*binaryClassresultAdd) Schema() *schema.Class { return schemaresultAdd }
var schemaresultAdd = &schema.Class{
TypeID: binaryIDresultAdd,
Package: "test",
Name: "resultAdd",
Fields: []schema.Field{
{Declared: "value", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
},
}
type binaryClassresultEnumToString struct{}
func (*resultEnumToString) Class() binary.Class {
return (*binaryClassresultEnumToString)(nil)
}
func doEncoderesultEnumToString(e binary.Encoder, o *resultEnumToString) error {
if err := e.String(o.value); err != nil {
return err
}
return nil
}
func doDecoderesultEnumToString(d binary.Decoder, o *resultEnumToString) error {
if obj, err := d.String(); err != nil {
return err
} else {
o.value = string(obj)
}
return nil
}
func doSkipresultEnumToString(d binary.Decoder) error {
if err := d.SkipString(); err != nil {
return err
}
return nil
}
func (*binaryClassresultEnumToString) ID() binary.ID { return binaryIDresultEnumToString }
func (*binaryClassresultEnumToString) New() binary.Object { return &resultEnumToString{} }
func (*binaryClassresultEnumToString) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultEnumToString(e, obj.(*resultEnumToString))
}
func (*binaryClassresultEnumToString) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultEnumToString{}
return obj, doDecoderesultEnumToString(d, obj)
}
func (*binaryClassresultEnumToString) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultEnumToString(d, obj.(*resultEnumToString))
}
func (*binaryClassresultEnumToString) Skip(d binary.Decoder) error { return doSkipresultEnumToString(d) }
func (*binaryClassresultEnumToString) Schema() *schema.Class { return schemaresultEnumToString }
var schemaresultEnumToString = &schema.Class{
TypeID: binaryIDresultEnumToString,
Package: "test",
Name: "resultEnumToString",
Fields: []schema.Field{
{Declared: "value", Type: &schema.Primitive{Name: "string", Method: schema.String}},
},
}
type binaryClassresultGetListNodeChain struct{}
func (*resultGetListNodeChain) Class() binary.Class {
return (*binaryClassresultGetListNodeChain)(nil)
}
func doEncoderesultGetListNodeChain(e binary.Encoder, o *resultGetListNodeChain) error {
if o.value != nil {
if err := e.Object(o.value); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
return nil
}
func doDecoderesultGetListNodeChain(d binary.Decoder, o *resultGetListNodeChain) error {
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
o.value = obj.(*ListNode)
} else {
o.value = nil
}
return nil
}
func doSkipresultGetListNodeChain(d binary.Decoder) error {
if _, err := d.SkipObject(); err != nil {
return err
}
return nil
}
func (*binaryClassresultGetListNodeChain) ID() binary.ID { return binaryIDresultGetListNodeChain }
func (*binaryClassresultGetListNodeChain) New() binary.Object { return &resultGetListNodeChain{} }
func (*binaryClassresultGetListNodeChain) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultGetListNodeChain(e, obj.(*resultGetListNodeChain))
}
func (*binaryClassresultGetListNodeChain) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultGetListNodeChain{}
return obj, doDecoderesultGetListNodeChain(d, obj)
}
func (*binaryClassresultGetListNodeChain) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultGetListNodeChain(d, obj.(*resultGetListNodeChain))
}
func (*binaryClassresultGetListNodeChain) Skip(d binary.Decoder) error {
return doSkipresultGetListNodeChain(d)
}
func (*binaryClassresultGetListNodeChain) Schema() *schema.Class { return schemaresultGetListNodeChain }
var schemaresultGetListNodeChain = &schema.Class{
TypeID: binaryIDresultGetListNodeChain,
Package: "test",
Name: "resultGetListNodeChain",
Fields: []schema.Field{
{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Name: "ListNode", ID: (*ListNode)(nil).Class().ID()}}},
},
}
type binaryClassresultGetListNodeChainArray struct{}
func (*resultGetListNodeChainArray) Class() binary.Class {
return (*binaryClassresultGetListNodeChainArray)(nil)
}
func doEncoderesultGetListNodeChainArray(e binary.Encoder, o *resultGetListNodeChainArray) error {
if err := e.Uint32(uint32(len(o.value))); err != nil {
return err
}
for i := range o.value {
if o.value[i] != nil {
if err := e.Object(o.value[i]); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
return nil
}
func doDecoderesultGetListNodeChainArray(d binary.Decoder, o *resultGetListNodeChainArray) error {
if count, err := d.Uint32(); err != nil {
return err
} else {
o.value = make([]*ListNode, count)
for i := range o.value {
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
o.value[i] = obj.(*ListNode)
} else {
o.value[i] = nil
}
}
}
return nil
}
func doSkipresultGetListNodeChainArray(d binary.Decoder) error {
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
return nil
}
func (*binaryClassresultGetListNodeChainArray) ID() binary.ID {
return binaryIDresultGetListNodeChainArray
}
func (*binaryClassresultGetListNodeChainArray) New() binary.Object {
return &resultGetListNodeChainArray{}
}
func (*binaryClassresultGetListNodeChainArray) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultGetListNodeChainArray(e, obj.(*resultGetListNodeChainArray))
}
func (*binaryClassresultGetListNodeChainArray) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultGetListNodeChainArray{}
return obj, doDecoderesultGetListNodeChainArray(d, obj)
}
func (*binaryClassresultGetListNodeChainArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultGetListNodeChainArray(d, obj.(*resultGetListNodeChainArray))
}
func (*binaryClassresultGetListNodeChainArray) Skip(d binary.Decoder) error {
return doSkipresultGetListNodeChainArray(d)
}
func (*binaryClassresultGetListNodeChainArray) Schema() *schema.Class {
return schemaresultGetListNodeChainArray
}
var schemaresultGetListNodeChainArray = &schema.Class{
TypeID: binaryIDresultGetListNodeChainArray,
Package: "test",
Name: "resultGetListNodeChainArray",
Fields: []schema.Field{
{Declared: "value", Type: &schema.Slice{Alias: "", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "ListNode", ID: (*ListNode)(nil).Class().ID()}}}},
},
}
type binaryClassresultGetResource struct{}
func (*resultGetResource) Class() binary.Class {
return (*binaryClassresultGetResource)(nil)
}
func doEncoderesultGetResource(e binary.Encoder, o *resultGetResource) error {
if err := e.ID(binary.ID(o.value)); err != nil {
return err
}
return nil
}
func doDecoderesultGetResource(d binary.Decoder, o *resultGetResource) error {
if obj, err := d.ID(); err != nil {
return err
} else {
o.value = ResourceID(obj)
}
return nil
}
func doSkipresultGetResource(d binary.Decoder) error {
if err := d.SkipID(); err != nil {
return err
}
return nil
}
func (*binaryClassresultGetResource) ID() binary.ID { return binaryIDresultGetResource }
func (*binaryClassresultGetResource) New() binary.Object { return &resultGetResource{} }
func (*binaryClassresultGetResource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultGetResource(e, obj.(*resultGetResource))
}
func (*binaryClassresultGetResource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultGetResource{}
return obj, doDecoderesultGetResource(d, obj)
}
func (*binaryClassresultGetResource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultGetResource(d, obj.(*resultGetResource))
}
func (*binaryClassresultGetResource) Skip(d binary.Decoder) error { return doSkipresultGetResource(d) }
func (*binaryClassresultGetResource) Schema() *schema.Class { return schemaresultGetResource }
var schemaresultGetResource = &schema.Class{
TypeID: binaryIDresultGetResource,
Package: "test",
Name: "resultGetResource",
Fields: []schema.Field{
{Declared: "value", Type: &schema.Primitive{Name: "ResourceID", Method: schema.ID}},
},
}
type binaryClassresultGetSingleListNode struct{}
func (*resultGetSingleListNode) Class() binary.Class {
return (*binaryClassresultGetSingleListNode)(nil)
}
func doEncoderesultGetSingleListNode(e binary.Encoder, o *resultGetSingleListNode) error {
if o.value != nil {
if err := e.Object(o.value); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
return nil
}
func doDecoderesultGetSingleListNode(d binary.Decoder, o *resultGetSingleListNode) error {
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
o.value = obj.(*ListNode)
} else {
o.value = nil
}
return nil
}
func doSkipresultGetSingleListNode(d binary.Decoder) error {
if _, err := d.SkipObject(); err != nil {
return err
}
return nil
}
func (*binaryClassresultGetSingleListNode) ID() binary.ID { return binaryIDresultGetSingleListNode }
func (*binaryClassresultGetSingleListNode) New() binary.Object { return &resultGetSingleListNode{} }
func (*binaryClassresultGetSingleListNode) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultGetSingleListNode(e, obj.(*resultGetSingleListNode))
}
func (*binaryClassresultGetSingleListNode) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultGetSingleListNode{}
return obj, doDecoderesultGetSingleListNode(d, obj)
}
func (*binaryClassresultGetSingleListNode) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultGetSingleListNode(d, obj.(*resultGetSingleListNode))
}
func (*binaryClassresultGetSingleListNode) Skip(d binary.Decoder) error {
return doSkipresultGetSingleListNode(d)
}
func (*binaryClassresultGetSingleListNode) Schema() *schema.Class {
return schemaresultGetSingleListNode
}
var schemaresultGetSingleListNode = &schema.Class{
TypeID: binaryIDresultGetSingleListNode,
Package: "test",
Name: "resultGetSingleListNode",
Fields: []schema.Field{
{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Name: "ListNode", ID: (*ListNode)(nil).Class().ID()}}},
},
}
type binaryClassresultGetStruct struct{}
func (*resultGetStruct) Class() binary.Class {
return (*binaryClassresultGetStruct)(nil)
}
func doEncoderesultGetStruct(e binary.Encoder, o *resultGetStruct) error {
if err := e.Value(&o.value); err != nil {
return err
}
return nil
}
func doDecoderesultGetStruct(d binary.Decoder, o *resultGetStruct) error {
if err := d.Value(&o.value); err != nil {
return err
}
return nil
}
func doSkipresultGetStruct(d binary.Decoder) error {
if err := d.SkipValue((*Struct)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassresultGetStruct) ID() binary.ID { return binaryIDresultGetStruct }
func (*binaryClassresultGetStruct) New() binary.Object { return &resultGetStruct{} }
func (*binaryClassresultGetStruct) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultGetStruct(e, obj.(*resultGetStruct))
}
func (*binaryClassresultGetStruct) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultGetStruct{}
return obj, doDecoderesultGetStruct(d, obj)
}
func (*binaryClassresultGetStruct) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultGetStruct(d, obj.(*resultGetStruct))
}
func (*binaryClassresultGetStruct) Skip(d binary.Decoder) error { return doSkipresultGetStruct(d) }
func (*binaryClassresultGetStruct) Schema() *schema.Class { return schemaresultGetStruct }
var schemaresultGetStruct = &schema.Class{
TypeID: binaryIDresultGetStruct,
Package: "test",
Name: "resultGetStruct",
Fields: []schema.Field{
{Declared: "value", Type: &schema.Struct{Name: "Struct", ID: (*Struct)(nil).Class().ID()}},
},
}
type binaryClassresultResolveResource struct{}
func (*resultResolveResource) Class() binary.Class {
return (*binaryClassresultResolveResource)(nil)
}
func doEncoderesultResolveResource(e binary.Encoder, o *resultResolveResource) error {
if err := e.Value(&o.value); err != nil {
return err
}
return nil
}
func doDecoderesultResolveResource(d binary.Decoder, o *resultResolveResource) error {
if err := d.Value(&o.value); err != nil {
return err
}
return nil
}
func doSkipresultResolveResource(d binary.Decoder) error {
if err := d.SkipValue((*Resource)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassresultResolveResource) ID() binary.ID { return binaryIDresultResolveResource }
func (*binaryClassresultResolveResource) New() binary.Object { return &resultResolveResource{} }
func (*binaryClassresultResolveResource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultResolveResource(e, obj.(*resultResolveResource))
}
func (*binaryClassresultResolveResource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultResolveResource{}
return obj, doDecoderesultResolveResource(d, obj)
}
func (*binaryClassresultResolveResource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultResolveResource(d, obj.(*resultResolveResource))
}
func (*binaryClassresultResolveResource) Skip(d binary.Decoder) error {
return doSkipresultResolveResource(d)
}
func (*binaryClassresultResolveResource) Schema() *schema.Class { return schemaresultResolveResource }
var schemaresultResolveResource = &schema.Class{
TypeID: binaryIDresultResolveResource,
Package: "test",
Name: "resultResolveResource",
Fields: []schema.Field{
{Declared: "value", Type: &schema.Struct{Name: "Resource", ID: (*Resource)(nil).Class().ID()}},
},
}
type binaryClassresultSetStruct struct{}
func (*resultSetStruct) Class() binary.Class {
return (*binaryClassresultSetStruct)(nil)
}
func doEncoderesultSetStruct(e binary.Encoder, o *resultSetStruct) error {
return nil
}
func doDecoderesultSetStruct(d binary.Decoder, o *resultSetStruct) error {
return nil
}
func doSkipresultSetStruct(d binary.Decoder) error {
return nil
}
func (*binaryClassresultSetStruct) ID() binary.ID { return binaryIDresultSetStruct }
func (*binaryClassresultSetStruct) New() binary.Object { return &resultSetStruct{} }
func (*binaryClassresultSetStruct) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultSetStruct(e, obj.(*resultSetStruct))
}
func (*binaryClassresultSetStruct) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultSetStruct{}
return obj, doDecoderesultSetStruct(d, obj)
}
func (*binaryClassresultSetStruct) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultSetStruct(d, obj.(*resultSetStruct))
}
func (*binaryClassresultSetStruct) Skip(d binary.Decoder) error { return doSkipresultSetStruct(d) }
func (*binaryClassresultSetStruct) Schema() *schema.Class { return schemaresultSetStruct }
var schemaresultSetStruct = &schema.Class{
TypeID: binaryIDresultSetStruct,
Package: "test",
Name: "resultSetStruct",
Fields: []schema.Field{},
}
type binaryClassresultUseResource struct{}
func (*resultUseResource) Class() binary.Class {
return (*binaryClassresultUseResource)(nil)
}
func doEncoderesultUseResource(e binary.Encoder, o *resultUseResource) error {
return nil
}
func doDecoderesultUseResource(d binary.Decoder, o *resultUseResource) error {
return nil
}
func doSkipresultUseResource(d binary.Decoder) error {
return nil
}
func (*binaryClassresultUseResource) ID() binary.ID { return binaryIDresultUseResource }
func (*binaryClassresultUseResource) New() binary.Object { return &resultUseResource{} }
func (*binaryClassresultUseResource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncoderesultUseResource(e, obj.(*resultUseResource))
}
func (*binaryClassresultUseResource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &resultUseResource{}
return obj, doDecoderesultUseResource(d, obj)
}
func (*binaryClassresultUseResource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecoderesultUseResource(d, obj.(*resultUseResource))
}
func (*binaryClassresultUseResource) Skip(d binary.Decoder) error { return doSkipresultUseResource(d) }
func (*binaryClassresultUseResource) Schema() *schema.Class { return schemaresultUseResource }
var schemaresultUseResource = &schema.Class{
TypeID: binaryIDresultUseResource,
Package: "test",
Name: "resultUseResource",
Fields: []schema.Field{},
}
var ConstantValues schema.Constants
const _Enum_name = "OneTwoThree"
var _Enum_map = map[Enum]string{}
func init() {
_Enum_map[1] = _Enum_name[0:3]
_Enum_map[2] = _Enum_name[3:6]
_Enum_map[3] = _Enum_name[6:11]
ConstantValues = append(ConstantValues, schema.ConstantSet{
Type: &schema.Primitive{Name: "Enum", Method: schema.Int32},
Entries: []schema.Constant{
{Name: _Enum_name[0:3], Value: int32(1)},
{Name: _Enum_name[3:6], Value: int32(2)},
{Name: _Enum_name[6:11], Value: int32(3)},
},
})
}
func (v Enum) String() string {
if s, ok := _Enum_map[v]; ok {
return s
}
return fmt.Sprintf("Enum(%d)", v)
}
func (v *Enum) Parse(s string) error {
for k, t := range _Enum_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in Enum", s)
}