framework/rpc/test/test_binary.go

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

package test

import (
	"android.googlesource.com/platform/tools/gpu/framework/binary"
	"android.googlesource.com/platform/tools/gpu/framework/binary/registry"
	"android.googlesource.com/platform/tools/gpu/framework/id"
)

// Make sure schema init() runs first
import _ "android.googlesource.com/platform/tools/gpu/framework/binary/schema"

// force use the id package, because our imports handling is wrong
var _ id.ID

const (
	ixǁListNode = iota
	ixǁResource
	ixǁStruct
	ixǁcallAdd
	ixǁcallEnumToString
	ixǁcallGetListNodeChain
	ixǁcallGetListNodeChainArray
	ixǁcallGetResource
	ixǁcallGetSingleListNode
	ixǁcallGetStruct
	ixǁcallResolveResource
	ixǁcallSetStruct
	ixǁcallUseResource
	ixǁresultAdd
	ixǁresultEnumToString
	ixǁresultGetListNodeChain
	ixǁresultGetListNodeChainArray
	ixǁresultGetResource
	ixǁresultGetSingleListNode
	ixǁresultGetStruct
	ixǁresultResolveResource
	ixǁresultSetStruct
	ixǁresultUseResource
)

var entities [23]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*ListNode)(nil))
	Namespace.AddClassOf((*Resource)(nil))
	Namespace.AddClassOf((*Struct)(nil))
	Namespace.AddClassOf((*callAdd)(nil))
	Namespace.AddClassOf((*callEnumToString)(nil))
	Namespace.AddClassOf((*callGetListNodeChain)(nil))
	Namespace.AddClassOf((*callGetListNodeChainArray)(nil))
	Namespace.AddClassOf((*callGetResource)(nil))
	Namespace.AddClassOf((*callGetSingleListNode)(nil))
	Namespace.AddClassOf((*callGetStruct)(nil))
	Namespace.AddClassOf((*callResolveResource)(nil))
	Namespace.AddClassOf((*callSetStruct)(nil))
	Namespace.AddClassOf((*callUseResource)(nil))
	Namespace.AddClassOf((*resultAdd)(nil))
	Namespace.AddClassOf((*resultEnumToString)(nil))
	Namespace.AddClassOf((*resultGetListNodeChain)(nil))
	Namespace.AddClassOf((*resultGetListNodeChainArray)(nil))
	Namespace.AddClassOf((*resultGetResource)(nil))
	Namespace.AddClassOf((*resultGetSingleListNode)(nil))
	Namespace.AddClassOf((*resultGetStruct)(nil))
	Namespace.AddClassOf((*resultResolveResource)(nil))
	Namespace.AddClassOf((*resultSetStruct)(nil))
	Namespace.AddClassOf((*resultUseResource)(nil))
}

type binaryClassListNode struct{}

func (*ListNode) Class() binary.Class {
	return (*binaryClassListNode)(nil)
}
func doEncodeListNode(e binary.Encoder, o *ListNode) {
	e.String(o.Name)
	if o.Next != nil {
		e.Object(o.Next)
	} else {
		e.Object(nil)
	}
}
func doDecodeListNode(d binary.Decoder, o *ListNode) {
	o.Name = string(d.String())
	if obj := d.Object(); obj != nil {
		o.Next = obj.(*ListNode)
	} else {
		o.Next = nil
	}
}
func doDecodeRawListNode(d binary.Decoder, o *ListNode) {
	o.Name = string(d.String())
	if obj := d.Object(); obj != nil {
		o.Next = obj.(*ListNode)
	} else {
		o.Next = nil
	}
}
func (*binaryClassListNode) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeListNode(e, obj.(*ListNode))
}
func (*binaryClassListNode) New() binary.Object {
	return &ListNode{}
}
func (*binaryClassListNode) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeListNode(d, obj.(*ListNode))
}
func (c *binaryClassListNode) Schema() *binary.Entity {
	return &entities[ixǁListNode]
}

type binaryClassResource struct{}

func (*Resource) Class() binary.Class {
	return (*binaryClassResource)(nil)
}
func doEncodeResource(e binary.Writer, o *Resource) {
	e.Uint32(o.Int)
	e.Float32(o.Float)
	e.String(o.String)
}
func doDecodeResource(d binary.Reader, o *Resource) {
	o.Int = uint32(d.Uint32())
	o.Float = float32(d.Float32())
	o.String = string(d.String())
}
func doDecodeRawResource(d binary.Reader, o *Resource) {
	o.Int = uint32(d.Uint32())
	o.Float = float32(d.Float32())
	o.String = string(d.String())
}
func (*binaryClassResource) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResource(e, obj.(*Resource))
}
func (*binaryClassResource) New() binary.Object {
	return &Resource{}
}
func (*binaryClassResource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResource(d, obj.(*Resource))
}
func (o *Resource) WriteSimple(w binary.Writer) {
	doEncodeResource(w, o)
}
func (o *Resource) ReadSimple(r binary.Reader) {
	doDecodeResource(r, o)
}
func (c *binaryClassResource) Schema() *binary.Entity {
	return &entities[ixǁResource]
}

type binaryClassStruct struct{}

func (*Struct) Class() binary.Class {
	return (*binaryClassStruct)(nil)
}
func doEncodeStruct(e binary.Writer, o *Struct) {
	e.String(o.String)
	e.Uint32(o.U32)
	e.Int32(int32(o.Enum))
}
func doDecodeStruct(d binary.Reader, o *Struct) {
	o.String = string(d.String())
	o.U32 = uint32(d.Uint32())
	o.Enum = Enum(d.Int32())
}
func doDecodeRawStruct(d binary.Reader, o *Struct) {
	o.String = string(d.String())
	o.U32 = uint32(d.Uint32())
	o.Enum = Enum(d.Int32())
}
func (*binaryClassStruct) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeStruct(e, obj.(*Struct))
}
func (*binaryClassStruct) New() binary.Object {
	return &Struct{}
}
func (*binaryClassStruct) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeStruct(d, obj.(*Struct))
}
func (o *Struct) WriteSimple(w binary.Writer) {
	doEncodeStruct(w, o)
}
func (o *Struct) ReadSimple(r binary.Reader) {
	doDecodeStruct(r, o)
}
func (c *binaryClassStruct) Schema() *binary.Entity {
	return &entities[ixǁStruct]
}

type binaryClasscallAdd struct{}

func (*callAdd) Class() binary.Class {
	return (*binaryClasscallAdd)(nil)
}
func doEncodecallAdd(e binary.Writer, o *callAdd) {
	e.Uint32(o.a)
	e.Uint32(o.b)
}
func doDecodecallAdd(d binary.Reader, o *callAdd) {
	o.a = uint32(d.Uint32())
	o.b = uint32(d.Uint32())
}
func doDecodeRawcallAdd(d binary.Reader, o *callAdd) {
	o.a = uint32(d.Uint32())
	o.b = uint32(d.Uint32())
}
func (*binaryClasscallAdd) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallAdd(e, obj.(*callAdd))
}
func (*binaryClasscallAdd) New() binary.Object {
	return &callAdd{}
}
func (*binaryClasscallAdd) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallAdd(d, obj.(*callAdd))
}
func (o *callAdd) WriteSimple(w binary.Writer) {
	doEncodecallAdd(w, o)
}
func (o *callAdd) ReadSimple(r binary.Reader) {
	doDecodecallAdd(r, o)
}
func (c *binaryClasscallAdd) Schema() *binary.Entity {
	return &entities[ixǁcallAdd]
}

type binaryClasscallEnumToString struct{}

func (*callEnumToString) Class() binary.Class {
	return (*binaryClasscallEnumToString)(nil)
}
func doEncodecallEnumToString(e binary.Writer, o *callEnumToString) {
	e.Int32(int32(o.e))
}
func doDecodecallEnumToString(d binary.Reader, o *callEnumToString) {
	o.e = Enum(d.Int32())
}
func doDecodeRawcallEnumToString(d binary.Reader, o *callEnumToString) {
	o.e = Enum(d.Int32())
}
func (*binaryClasscallEnumToString) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallEnumToString(e, obj.(*callEnumToString))
}
func (*binaryClasscallEnumToString) New() binary.Object {
	return &callEnumToString{}
}
func (*binaryClasscallEnumToString) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallEnumToString(d, obj.(*callEnumToString))
}
func (o *callEnumToString) WriteSimple(w binary.Writer) {
	doEncodecallEnumToString(w, o)
}
func (o *callEnumToString) ReadSimple(r binary.Reader) {
	doDecodecallEnumToString(r, o)
}
func (c *binaryClasscallEnumToString) Schema() *binary.Entity {
	return &entities[ixǁcallEnumToString]
}

type binaryClasscallGetListNodeChain struct{}

func (*callGetListNodeChain) Class() binary.Class {
	return (*binaryClasscallGetListNodeChain)(nil)
}
func doEncodecallGetListNodeChain(e binary.Writer, o *callGetListNodeChain) {
}
func doDecodecallGetListNodeChain(d binary.Reader, o *callGetListNodeChain) {
}
func doDecodeRawcallGetListNodeChain(d binary.Reader, o *callGetListNodeChain) {
}
func (*binaryClasscallGetListNodeChain) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetListNodeChain(e, obj.(*callGetListNodeChain))
}
func (*binaryClasscallGetListNodeChain) New() binary.Object {
	return &callGetListNodeChain{}
}
func (*binaryClasscallGetListNodeChain) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetListNodeChain(d, obj.(*callGetListNodeChain))
}
func (o *callGetListNodeChain) WriteSimple(w binary.Writer) {
	doEncodecallGetListNodeChain(w, o)
}
func (o *callGetListNodeChain) ReadSimple(r binary.Reader) {
	doDecodecallGetListNodeChain(r, o)
}
func (c *binaryClasscallGetListNodeChain) Schema() *binary.Entity {
	return &entities[ixǁcallGetListNodeChain]
}

type binaryClasscallGetListNodeChainArray struct{}

func (*callGetListNodeChainArray) Class() binary.Class {
	return (*binaryClasscallGetListNodeChainArray)(nil)
}
func doEncodecallGetListNodeChainArray(e binary.Writer, o *callGetListNodeChainArray) {
}
func doDecodecallGetListNodeChainArray(d binary.Reader, o *callGetListNodeChainArray) {
}
func doDecodeRawcallGetListNodeChainArray(d binary.Reader, o *callGetListNodeChainArray) {
}
func (*binaryClasscallGetListNodeChainArray) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetListNodeChainArray(e, obj.(*callGetListNodeChainArray))
}
func (*binaryClasscallGetListNodeChainArray) New() binary.Object {
	return &callGetListNodeChainArray{}
}
func (*binaryClasscallGetListNodeChainArray) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetListNodeChainArray(d, obj.(*callGetListNodeChainArray))
}
func (o *callGetListNodeChainArray) WriteSimple(w binary.Writer) {
	doEncodecallGetListNodeChainArray(w, o)
}
func (o *callGetListNodeChainArray) ReadSimple(r binary.Reader) {
	doDecodecallGetListNodeChainArray(r, o)
}
func (c *binaryClasscallGetListNodeChainArray) Schema() *binary.Entity {
	return &entities[ixǁcallGetListNodeChainArray]
}

type binaryClasscallGetResource struct{}

func (*callGetResource) Class() binary.Class {
	return (*binaryClasscallGetResource)(nil)
}
func doEncodecallGetResource(e binary.Writer, o *callGetResource) {
}
func doDecodecallGetResource(d binary.Reader, o *callGetResource) {
}
func doDecodeRawcallGetResource(d binary.Reader, o *callGetResource) {
}
func (*binaryClasscallGetResource) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetResource(e, obj.(*callGetResource))
}
func (*binaryClasscallGetResource) New() binary.Object {
	return &callGetResource{}
}
func (*binaryClasscallGetResource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetResource(d, obj.(*callGetResource))
}
func (o *callGetResource) WriteSimple(w binary.Writer) {
	doEncodecallGetResource(w, o)
}
func (o *callGetResource) ReadSimple(r binary.Reader) {
	doDecodecallGetResource(r, o)
}
func (c *binaryClasscallGetResource) Schema() *binary.Entity {
	return &entities[ixǁcallGetResource]
}

type binaryClasscallGetSingleListNode struct{}

func (*callGetSingleListNode) Class() binary.Class {
	return (*binaryClasscallGetSingleListNode)(nil)
}
func doEncodecallGetSingleListNode(e binary.Writer, o *callGetSingleListNode) {
}
func doDecodecallGetSingleListNode(d binary.Reader, o *callGetSingleListNode) {
}
func doDecodeRawcallGetSingleListNode(d binary.Reader, o *callGetSingleListNode) {
}
func (*binaryClasscallGetSingleListNode) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetSingleListNode(e, obj.(*callGetSingleListNode))
}
func (*binaryClasscallGetSingleListNode) New() binary.Object {
	return &callGetSingleListNode{}
}
func (*binaryClasscallGetSingleListNode) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetSingleListNode(d, obj.(*callGetSingleListNode))
}
func (o *callGetSingleListNode) WriteSimple(w binary.Writer) {
	doEncodecallGetSingleListNode(w, o)
}
func (o *callGetSingleListNode) ReadSimple(r binary.Reader) {
	doDecodecallGetSingleListNode(r, o)
}
func (c *binaryClasscallGetSingleListNode) Schema() *binary.Entity {
	return &entities[ixǁcallGetSingleListNode]
}

type binaryClasscallGetStruct struct{}

func (*callGetStruct) Class() binary.Class {
	return (*binaryClasscallGetStruct)(nil)
}
func doEncodecallGetStruct(e binary.Writer, o *callGetStruct) {
}
func doDecodecallGetStruct(d binary.Reader, o *callGetStruct) {
}
func doDecodeRawcallGetStruct(d binary.Reader, o *callGetStruct) {
}
func (*binaryClasscallGetStruct) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetStruct(e, obj.(*callGetStruct))
}
func (*binaryClasscallGetStruct) New() binary.Object {
	return &callGetStruct{}
}
func (*binaryClasscallGetStruct) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetStruct(d, obj.(*callGetStruct))
}
func (o *callGetStruct) WriteSimple(w binary.Writer) {
	doEncodecallGetStruct(w, o)
}
func (o *callGetStruct) ReadSimple(r binary.Reader) {
	doDecodecallGetStruct(r, o)
}
func (c *binaryClasscallGetStruct) Schema() *binary.Entity {
	return &entities[ixǁcallGetStruct]
}

type binaryClasscallResolveResource struct{}

func (*callResolveResource) Class() binary.Class {
	return (*binaryClasscallResolveResource)(nil)
}
func doEncodecallResolveResource(e binary.Writer, o *callResolveResource) {
	e.Data(o.r[:20])
}
func doDecodecallResolveResource(d binary.Reader, o *callResolveResource) {
	d.Data(o.r[:20])
}
func doDecodeRawcallResolveResource(d binary.Reader, o *callResolveResource) {
	d.Data(o.r[:20])
}
func (*binaryClasscallResolveResource) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallResolveResource(e, obj.(*callResolveResource))
}
func (*binaryClasscallResolveResource) New() binary.Object {
	return &callResolveResource{}
}
func (*binaryClasscallResolveResource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallResolveResource(d, obj.(*callResolveResource))
}
func (o *callResolveResource) WriteSimple(w binary.Writer) {
	doEncodecallResolveResource(w, o)
}
func (o *callResolveResource) ReadSimple(r binary.Reader) {
	doDecodecallResolveResource(r, o)
}
func (c *binaryClasscallResolveResource) Schema() *binary.Entity {
	return &entities[ixǁcallResolveResource]
}

type binaryClasscallSetStruct struct{}

func (*callSetStruct) Class() binary.Class {
	return (*binaryClasscallSetStruct)(nil)
}
func doEncodecallSetStruct(e binary.Writer, o *callSetStruct) {
	e.Simple(&o.s)
}
func doDecodecallSetStruct(d binary.Reader, o *callSetStruct) {
	d.Simple(&o.s)
}
func doDecodeRawcallSetStruct(d binary.Reader, o *callSetStruct) {
	d.Simple(&o.s)
}
func (*binaryClasscallSetStruct) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallSetStruct(e, obj.(*callSetStruct))
}
func (*binaryClasscallSetStruct) New() binary.Object {
	return &callSetStruct{}
}
func (*binaryClasscallSetStruct) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallSetStruct(d, obj.(*callSetStruct))
}
func (o *callSetStruct) WriteSimple(w binary.Writer) {
	doEncodecallSetStruct(w, o)
}
func (o *callSetStruct) ReadSimple(r binary.Reader) {
	doDecodecallSetStruct(r, o)
}
func (c *binaryClasscallSetStruct) Schema() *binary.Entity {
	return &entities[ixǁcallSetStruct]
}

type binaryClasscallUseResource struct{}

func (*callUseResource) Class() binary.Class {
	return (*binaryClasscallUseResource)(nil)
}
func doEncodecallUseResource(e binary.Writer, o *callUseResource) {
	e.Data(o.r[:20])
}
func doDecodecallUseResource(d binary.Reader, o *callUseResource) {
	d.Data(o.r[:20])
}
func doDecodeRawcallUseResource(d binary.Reader, o *callUseResource) {
	d.Data(o.r[:20])
}
func (*binaryClasscallUseResource) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallUseResource(e, obj.(*callUseResource))
}
func (*binaryClasscallUseResource) New() binary.Object {
	return &callUseResource{}
}
func (*binaryClasscallUseResource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallUseResource(d, obj.(*callUseResource))
}
func (o *callUseResource) WriteSimple(w binary.Writer) {
	doEncodecallUseResource(w, o)
}
func (o *callUseResource) ReadSimple(r binary.Reader) {
	doDecodecallUseResource(r, o)
}
func (c *binaryClasscallUseResource) Schema() *binary.Entity {
	return &entities[ixǁcallUseResource]
}

type binaryClassresultAdd struct{}

func (*resultAdd) Class() binary.Class {
	return (*binaryClassresultAdd)(nil)
}
func doEncoderesultAdd(e binary.Writer, o *resultAdd) {
	e.Uint32(o.value)
}
func doDecoderesultAdd(d binary.Reader, o *resultAdd) {
	o.value = uint32(d.Uint32())
}
func doDecodeRawresultAdd(d binary.Reader, o *resultAdd) {
	o.value = uint32(d.Uint32())
}
func (*binaryClassresultAdd) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultAdd(e, obj.(*resultAdd))
}
func (*binaryClassresultAdd) New() binary.Object {
	return &resultAdd{}
}
func (*binaryClassresultAdd) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultAdd(d, obj.(*resultAdd))
}
func (o *resultAdd) WriteSimple(w binary.Writer) {
	doEncoderesultAdd(w, o)
}
func (o *resultAdd) ReadSimple(r binary.Reader) {
	doDecoderesultAdd(r, o)
}
func (c *binaryClassresultAdd) Schema() *binary.Entity {
	return &entities[ixǁresultAdd]
}

type binaryClassresultEnumToString struct{}

func (*resultEnumToString) Class() binary.Class {
	return (*binaryClassresultEnumToString)(nil)
}
func doEncoderesultEnumToString(e binary.Writer, o *resultEnumToString) {
	e.String(o.value)
}
func doDecoderesultEnumToString(d binary.Reader, o *resultEnumToString) {
	o.value = string(d.String())
}
func doDecodeRawresultEnumToString(d binary.Reader, o *resultEnumToString) {
	o.value = string(d.String())
}
func (*binaryClassresultEnumToString) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultEnumToString(e, obj.(*resultEnumToString))
}
func (*binaryClassresultEnumToString) New() binary.Object {
	return &resultEnumToString{}
}
func (*binaryClassresultEnumToString) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultEnumToString(d, obj.(*resultEnumToString))
}
func (o *resultEnumToString) WriteSimple(w binary.Writer) {
	doEncoderesultEnumToString(w, o)
}
func (o *resultEnumToString) ReadSimple(r binary.Reader) {
	doDecoderesultEnumToString(r, o)
}
func (c *binaryClassresultEnumToString) Schema() *binary.Entity {
	return &entities[ixǁresultEnumToString]
}

type binaryClassresultGetListNodeChain struct{}

func (*resultGetListNodeChain) Class() binary.Class {
	return (*binaryClassresultGetListNodeChain)(nil)
}
func doEncoderesultGetListNodeChain(e binary.Encoder, o *resultGetListNodeChain) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetListNodeChain(d binary.Decoder, o *resultGetListNodeChain) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*ListNode)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultGetListNodeChain(d binary.Decoder, o *resultGetListNodeChain) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*ListNode)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetListNodeChain) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetListNodeChain(e, obj.(*resultGetListNodeChain))
}
func (*binaryClassresultGetListNodeChain) New() binary.Object {
	return &resultGetListNodeChain{}
}
func (*binaryClassresultGetListNodeChain) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetListNodeChain(d, obj.(*resultGetListNodeChain))
}
func (c *binaryClassresultGetListNodeChain) Schema() *binary.Entity {
	return &entities[ixǁresultGetListNodeChain]
}

type binaryClassresultGetListNodeChainArray struct{}

func (*resultGetListNodeChainArray) Class() binary.Class {
	return (*binaryClassresultGetListNodeChainArray)(nil)
}
func doEncoderesultGetListNodeChainArray(e binary.Encoder, o *resultGetListNodeChainArray) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		if *curr != nil {
			e.Object(*curr)
		} else {
			e.Object(nil)
		}
	}
}
func doDecoderesultGetListNodeChainArray(d binary.Decoder, o *resultGetListNodeChainArray) {
	if count := d.Count(); count > 0 {
		o.value = make([]*ListNode, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*ListNode)
			} else {
				*curr = nil
			}
		}
	}
}
func doDecodeRawresultGetListNodeChainArray(d binary.Decoder, o *resultGetListNodeChainArray) {
	if count := d.Count(); count > 0 {
		o.value = make([]*ListNode, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*ListNode)
			} else {
				*curr = nil
			}
		}
	}
}
func (*binaryClassresultGetListNodeChainArray) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetListNodeChainArray(e, obj.(*resultGetListNodeChainArray))
}
func (*binaryClassresultGetListNodeChainArray) New() binary.Object {
	return &resultGetListNodeChainArray{}
}
func (*binaryClassresultGetListNodeChainArray) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetListNodeChainArray(d, obj.(*resultGetListNodeChainArray))
}
func (c *binaryClassresultGetListNodeChainArray) Schema() *binary.Entity {
	return &entities[ixǁresultGetListNodeChainArray]
}

type binaryClassresultGetResource struct{}

func (*resultGetResource) Class() binary.Class {
	return (*binaryClassresultGetResource)(nil)
}
func doEncoderesultGetResource(e binary.Writer, o *resultGetResource) {
	e.Data(o.value[:20])
}
func doDecoderesultGetResource(d binary.Reader, o *resultGetResource) {
	d.Data(o.value[:20])
}
func doDecodeRawresultGetResource(d binary.Reader, o *resultGetResource) {
	d.Data(o.value[:20])
}
func (*binaryClassresultGetResource) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetResource(e, obj.(*resultGetResource))
}
func (*binaryClassresultGetResource) New() binary.Object {
	return &resultGetResource{}
}
func (*binaryClassresultGetResource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetResource(d, obj.(*resultGetResource))
}
func (o *resultGetResource) WriteSimple(w binary.Writer) {
	doEncoderesultGetResource(w, o)
}
func (o *resultGetResource) ReadSimple(r binary.Reader) {
	doDecoderesultGetResource(r, o)
}
func (c *binaryClassresultGetResource) Schema() *binary.Entity {
	return &entities[ixǁresultGetResource]
}

type binaryClassresultGetSingleListNode struct{}

func (*resultGetSingleListNode) Class() binary.Class {
	return (*binaryClassresultGetSingleListNode)(nil)
}
func doEncoderesultGetSingleListNode(e binary.Encoder, o *resultGetSingleListNode) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetSingleListNode(d binary.Decoder, o *resultGetSingleListNode) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*ListNode)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultGetSingleListNode(d binary.Decoder, o *resultGetSingleListNode) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*ListNode)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetSingleListNode) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetSingleListNode(e, obj.(*resultGetSingleListNode))
}
func (*binaryClassresultGetSingleListNode) New() binary.Object {
	return &resultGetSingleListNode{}
}
func (*binaryClassresultGetSingleListNode) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetSingleListNode(d, obj.(*resultGetSingleListNode))
}
func (c *binaryClassresultGetSingleListNode) Schema() *binary.Entity {
	return &entities[ixǁresultGetSingleListNode]
}

type binaryClassresultGetStruct struct{}

func (*resultGetStruct) Class() binary.Class {
	return (*binaryClassresultGetStruct)(nil)
}
func doEncoderesultGetStruct(e binary.Writer, o *resultGetStruct) {
	e.Simple(&o.value)
}
func doDecoderesultGetStruct(d binary.Reader, o *resultGetStruct) {
	d.Simple(&o.value)
}
func doDecodeRawresultGetStruct(d binary.Reader, o *resultGetStruct) {
	d.Simple(&o.value)
}
func (*binaryClassresultGetStruct) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetStruct(e, obj.(*resultGetStruct))
}
func (*binaryClassresultGetStruct) New() binary.Object {
	return &resultGetStruct{}
}
func (*binaryClassresultGetStruct) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetStruct(d, obj.(*resultGetStruct))
}
func (o *resultGetStruct) WriteSimple(w binary.Writer) {
	doEncoderesultGetStruct(w, o)
}
func (o *resultGetStruct) ReadSimple(r binary.Reader) {
	doDecoderesultGetStruct(r, o)
}
func (c *binaryClassresultGetStruct) Schema() *binary.Entity {
	return &entities[ixǁresultGetStruct]
}

type binaryClassresultResolveResource struct{}

func (*resultResolveResource) Class() binary.Class {
	return (*binaryClassresultResolveResource)(nil)
}
func doEncoderesultResolveResource(e binary.Writer, o *resultResolveResource) {
	e.Simple(&o.value)
}
func doDecoderesultResolveResource(d binary.Reader, o *resultResolveResource) {
	d.Simple(&o.value)
}
func doDecodeRawresultResolveResource(d binary.Reader, o *resultResolveResource) {
	d.Simple(&o.value)
}
func (*binaryClassresultResolveResource) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultResolveResource(e, obj.(*resultResolveResource))
}
func (*binaryClassresultResolveResource) New() binary.Object {
	return &resultResolveResource{}
}
func (*binaryClassresultResolveResource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultResolveResource(d, obj.(*resultResolveResource))
}
func (o *resultResolveResource) WriteSimple(w binary.Writer) {
	doEncoderesultResolveResource(w, o)
}
func (o *resultResolveResource) ReadSimple(r binary.Reader) {
	doDecoderesultResolveResource(r, o)
}
func (c *binaryClassresultResolveResource) Schema() *binary.Entity {
	return &entities[ixǁresultResolveResource]
}

type binaryClassresultSetStruct struct{}

func (*resultSetStruct) Class() binary.Class {
	return (*binaryClassresultSetStruct)(nil)
}
func doEncoderesultSetStruct(e binary.Writer, o *resultSetStruct) {
}
func doDecoderesultSetStruct(d binary.Reader, o *resultSetStruct) {
}
func doDecodeRawresultSetStruct(d binary.Reader, o *resultSetStruct) {
}
func (*binaryClassresultSetStruct) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultSetStruct(e, obj.(*resultSetStruct))
}
func (*binaryClassresultSetStruct) New() binary.Object {
	return &resultSetStruct{}
}
func (*binaryClassresultSetStruct) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultSetStruct(d, obj.(*resultSetStruct))
}
func (o *resultSetStruct) WriteSimple(w binary.Writer) {
	doEncoderesultSetStruct(w, o)
}
func (o *resultSetStruct) ReadSimple(r binary.Reader) {
	doDecoderesultSetStruct(r, o)
}
func (c *binaryClassresultSetStruct) Schema() *binary.Entity {
	return &entities[ixǁresultSetStruct]
}

type binaryClassresultUseResource struct{}

func (*resultUseResource) Class() binary.Class {
	return (*binaryClassresultUseResource)(nil)
}
func doEncoderesultUseResource(e binary.Writer, o *resultUseResource) {
}
func doDecoderesultUseResource(d binary.Reader, o *resultUseResource) {
}
func doDecodeRawresultUseResource(d binary.Reader, o *resultUseResource) {
}
func (*binaryClassresultUseResource) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultUseResource(e, obj.(*resultUseResource))
}
func (*binaryClassresultUseResource) New() binary.Object {
	return &resultUseResource{}
}
func (*binaryClassresultUseResource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultUseResource(d, obj.(*resultUseResource))
}
func (o *resultUseResource) WriteSimple(w binary.Writer) {
	doEncoderesultUseResource(w, o)
}
func (o *resultUseResource) ReadSimple(r binary.Reader) {
	doDecoderesultUseResource(r, o)
}
func (c *binaryClassresultUseResource) Schema() *binary.Entity {
	return &entities[ixǁresultUseResource]
}