rpc/test/test_binary.go

////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen -go
////////////////////////////////////////////////////////////////////////////////

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"
)

func init() {
	registry.Add((*Derived)(nil).Class())
	registry.Add((*ListNode)(nil).Class())
	registry.Add((*Resource)(nil).Class())
	registry.Add((*ResourceId)(nil).Class())
	registry.Add((*Struct)(nil).Class())
	registry.Add((*callAdd)(nil).Class())
	registry.Add((*callEnumToString)(nil).Class())
	registry.Add((*callGetBase)(nil).Class())
	registry.Add((*callGetDerived)(nil).Class())
	registry.Add((*callGetListNodeChain)(nil).Class())
	registry.Add((*callGetListNodeChainArray)(nil).Class())
	registry.Add((*callGetResource)(nil).Class())
	registry.Add((*callGetSingleListNode)(nil).Class())
	registry.Add((*callGetStruct)(nil).Class())
	registry.Add((*callResolveResource)(nil).Class())
	registry.Add((*callSetStruct)(nil).Class())
	registry.Add((*callUseResource)(nil).Class())
	registry.Add((*resultAdd)(nil).Class())
	registry.Add((*resultEnumToString)(nil).Class())
	registry.Add((*resultGetBase)(nil).Class())
	registry.Add((*resultGetDerived)(nil).Class())
	registry.Add((*resultGetListNodeChain)(nil).Class())
	registry.Add((*resultGetListNodeChainArray)(nil).Class())
	registry.Add((*resultGetResource)(nil).Class())
	registry.Add((*resultGetSingleListNode)(nil).Class())
	registry.Add((*resultGetStruct)(nil).Class())
	registry.Add((*resultResolveResource)(nil).Class())
	registry.Add((*resultSetStruct)(nil).Class())
	registry.Add((*resultUseResource)(nil).Class())
}

var (
	binaryIDDerived                     = binary.ID{0x0d, 0x9c, 0x9a, 0x15, 0x97, 0x4d, 0xf4, 0xcf, 0x34, 0x4a, 0x26, 0x1b, 0xde, 0x0b, 0x5e, 0x1e, 0x08, 0x36, 0x95, 0x0a}
	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}
	binaryIDResourceId                  = binary.ID{0x90, 0xae, 0xdc, 0x2b, 0xca, 0x22, 0x65, 0x8f, 0xca, 0xff, 0x86, 0x19, 0xc6, 0x73, 0x1b, 0x71, 0x6e, 0x54, 0x99, 0xc2}
	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}
	binaryIDcallGetBase                 = binary.ID{0x28, 0xb4, 0x5a, 0x5f, 0xcd, 0xa2, 0xd9, 0x93, 0x1e, 0x4b, 0x49, 0x3a, 0x9b, 0x6a, 0xec, 0x7a, 0xb7, 0xb5, 0xc7, 0xf6}
	binaryIDcallGetDerived              = binary.ID{0x72, 0x71, 0x8e, 0x2b, 0x3f, 0xa3, 0xe7, 0x7d, 0x76, 0xe3, 0x33, 0x9b, 0x63, 0xa4, 0xfc, 0x2f, 0x5b, 0xc4, 0x6b, 0x0e}
	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{0xdc, 0x4e, 0xa1, 0x9f, 0xfb, 0x65, 0x5f, 0xed, 0x37, 0x13, 0x5f, 0x21, 0xe4, 0x57, 0x5d, 0xe5, 0xef, 0xbf, 0x87, 0xc2}
	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{0x96, 0x12, 0x10, 0xa9, 0x67, 0xea, 0xf9, 0x3b, 0x5f, 0x44, 0xa0, 0xfe, 0xbe, 0xf9, 0x0a, 0xb6, 0xc9, 0x6c, 0x27, 0x21}
	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}
	binaryIDresultGetBase               = binary.ID{0xae, 0x6d, 0xce, 0x4d, 0xba, 0x99, 0xa9, 0xa0, 0xd6, 0x69, 0xde, 0xec, 0x6d, 0xcc, 0x10, 0xbe, 0xe0, 0x0a, 0x0d, 0x53}
	binaryIDresultGetDerived            = binary.ID{0x33, 0x7b, 0x5c, 0xf9, 0x0e, 0x8f, 0xfd, 0x58, 0x64, 0x31, 0x0d, 0xc0, 0x32, 0x51, 0xa6, 0x82, 0xee, 0xd3, 0xfc, 0x16}
	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{0xe2, 0x0a, 0xbc, 0xe8, 0x0a, 0x49, 0xe3, 0xe9, 0x6a, 0x9e, 0x01, 0x33, 0x85, 0x20, 0x80, 0xef, 0x2a, 0xc7, 0x9b, 0x51}
	binaryIDresultGetResource           = binary.ID{0xc1, 0x36, 0x88, 0xd8, 0x61, 0xde, 0xe9, 0xe6, 0x82, 0x5b, 0xb1, 0xfb, 0x67, 0xd1, 0x11, 0x30, 0xb9, 0xcf, 0x72, 0x23}
	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 binaryClassDerived struct{}

func (*Derived) Class() binary.Class {
	return (*binaryClassDerived)(nil)
}
func doEncodeDerived(e binary.Encoder, o *Derived) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Enum)); err != nil {
		return err
	}
	return nil
}
func doDecodeDerived(d binary.Decoder, o *Derived) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Enum = Enum(obj)
	}
	return nil
}
func doSkipDerived(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassDerived) ID() binary.ID      { return binaryIDDerived }
func (*binaryClassDerived) New() binary.Object { return &Derived{} }
func (*binaryClassDerived) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeDerived(e, obj.(*Derived))
}
func (*binaryClassDerived) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Derived{}
	return obj, doDecodeDerived(d, obj)
}
func (*binaryClassDerived) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeDerived(d, obj.(*Derived))
}
func (*binaryClassDerived) Skip(d binary.Decoder) error { return doSkipDerived(d) }
func (*binaryClassDerived) Schema() *schema.Class       { return schemaDerived }

var schemaDerived = &schema.Class{
	TypeID: binaryIDDerived,
	Name:   "Derived",
	Fields: []schema.Field{
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Enum", Type: &schema.Primitive{Name: "Enum", Method: schema.Int32}},
	},
}

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,
	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"}}},
	},
}

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,
	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 binaryClassResourceId struct{}

func (*ResourceId) Class() binary.Class {
	return (*binaryClassResourceId)(nil)
}
func doEncodeResourceId(e binary.Encoder, o *ResourceId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeResourceId(d binary.Decoder, o *ResourceId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipResourceId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassResourceId) ID() binary.ID      { return binaryIDResourceId }
func (*binaryClassResourceId) New() binary.Object { return &ResourceId{} }
func (*binaryClassResourceId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeResourceId(e, obj.(*ResourceId))
}
func (*binaryClassResourceId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ResourceId{}
	return obj, doDecodeResourceId(d, obj)
}
func (*binaryClassResourceId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeResourceId(d, obj.(*ResourceId))
}
func (*binaryClassResourceId) Skip(d binary.Decoder) error { return doSkipResourceId(d) }
func (*binaryClassResourceId) Schema() *schema.Class       { return schemaResourceId }

var schemaResourceId = &schema.Class{
	TypeID: binaryIDResourceId,
	Name:   "ResourceId",
	Fields: []schema.Field{
		{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

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,
	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,
	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,
	Name:   "callEnumToString",
	Fields: []schema.Field{
		{Declared: "e", Type: &schema.Primitive{Name: "Enum", Method: schema.Int32}},
	},
}

type binaryClasscallGetBase struct{}

func (*callGetBase) Class() binary.Class {
	return (*binaryClasscallGetBase)(nil)
}
func doEncodecallGetBase(e binary.Encoder, o *callGetBase) error {
	return nil
}
func doDecodecallGetBase(d binary.Decoder, o *callGetBase) error {
	return nil
}
func doSkipcallGetBase(d binary.Decoder) error {
	return nil
}
func (*binaryClasscallGetBase) ID() binary.ID      { return binaryIDcallGetBase }
func (*binaryClasscallGetBase) New() binary.Object { return &callGetBase{} }
func (*binaryClasscallGetBase) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetBase(e, obj.(*callGetBase))
}
func (*binaryClasscallGetBase) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetBase{}
	return obj, doDecodecallGetBase(d, obj)
}
func (*binaryClasscallGetBase) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetBase(d, obj.(*callGetBase))
}
func (*binaryClasscallGetBase) Skip(d binary.Decoder) error { return doSkipcallGetBase(d) }
func (*binaryClasscallGetBase) Schema() *schema.Class       { return schemacallGetBase }

var schemacallGetBase = &schema.Class{
	TypeID: binaryIDcallGetBase,
	Name:   "callGetBase",
	Fields: []schema.Field{},
}

type binaryClasscallGetDerived struct{}

func (*callGetDerived) Class() binary.Class {
	return (*binaryClasscallGetDerived)(nil)
}
func doEncodecallGetDerived(e binary.Encoder, o *callGetDerived) error {
	return nil
}
func doDecodecallGetDerived(d binary.Decoder, o *callGetDerived) error {
	return nil
}
func doSkipcallGetDerived(d binary.Decoder) error {
	return nil
}
func (*binaryClasscallGetDerived) ID() binary.ID      { return binaryIDcallGetDerived }
func (*binaryClasscallGetDerived) New() binary.Object { return &callGetDerived{} }
func (*binaryClasscallGetDerived) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetDerived(e, obj.(*callGetDerived))
}
func (*binaryClasscallGetDerived) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetDerived{}
	return obj, doDecodecallGetDerived(d, obj)
}
func (*binaryClasscallGetDerived) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetDerived(d, obj.(*callGetDerived))
}
func (*binaryClasscallGetDerived) Skip(d binary.Decoder) error { return doSkipcallGetDerived(d) }
func (*binaryClasscallGetDerived) Schema() *schema.Class       { return schemacallGetDerived }

var schemacallGetDerived = &schema.Class{
	TypeID: binaryIDcallGetDerived,
	Name:   "callGetDerived",
	Fields: []schema.Field{},
}

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,
	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,
	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,
	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,
	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,
	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.Value(&o.r); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveResource(d binary.Decoder, o *callResolveResource) error {
	if err := d.Value(&o.r); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveResource(d binary.Decoder) error {
	if err := d.SkipValue((*ResourceId)(nil)); 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,
	Name:   "callResolveResource",
	Fields: []schema.Field{
		{Declared: "r", Type: &schema.Struct{Name: "ResourceId"}},
	},
}

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,
	Name:   "callSetStruct",
	Fields: []schema.Field{
		{Declared: "s", Type: &schema.Struct{Name: "Struct"}},
	},
}

type binaryClasscallUseResource struct{}

func (*callUseResource) Class() binary.Class {
	return (*binaryClasscallUseResource)(nil)
}
func doEncodecallUseResource(e binary.Encoder, o *callUseResource) error {
	if err := e.Value(&o.r); err != nil {
		return err
	}
	return nil
}
func doDecodecallUseResource(d binary.Decoder, o *callUseResource) error {
	if err := d.Value(&o.r); err != nil {
		return err
	}
	return nil
}
func doSkipcallUseResource(d binary.Decoder) error {
	if err := d.SkipValue((*ResourceId)(nil)); 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,
	Name:   "callUseResource",
	Fields: []schema.Field{
		{Declared: "r", Type: &schema.Struct{Name: "ResourceId"}},
	},
}

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,
	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,
	Name:   "resultEnumToString",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassresultGetBase struct{}

func (*resultGetBase) Class() binary.Class {
	return (*binaryClassresultGetBase)(nil)
}
func doEncoderesultGetBase(e binary.Encoder, o *resultGetBase) 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 doDecoderesultGetBase(d binary.Decoder, o *resultGetBase) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.value = obj.(Base)
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultGetBase(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetBase) ID() binary.ID      { return binaryIDresultGetBase }
func (*binaryClassresultGetBase) New() binary.Object { return &resultGetBase{} }
func (*binaryClassresultGetBase) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetBase(e, obj.(*resultGetBase))
}
func (*binaryClassresultGetBase) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetBase{}
	return obj, doDecoderesultGetBase(d, obj)
}
func (*binaryClassresultGetBase) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetBase(d, obj.(*resultGetBase))
}
func (*binaryClassresultGetBase) Skip(d binary.Decoder) error { return doSkipresultGetBase(d) }
func (*binaryClassresultGetBase) Schema() *schema.Class       { return schemaresultGetBase }

var schemaresultGetBase = &schema.Class{
	TypeID: binaryIDresultGetBase,
	Name:   "resultGetBase",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Interface{Name: "Base"}},
	},
}

type binaryClassresultGetDerived struct{}

func (*resultGetDerived) Class() binary.Class {
	return (*binaryClassresultGetDerived)(nil)
}
func doEncoderesultGetDerived(e binary.Encoder, o *resultGetDerived) 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 doDecoderesultGetDerived(d binary.Decoder, o *resultGetDerived) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.value = obj.(Base)
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultGetDerived(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetDerived) ID() binary.ID      { return binaryIDresultGetDerived }
func (*binaryClassresultGetDerived) New() binary.Object { return &resultGetDerived{} }
func (*binaryClassresultGetDerived) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetDerived(e, obj.(*resultGetDerived))
}
func (*binaryClassresultGetDerived) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetDerived{}
	return obj, doDecoderesultGetDerived(d, obj)
}
func (*binaryClassresultGetDerived) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetDerived(d, obj.(*resultGetDerived))
}
func (*binaryClassresultGetDerived) Skip(d binary.Decoder) error { return doSkipresultGetDerived(d) }
func (*binaryClassresultGetDerived) Schema() *schema.Class       { return schemaresultGetDerived }

var schemaresultGetDerived = &schema.Class{
	TypeID: binaryIDresultGetDerived,
	Name:   "resultGetDerived",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Interface{Name: "Base"}},
	},
}

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,
	Name:   "resultGetListNodeChain",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Name: "ListNode"}}},
	},
}

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(ListNodePtrArray, 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,
	Name:   "resultGetListNodeChainArray",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Slice{Alias: "ListNodePtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "ListNode"}}}},
	},
}

type binaryClassresultGetResource struct{}

func (*resultGetResource) Class() binary.Class {
	return (*binaryClassresultGetResource)(nil)
}
func doEncoderesultGetResource(e binary.Encoder, o *resultGetResource) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetResource(d binary.Decoder, o *resultGetResource) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultGetResource(d binary.Decoder) error {
	if err := d.SkipValue((*ResourceId)(nil)); 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,
	Name:   "resultGetResource",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Struct{Name: "ResourceId"}},
	},
}

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,
	Name:   "resultGetSingleListNode",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Name: "ListNode"}}},
	},
}

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,
	Name:   "resultGetStruct",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Struct{Name: "Struct"}},
	},
}

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,
	Name:   "resultResolveResource",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Struct{Name: "Resource"}},
	},
}

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,
	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,
	Name:   "resultUseResource",
	Fields: []schema.Field{},
}

const _Enum_name = "OneTwoThree"

var _Enum_map = map[Enum]string{
	1: _Enum_name[0:3],
	2: _Enum_name[3:6],
	3: _Enum_name[6:11],
}

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)
}