gapid/service/path/path_binary.go

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

package path

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/binary/schema"
	"android.googlesource.com/platform/tools/gpu/framework/id"
	"android.googlesource.com/platform/tools/gpu/framework/rpc"
)

// 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ǁArrayIndex = iota
	ixǁAs
	ixǁCapture
	ixǁAtoms
	ixǁAtom
	ixǁAtomRange
	ixǁBlob
	ixǁContexts
	ixǁContext
	ixǁDevice
	ixǁErrNotFollowable
	ixǁField
	ixǁHierarchies
	ixǁHierarchy
	ixǁImageInfo
	ixǁMapIndex
	ixǁMemoryRange
	ixǁMemoryType
	ixǁMeshOptions
	ixǁMesh
	ixǁReport
	ixǁReportItem
	ixǁResource
	ixǁResourceBundles
	ixǁResources
	ixǁSlice
	ixǁState
	ixǁThumbnail
	ixǁTimingInfo
	ixǁTypedMemory
	ixǁVertexStreamData
)

var entities [31]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*ArrayIndex)(nil))
	Namespace.AddClassOf((*As)(nil))
	Namespace.AddClassOf((*Capture)(nil))
	Namespace.AddClassOf((*Atoms)(nil))
	Namespace.AddClassOf((*Atom)(nil))
	Namespace.AddClassOf((*AtomRange)(nil))
	Namespace.AddClassOf((*Blob)(nil))
	Namespace.AddClassOf((*Contexts)(nil))
	Namespace.AddClassOf((*Context)(nil))
	Namespace.AddClassOf((*Device)(nil))
	Namespace.AddClassOf((*ErrNotFollowable)(nil))
	Namespace.AddClassOf((*Field)(nil))
	Namespace.AddClassOf((*Hierarchies)(nil))
	Namespace.AddClassOf((*Hierarchy)(nil))
	Namespace.AddClassOf((*ImageInfo)(nil))
	Namespace.AddClassOf((*MapIndex)(nil))
	Namespace.AddClassOf((*MemoryRange)(nil))
	Namespace.AddClassOf((*MemoryType)(nil))
	Namespace.AddClassOf((*MeshOptions)(nil))
	Namespace.AddClassOf((*Mesh)(nil))
	Namespace.AddClassOf((*Report)(nil))
	Namespace.AddClassOf((*ReportItem)(nil))
	Namespace.AddClassOf((*Resource)(nil))
	Namespace.AddClassOf((*ResourceBundles)(nil))
	Namespace.AddClassOf((*Resources)(nil))
	Namespace.AddClassOf((*Slice)(nil))
	Namespace.AddClassOf((*State)(nil))
	Namespace.AddClassOf((*Thumbnail)(nil))
	Namespace.AddClassOf((*TimingInfo)(nil))
	Namespace.AddClassOf((*TypedMemory)(nil))
	Namespace.AddClassOf((*VertexStreamData)(nil))
}

type binaryClassArrayIndex struct{}

func (*ArrayIndex) Class() binary.Class {
	return (*binaryClassArrayIndex)(nil)
}
func doEncodeArrayIndex(e binary.Encoder, o *ArrayIndex) {
	e.Object(o.Array)
	e.Uint64(o.Index)
}
func doDecodeArrayIndex(d binary.Decoder, o *ArrayIndex) {
	o.Array = PathCast(d.Object())
	o.Index = uint64(d.Uint64())
}
func doDecodeRawArrayIndex(d binary.Decoder, o *ArrayIndex) {
	o.Array = PathCast(d.Object())
	o.Index = uint64(d.Uint64())
}
func (*binaryClassArrayIndex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeArrayIndex(e, obj.(*ArrayIndex))
}
func (*binaryClassArrayIndex) New() binary.Object {
	return &ArrayIndex{}
}
func (*binaryClassArrayIndex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeArrayIndex(d, obj.(*ArrayIndex))
}
func (c *binaryClassArrayIndex) Schema() *binary.Entity {
	return &entities[ixǁArrayIndex]
}

type binaryClassAs struct{}

func (*As) Class() binary.Class {
	return (*binaryClassAs)(nil)
}
func doEncodeAs(e binary.Encoder, o *As) {
	e.Object(o.Object)
	schema.Any{}.EncodeValue(e, o.Type)
}
func doDecodeAs(d binary.Decoder, o *As) {
	o.Object = PathCast(d.Object())
	o.Type = schema.Any{}.DecodeValue(d)
}
func doDecodeRawAs(d binary.Decoder, o *As) {
	o.Object = PathCast(d.Object())
	o.Type = schema.Any{}.DecodeValue(d)
}
func (*binaryClassAs) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAs(e, obj.(*As))
}
func (*binaryClassAs) New() binary.Object {
	return &As{}
}
func (*binaryClassAs) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAs(d, obj.(*As))
}
func (c *binaryClassAs) Schema() *binary.Entity {
	return &entities[ixǁAs]
}

type binaryClassCapture struct{}

func (*Capture) Class() binary.Class {
	return (*binaryClassCapture)(nil)
}
func doEncodeCapture(e binary.Writer, o *Capture) {
	e.Data(o.ID[:20])
}
func doDecodeCapture(d binary.Reader, o *Capture) {
	d.Data(o.ID[:20])
}
func doDecodeRawCapture(d binary.Reader, o *Capture) {
	d.Data(o.ID[:20])
}
func (*binaryClassCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCapture(e, obj.(*Capture))
}
func (*binaryClassCapture) New() binary.Object {
	return &Capture{}
}
func (*binaryClassCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCapture(d, obj.(*Capture))
}
func (o *Capture) WriteSimple(w binary.Writer) {
	doEncodeCapture(w, o)
}
func (o *Capture) ReadSimple(r binary.Reader) {
	doDecodeCapture(r, o)
}
func (c *binaryClassCapture) Schema() *binary.Entity {
	return &entities[ixǁCapture]
}

type binaryClassAtoms struct{}

func (*Atoms) Class() binary.Class {
	return (*binaryClassAtoms)(nil)
}
func doEncodeAtoms(e binary.Encoder, o *Atoms) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodeAtoms(d binary.Decoder, o *Atoms) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func doDecodeRawAtoms(d binary.Decoder, o *Atoms) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassAtoms) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtoms(e, obj.(*Atoms))
}
func (*binaryClassAtoms) New() binary.Object {
	return &Atoms{}
}
func (*binaryClassAtoms) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtoms(d, obj.(*Atoms))
}
func (c *binaryClassAtoms) Schema() *binary.Entity {
	return &entities[ixǁAtoms]
}

type binaryClassAtom struct{}

func (*Atom) Class() binary.Class {
	return (*binaryClassAtom)(nil)
}
func doEncodeAtom(e binary.Encoder, o *Atom) {
	if o.Atoms != nil {
		e.Object(o.Atoms)
	} else {
		e.Object(nil)
	}
	e.Uint64(o.Index)
}
func doDecodeAtom(d binary.Decoder, o *Atom) {
	if obj := d.Object(); obj != nil {
		o.Atoms = obj.(*Atoms)
	} else {
		o.Atoms = nil
	}
	o.Index = uint64(d.Uint64())
}
func doDecodeRawAtom(d binary.Decoder, o *Atom) {
	if obj := d.Object(); obj != nil {
		o.Atoms = obj.(*Atoms)
	} else {
		o.Atoms = nil
	}
	o.Index = uint64(d.Uint64())
}
func (*binaryClassAtom) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtom(e, obj.(*Atom))
}
func (*binaryClassAtom) New() binary.Object {
	return &Atom{}
}
func (*binaryClassAtom) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtom(d, obj.(*Atom))
}
func (c *binaryClassAtom) Schema() *binary.Entity {
	return &entities[ixǁAtom]
}

type binaryClassAtomRange struct{}

func (*AtomRange) Class() binary.Class {
	return (*binaryClassAtomRange)(nil)
}
func doEncodeAtomRange(e binary.Encoder, o *AtomRange) {
	if o.Atoms != nil {
		e.Object(o.Atoms)
	} else {
		e.Object(nil)
	}
	e.Uint64(o.First)
	e.Uint64(o.Count)
}
func doDecodeAtomRange(d binary.Decoder, o *AtomRange) {
	if obj := d.Object(); obj != nil {
		o.Atoms = obj.(*Atoms)
	} else {
		o.Atoms = nil
	}
	o.First = uint64(d.Uint64())
	o.Count = uint64(d.Uint64())
}
func doDecodeRawAtomRange(d binary.Decoder, o *AtomRange) {
	if obj := d.Object(); obj != nil {
		o.Atoms = obj.(*Atoms)
	} else {
		o.Atoms = nil
	}
	o.First = uint64(d.Uint64())
	o.Count = uint64(d.Uint64())
}
func (*binaryClassAtomRange) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtomRange(e, obj.(*AtomRange))
}
func (*binaryClassAtomRange) New() binary.Object {
	return &AtomRange{}
}
func (*binaryClassAtomRange) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtomRange(d, obj.(*AtomRange))
}
func (c *binaryClassAtomRange) Schema() *binary.Entity {
	return &entities[ixǁAtomRange]
}

type binaryClassBlob struct{}

func (*Blob) Class() binary.Class {
	return (*binaryClassBlob)(nil)
}
func doEncodeBlob(e binary.Writer, o *Blob) {
	e.Data(o.ID[:20])
}
func doDecodeBlob(d binary.Reader, o *Blob) {
	d.Data(o.ID[:20])
}
func doDecodeRawBlob(d binary.Reader, o *Blob) {
	d.Data(o.ID[:20])
}
func (*binaryClassBlob) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBlob(e, obj.(*Blob))
}
func (*binaryClassBlob) New() binary.Object {
	return &Blob{}
}
func (*binaryClassBlob) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBlob(d, obj.(*Blob))
}
func (o *Blob) WriteSimple(w binary.Writer) {
	doEncodeBlob(w, o)
}
func (o *Blob) ReadSimple(r binary.Reader) {
	doDecodeBlob(r, o)
}
func (c *binaryClassBlob) Schema() *binary.Entity {
	return &entities[ixǁBlob]
}

type binaryClassContexts struct{}

func (*Contexts) Class() binary.Class {
	return (*binaryClassContexts)(nil)
}
func doEncodeContexts(e binary.Encoder, o *Contexts) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodeContexts(d binary.Decoder, o *Contexts) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func doDecodeRawContexts(d binary.Decoder, o *Contexts) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassContexts) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeContexts(e, obj.(*Contexts))
}
func (*binaryClassContexts) New() binary.Object {
	return &Contexts{}
}
func (*binaryClassContexts) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeContexts(d, obj.(*Contexts))
}
func (c *binaryClassContexts) Schema() *binary.Entity {
	return &entities[ixǁContexts]
}

type binaryClassContext struct{}

func (*Context) Class() binary.Class {
	return (*binaryClassContext)(nil)
}
func doEncodeContext(e binary.Encoder, o *Context) {
	if o.Contexts != nil {
		e.Object(o.Contexts)
	} else {
		e.Object(nil)
	}
	e.Data(o.ID[:20])
}
func doDecodeContext(d binary.Decoder, o *Context) {
	if obj := d.Object(); obj != nil {
		o.Contexts = obj.(*Contexts)
	} else {
		o.Contexts = nil
	}
	d.Data(o.ID[:20])
}
func doDecodeRawContext(d binary.Decoder, o *Context) {
	if obj := d.Object(); obj != nil {
		o.Contexts = obj.(*Contexts)
	} else {
		o.Contexts = nil
	}
	d.Data(o.ID[:20])
}
func (*binaryClassContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeContext(e, obj.(*Context))
}
func (*binaryClassContext) New() binary.Object {
	return &Context{}
}
func (*binaryClassContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeContext(d, obj.(*Context))
}
func (c *binaryClassContext) Schema() *binary.Entity {
	return &entities[ixǁContext]
}

type binaryClassDevice struct{}

func (*Device) Class() binary.Class {
	return (*binaryClassDevice)(nil)
}
func doEncodeDevice(e binary.Writer, o *Device) {
	e.Data(o.ID[:20])
}
func doDecodeDevice(d binary.Reader, o *Device) {
	d.Data(o.ID[:20])
}
func doDecodeRawDevice(d binary.Reader, o *Device) {
	d.Data(o.ID[:20])
}
func (*binaryClassDevice) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeDevice(e, obj.(*Device))
}
func (*binaryClassDevice) New() binary.Object {
	return &Device{}
}
func (*binaryClassDevice) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeDevice(d, obj.(*Device))
}
func (o *Device) WriteSimple(w binary.Writer) {
	doEncodeDevice(w, o)
}
func (o *Device) ReadSimple(r binary.Reader) {
	doDecodeDevice(r, o)
}
func (c *binaryClassDevice) Schema() *binary.Entity {
	return &entities[ixǁDevice]
}

var _ rpc.Err = (*ErrNotFollowable)(nil) // Interface compliance check.
type binaryClassErrNotFollowable struct{}

func (*ErrNotFollowable) Class() binary.Class {
	return (*binaryClassErrNotFollowable)(nil)
}
func doEncodeErrNotFollowable(e binary.Encoder, o *ErrNotFollowable) {
	e.Object(o.Path)
}
func doDecodeErrNotFollowable(d binary.Decoder, o *ErrNotFollowable) {
	o.Path = PathCast(d.Object())
}
func doDecodeRawErrNotFollowable(d binary.Decoder, o *ErrNotFollowable) {
	o.Path = PathCast(d.Object())
}
func (*binaryClassErrNotFollowable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrNotFollowable(e, obj.(*ErrNotFollowable))
}
func (*binaryClassErrNotFollowable) New() binary.Object {
	return &ErrNotFollowable{}
}
func (*binaryClassErrNotFollowable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrNotFollowable(d, obj.(*ErrNotFollowable))
}
func (c *binaryClassErrNotFollowable) Schema() *binary.Entity {
	return &entities[ixǁErrNotFollowable]
}

type binaryClassField struct{}

func (*Field) Class() binary.Class {
	return (*binaryClassField)(nil)
}
func doEncodeField(e binary.Encoder, o *Field) {
	e.Object(o.Struct)
	e.String(o.Name)
}
func doDecodeField(d binary.Decoder, o *Field) {
	o.Struct = PathCast(d.Object())
	o.Name = string(d.String())
}
func doDecodeRawField(d binary.Decoder, o *Field) {
	o.Struct = PathCast(d.Object())
	o.Name = string(d.String())
}
func (*binaryClassField) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeField(e, obj.(*Field))
}
func (*binaryClassField) New() binary.Object {
	return &Field{}
}
func (*binaryClassField) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeField(d, obj.(*Field))
}
func (c *binaryClassField) Schema() *binary.Entity {
	return &entities[ixǁField]
}

type binaryClassHierarchies struct{}

func (*Hierarchies) Class() binary.Class {
	return (*binaryClassHierarchies)(nil)
}
func doEncodeHierarchies(e binary.Encoder, o *Hierarchies) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodeHierarchies(d binary.Decoder, o *Hierarchies) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func doDecodeRawHierarchies(d binary.Decoder, o *Hierarchies) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassHierarchies) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeHierarchies(e, obj.(*Hierarchies))
}
func (*binaryClassHierarchies) New() binary.Object {
	return &Hierarchies{}
}
func (*binaryClassHierarchies) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeHierarchies(d, obj.(*Hierarchies))
}
func (c *binaryClassHierarchies) Schema() *binary.Entity {
	return &entities[ixǁHierarchies]
}

type binaryClassHierarchy struct{}

func (*Hierarchy) Class() binary.Class {
	return (*binaryClassHierarchy)(nil)
}
func doEncodeHierarchy(e binary.Encoder, o *Hierarchy) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodeHierarchy(d binary.Decoder, o *Hierarchy) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func doDecodeRawHierarchy(d binary.Decoder, o *Hierarchy) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassHierarchy) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeHierarchy(e, obj.(*Hierarchy))
}
func (*binaryClassHierarchy) New() binary.Object {
	return &Hierarchy{}
}
func (*binaryClassHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeHierarchy(d, obj.(*Hierarchy))
}
func (c *binaryClassHierarchy) Schema() *binary.Entity {
	return &entities[ixǁHierarchy]
}

type binaryClassImageInfo struct{}

func (*ImageInfo) Class() binary.Class {
	return (*binaryClassImageInfo)(nil)
}
func doEncodeImageInfo(e binary.Writer, o *ImageInfo) {
	e.Data(o.ID[:20])
}
func doDecodeImageInfo(d binary.Reader, o *ImageInfo) {
	d.Data(o.ID[:20])
}
func doDecodeRawImageInfo(d binary.Reader, o *ImageInfo) {
	d.Data(o.ID[:20])
}
func (*binaryClassImageInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeImageInfo(e, obj.(*ImageInfo))
}
func (*binaryClassImageInfo) New() binary.Object {
	return &ImageInfo{}
}
func (*binaryClassImageInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeImageInfo(d, obj.(*ImageInfo))
}
func (o *ImageInfo) WriteSimple(w binary.Writer) {
	doEncodeImageInfo(w, o)
}
func (o *ImageInfo) ReadSimple(r binary.Reader) {
	doDecodeImageInfo(r, o)
}
func (c *binaryClassImageInfo) Schema() *binary.Entity {
	return &entities[ixǁImageInfo]
}

type binaryClassMapIndex struct{}

func (*MapIndex) Class() binary.Class {
	return (*binaryClassMapIndex)(nil)
}
func doEncodeMapIndex(e binary.Encoder, o *MapIndex) {
	e.Object(o.Map)
	schema.Any{}.EncodeValue(e, o.Key)
}
func doDecodeMapIndex(d binary.Decoder, o *MapIndex) {
	o.Map = PathCast(d.Object())
	o.Key = schema.Any{}.DecodeValue(d)
}
func doDecodeRawMapIndex(d binary.Decoder, o *MapIndex) {
	o.Map = PathCast(d.Object())
	o.Key = schema.Any{}.DecodeValue(d)
}
func (*binaryClassMapIndex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMapIndex(e, obj.(*MapIndex))
}
func (*binaryClassMapIndex) New() binary.Object {
	return &MapIndex{}
}
func (*binaryClassMapIndex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMapIndex(d, obj.(*MapIndex))
}
func (c *binaryClassMapIndex) Schema() *binary.Entity {
	return &entities[ixǁMapIndex]
}

type binaryClassMemoryRange struct{}

func (*MemoryRange) Class() binary.Class {
	return (*binaryClassMemoryRange)(nil)
}
func doEncodeMemoryRange(e binary.Encoder, o *MemoryRange) {
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
	e.Uint64(o.Pool)
	e.Uint64(o.Address)
	e.Uint64(o.Size)
}
func doDecodeMemoryRange(d binary.Decoder, o *MemoryRange) {
	if obj := d.Object(); obj != nil {
		o.After = obj.(*Atom)
	} else {
		o.After = nil
	}
	o.Pool = uint64(d.Uint64())
	o.Address = uint64(d.Uint64())
	o.Size = uint64(d.Uint64())
}
func doDecodeRawMemoryRange(d binary.Decoder, o *MemoryRange) {
	if obj := d.Object(); obj != nil {
		o.After = obj.(*Atom)
	} else {
		o.After = nil
	}
	o.Pool = uint64(d.Uint64())
	o.Address = uint64(d.Uint64())
	o.Size = uint64(d.Uint64())
}
func (*binaryClassMemoryRange) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMemoryRange(e, obj.(*MemoryRange))
}
func (*binaryClassMemoryRange) New() binary.Object {
	return &MemoryRange{}
}
func (*binaryClassMemoryRange) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMemoryRange(d, obj.(*MemoryRange))
}
func (c *binaryClassMemoryRange) Schema() *binary.Entity {
	return &entities[ixǁMemoryRange]
}

type binaryClassMemoryType struct{}

func (*MemoryType) Class() binary.Class {
	return (*binaryClassMemoryType)(nil)
}
func doEncodeMemoryType(e binary.Encoder, o *MemoryType) {
	e.Int32(int32(o.Kind))
	e.Uint64(o.ByteSize)
	e.Bool(o.Signed)
	if o.To != nil {
		e.Object(o.To)
	} else {
		e.Object(nil)
	}
}
func doDecodeMemoryType(d binary.Decoder, o *MemoryType) {
	o.Kind = MemoryKind(d.Int32())
	o.ByteSize = uint64(d.Uint64())
	o.Signed = bool(d.Bool())
	if obj := d.Object(); obj != nil {
		o.To = obj.(*MemoryType)
	} else {
		o.To = nil
	}
}
func doDecodeRawMemoryType(d binary.Decoder, o *MemoryType) {
	o.Kind = MemoryKind(d.Int32())
	o.ByteSize = uint64(d.Uint64())
	o.Signed = bool(d.Bool())
	if obj := d.Object(); obj != nil {
		o.To = obj.(*MemoryType)
	} else {
		o.To = nil
	}
}
func (*binaryClassMemoryType) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMemoryType(e, obj.(*MemoryType))
}
func (*binaryClassMemoryType) New() binary.Object {
	return &MemoryType{}
}
func (*binaryClassMemoryType) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMemoryType(d, obj.(*MemoryType))
}
func (c *binaryClassMemoryType) Schema() *binary.Entity {
	return &entities[ixǁMemoryType]
}

type binaryClassMeshOptions struct{}

func (*MeshOptions) Class() binary.Class {
	return (*binaryClassMeshOptions)(nil)
}
func doEncodeMeshOptions(e binary.Writer, o *MeshOptions) {
	e.Bool(o.Faceted)
}
func doDecodeMeshOptions(d binary.Reader, o *MeshOptions) {
	o.Faceted = bool(d.Bool())
}
func doDecodeRawMeshOptions(d binary.Reader, o *MeshOptions) {
	o.Faceted = bool(d.Bool())
}
func (*binaryClassMeshOptions) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMeshOptions(e, obj.(*MeshOptions))
}
func (*binaryClassMeshOptions) New() binary.Object {
	return &MeshOptions{}
}
func (*binaryClassMeshOptions) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMeshOptions(d, obj.(*MeshOptions))
}
func (o *MeshOptions) WriteSimple(w binary.Writer) {
	doEncodeMeshOptions(w, o)
}
func (o *MeshOptions) ReadSimple(r binary.Reader) {
	doDecodeMeshOptions(r, o)
}
func (c *binaryClassMeshOptions) Schema() *binary.Entity {
	return &entities[ixǁMeshOptions]
}

type binaryClassMesh struct{}

func (*Mesh) Class() binary.Class {
	return (*binaryClassMesh)(nil)
}
func doEncodeMesh(e binary.Encoder, o *Mesh) {
	e.Object(o.Object)
	if o.Options != nil {
		e.Object(o.Options)
	} else {
		e.Object(nil)
	}
}
func doDecodeMesh(d binary.Decoder, o *Mesh) {
	o.Object = PathCast(d.Object())
	if obj := d.Object(); obj != nil {
		o.Options = obj.(*MeshOptions)
	} else {
		o.Options = nil
	}
}
func doDecodeRawMesh(d binary.Decoder, o *Mesh) {
	o.Object = PathCast(d.Object())
	if obj := d.Object(); obj != nil {
		o.Options = obj.(*MeshOptions)
	} else {
		o.Options = nil
	}
}
func (*binaryClassMesh) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMesh(e, obj.(*Mesh))
}
func (*binaryClassMesh) New() binary.Object {
	return &Mesh{}
}
func (*binaryClassMesh) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMesh(d, obj.(*Mesh))
}
func (c *binaryClassMesh) Schema() *binary.Entity {
	return &entities[ixǁMesh]
}

type binaryClassReport struct{}

func (*Report) Class() binary.Class {
	return (*binaryClassReport)(nil)
}
func doEncodeReport(e binary.Encoder, o *Report) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
	if o.Device != nil {
		e.Object(o.Device)
	} else {
		e.Object(nil)
	}
}
func doDecodeReport(d binary.Decoder, o *Report) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
	if obj := d.Object(); obj != nil {
		o.Device = obj.(*Device)
	} else {
		o.Device = nil
	}
}
func doDecodeRawReport(d binary.Decoder, o *Report) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
	if obj := d.Object(); obj != nil {
		o.Device = obj.(*Device)
	} else {
		o.Device = nil
	}
}
func (*binaryClassReport) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReport(e, obj.(*Report))
}
func (*binaryClassReport) New() binary.Object {
	return &Report{}
}
func (*binaryClassReport) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReport(d, obj.(*Report))
}
func (c *binaryClassReport) Schema() *binary.Entity {
	return &entities[ixǁReport]
}

type binaryClassReportItem struct{}

func (*ReportItem) Class() binary.Class {
	return (*binaryClassReportItem)(nil)
}
func doEncodeReportItem(e binary.Encoder, o *ReportItem) {
	if o.Report != nil {
		e.Object(o.Report)
	} else {
		e.Object(nil)
	}
	e.Uint64(o.Index)
}
func doDecodeReportItem(d binary.Decoder, o *ReportItem) {
	if obj := d.Object(); obj != nil {
		o.Report = obj.(*Report)
	} else {
		o.Report = nil
	}
	o.Index = uint64(d.Uint64())
}
func doDecodeRawReportItem(d binary.Decoder, o *ReportItem) {
	if obj := d.Object(); obj != nil {
		o.Report = obj.(*Report)
	} else {
		o.Report = nil
	}
	o.Index = uint64(d.Uint64())
}
func (*binaryClassReportItem) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReportItem(e, obj.(*ReportItem))
}
func (*binaryClassReportItem) New() binary.Object {
	return &ReportItem{}
}
func (*binaryClassReportItem) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReportItem(d, obj.(*ReportItem))
}
func (c *binaryClassReportItem) Schema() *binary.Entity {
	return &entities[ixǁReportItem]
}

type binaryClassResource struct{}

func (*Resource) Class() binary.Class {
	return (*binaryClassResource)(nil)
}
func doEncodeResource(e binary.Encoder, o *Resource) {
	e.Data(o.ID[:20])
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
}
func doDecodeResource(d binary.Decoder, o *Resource) {
	d.Data(o.ID[:20])
	if obj := d.Object(); obj != nil {
		o.After = obj.(*Atom)
	} else {
		o.After = nil
	}
}
func doDecodeRawResource(d binary.Decoder, o *Resource) {
	d.Data(o.ID[:20])
	if obj := d.Object(); obj != nil {
		o.After = obj.(*Atom)
	} else {
		o.After = nil
	}
}
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 (c *binaryClassResource) Schema() *binary.Entity {
	return &entities[ixǁResource]
}

type binaryClassResourceBundles struct{}

func (*ResourceBundles) Class() binary.Class {
	return (*binaryClassResourceBundles)(nil)
}
func doEncodeResourceBundles(e binary.Encoder, o *ResourceBundles) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodeResourceBundles(d binary.Decoder, o *ResourceBundles) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func doDecodeRawResourceBundles(d binary.Decoder, o *ResourceBundles) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassResourceBundles) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResourceBundles(e, obj.(*ResourceBundles))
}
func (*binaryClassResourceBundles) New() binary.Object {
	return &ResourceBundles{}
}
func (*binaryClassResourceBundles) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResourceBundles(d, obj.(*ResourceBundles))
}
func (c *binaryClassResourceBundles) Schema() *binary.Entity {
	return &entities[ixǁResourceBundles]
}

type binaryClassResources struct{}

func (*Resources) Class() binary.Class {
	return (*binaryClassResources)(nil)
}
func doEncodeResources(e binary.Encoder, o *Resources) {
	if o.Capture != nil {
		e.Object(o.Capture)
	} else {
		e.Object(nil)
	}
}
func doDecodeResources(d binary.Decoder, o *Resources) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func doDecodeRawResources(d binary.Decoder, o *Resources) {
	if obj := d.Object(); obj != nil {
		o.Capture = obj.(*Capture)
	} else {
		o.Capture = nil
	}
}
func (*binaryClassResources) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResources(e, obj.(*Resources))
}
func (*binaryClassResources) New() binary.Object {
	return &Resources{}
}
func (*binaryClassResources) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResources(d, obj.(*Resources))
}
func (c *binaryClassResources) Schema() *binary.Entity {
	return &entities[ixǁResources]
}

type binaryClassSlice struct{}

func (*Slice) Class() binary.Class {
	return (*binaryClassSlice)(nil)
}
func doEncodeSlice(e binary.Encoder, o *Slice) {
	e.Object(o.Array)
	e.Uint64(o.Start)
	e.Uint64(o.End)
}
func doDecodeSlice(d binary.Decoder, o *Slice) {
	o.Array = PathCast(d.Object())
	o.Start = uint64(d.Uint64())
	o.End = uint64(d.Uint64())
}
func doDecodeRawSlice(d binary.Decoder, o *Slice) {
	o.Array = PathCast(d.Object())
	o.Start = uint64(d.Uint64())
	o.End = uint64(d.Uint64())
}
func (*binaryClassSlice) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeSlice(e, obj.(*Slice))
}
func (*binaryClassSlice) New() binary.Object {
	return &Slice{}
}
func (*binaryClassSlice) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeSlice(d, obj.(*Slice))
}
func (c *binaryClassSlice) Schema() *binary.Entity {
	return &entities[ixǁSlice]
}

type binaryClassState struct{}

func (*State) Class() binary.Class {
	return (*binaryClassState)(nil)
}
func doEncodeState(e binary.Encoder, o *State) {
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
}
func doDecodeState(d binary.Decoder, o *State) {
	if obj := d.Object(); obj != nil {
		o.After = obj.(*Atom)
	} else {
		o.After = nil
	}
}
func doDecodeRawState(d binary.Decoder, o *State) {
	if obj := d.Object(); obj != nil {
		o.After = obj.(*Atom)
	} else {
		o.After = nil
	}
}
func (*binaryClassState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeState(e, obj.(*State))
}
func (*binaryClassState) New() binary.Object {
	return &State{}
}
func (*binaryClassState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeState(d, obj.(*State))
}
func (c *binaryClassState) Schema() *binary.Entity {
	return &entities[ixǁState]
}

type binaryClassThumbnail struct{}

func (*Thumbnail) Class() binary.Class {
	return (*binaryClassThumbnail)(nil)
}
func doEncodeThumbnail(e binary.Encoder, o *Thumbnail) {
	e.Object(o.Object)
	e.Uint32(o.DesiredMaxWidth)
	e.Uint32(o.DesiredMaxHeight)
	schema.Any{}.EncodeValue(e, o.DesiredFormat)
}
func doDecodeThumbnail(d binary.Decoder, o *Thumbnail) {
	o.Object = PathCast(d.Object())
	o.DesiredMaxWidth = uint32(d.Uint32())
	o.DesiredMaxHeight = uint32(d.Uint32())
	o.DesiredFormat = schema.Any{}.DecodeValue(d)
}
func doDecodeRawThumbnail(d binary.Decoder, o *Thumbnail) {
	o.Object = PathCast(d.Object())
	o.DesiredMaxWidth = uint32(d.Uint32())
	o.DesiredMaxHeight = uint32(d.Uint32())
	o.DesiredFormat = schema.Any{}.DecodeValue(d)
}
func (*binaryClassThumbnail) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeThumbnail(e, obj.(*Thumbnail))
}
func (*binaryClassThumbnail) New() binary.Object {
	return &Thumbnail{}
}
func (*binaryClassThumbnail) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeThumbnail(d, obj.(*Thumbnail))
}
func (c *binaryClassThumbnail) Schema() *binary.Entity {
	return &entities[ixǁThumbnail]
}

type binaryClassTimingInfo struct{}

func (*TimingInfo) Class() binary.Class {
	return (*binaryClassTimingInfo)(nil)
}
func doEncodeTimingInfo(e binary.Writer, o *TimingInfo) {
	e.Data(o.ID[:20])
}
func doDecodeTimingInfo(d binary.Reader, o *TimingInfo) {
	d.Data(o.ID[:20])
}
func doDecodeRawTimingInfo(d binary.Reader, o *TimingInfo) {
	d.Data(o.ID[:20])
}
func (*binaryClassTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTimingInfo(e, obj.(*TimingInfo))
}
func (*binaryClassTimingInfo) New() binary.Object {
	return &TimingInfo{}
}
func (*binaryClassTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTimingInfo(d, obj.(*TimingInfo))
}
func (o *TimingInfo) WriteSimple(w binary.Writer) {
	doEncodeTimingInfo(w, o)
}
func (o *TimingInfo) ReadSimple(r binary.Reader) {
	doDecodeTimingInfo(r, o)
}
func (c *binaryClassTimingInfo) Schema() *binary.Entity {
	return &entities[ixǁTimingInfo]
}

type binaryClassTypedMemory struct{}

func (*TypedMemory) Class() binary.Class {
	return (*binaryClassTypedMemory)(nil)
}
func doEncodeTypedMemory(e binary.Encoder, o *TypedMemory) {
	if o.Range != nil {
		e.Object(o.Range)
	} else {
		e.Object(nil)
	}
	e.Struct(&o.Type)
}
func doDecodeTypedMemory(d binary.Decoder, o *TypedMemory) {
	if obj := d.Object(); obj != nil {
		o.Range = obj.(*MemoryRange)
	} else {
		o.Range = nil
	}
	d.Struct(&o.Type)
}
func doDecodeRawTypedMemory(d binary.Decoder, o *TypedMemory) {
	if obj := d.Object(); obj != nil {
		o.Range = obj.(*MemoryRange)
	} else {
		o.Range = nil
	}
	d.Struct(&o.Type)
}
func (*binaryClassTypedMemory) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTypedMemory(e, obj.(*TypedMemory))
}
func (*binaryClassTypedMemory) New() binary.Object {
	return &TypedMemory{}
}
func (*binaryClassTypedMemory) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTypedMemory(d, obj.(*TypedMemory))
}
func (c *binaryClassTypedMemory) Schema() *binary.Entity {
	return &entities[ixǁTypedMemory]
}

type binaryClassVertexStreamData struct{}

func (*VertexStreamData) Class() binary.Class {
	return (*binaryClassVertexStreamData)(nil)
}
func doEncodeVertexStreamData(e binary.Writer, o *VertexStreamData) {
	e.Data(o.ID[:20])
}
func doDecodeVertexStreamData(d binary.Reader, o *VertexStreamData) {
	d.Data(o.ID[:20])
}
func doDecodeRawVertexStreamData(d binary.Reader, o *VertexStreamData) {
	d.Data(o.ID[:20])
}
func (*binaryClassVertexStreamData) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexStreamData(e, obj.(*VertexStreamData))
}
func (*binaryClassVertexStreamData) New() binary.Object {
	return &VertexStreamData{}
}
func (*binaryClassVertexStreamData) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexStreamData(d, obj.(*VertexStreamData))
}
func (o *VertexStreamData) WriteSimple(w binary.Writer) {
	doEncodeVertexStreamData(w, o)
}
func (o *VertexStreamData) ReadSimple(r binary.Reader) {
	doDecodeVertexStreamData(r, o)
}
func (c *binaryClassVertexStreamData) Schema() *binary.Entity {
	return &entities[ixǁVertexStreamData]
}