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