gapid/service/service_binary.go

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

package service

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/log"
	"android.googlesource.com/platform/tools/gpu/framework/rpc"
	"android.googlesource.com/platform/tools/gpu/framework/stringtable"
	"android.googlesource.com/platform/tools/gpu/framework/stringtable/msg"
	"android.googlesource.com/platform/tools/gpu/gapid/atom"
	"android.googlesource.com/platform/tools/gpu/gapid/memory"
	"android.googlesource.com/platform/tools/gpu/gapid/service/path"
)

// 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ǁAtomRangeTimer = iota
	ixǁAtomTimer
	ixǁCapture
	ixǁContext
	ixǁContextList
	ixǁDevice
	ixǁErrDataUnavailable
	ixǁErrInvalidArgument
	ixǁErrInvalidPath
	ixǁHierarchy
	ixǁHierarchyList
	ixǁMemoryInfo
	ixǁRenderSettings
	ixǁReportItem
	ixǁReport
	ixǁResourceInfo
	ixǁResources
	ixǁTimingInfo
	ixǁcallBeginCPUProfile
	ixǁcallEndCPUProfile
	ixǁcallFollow
	ixǁcallGet
	ixǁcallGetAvailableStringTables
	ixǁcallGetCaptures
	ixǁcallGetDevices
	ixǁcallGetFeatures
	ixǁcallGetFramebufferColor
	ixǁcallGetFramebufferDepth
	ixǁcallGetSchema
	ixǁcallGetStringTable
	ixǁcallGetTimingInfo
	ixǁcallImportCapture
	ixǁcallLoadCapture
	ixǁcallSet
	ixǁresultBeginCPUProfile
	ixǁresultEndCPUProfile
	ixǁresultFollow
	ixǁresultGet
	ixǁresultGetAvailableStringTables
	ixǁresultGetCaptures
	ixǁresultGetDevices
	ixǁresultGetFeatures
	ixǁresultGetFramebufferColor
	ixǁresultGetFramebufferDepth
	ixǁresultGetSchema
	ixǁresultGetStringTable
	ixǁresultGetTimingInfo
	ixǁresultImportCapture
	ixǁresultLoadCapture
	ixǁresultSet
)

var entities [50]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*AtomRangeTimer)(nil))
	Namespace.AddClassOf((*AtomTimer)(nil))
	Namespace.AddClassOf((*Capture)(nil))
	Namespace.AddClassOf((*Context)(nil))
	Namespace.AddClassOf((*ContextList)(nil))
	Namespace.AddClassOf((*Device)(nil))
	Namespace.AddClassOf((*ErrDataUnavailable)(nil))
	Namespace.AddClassOf((*ErrInvalidArgument)(nil))
	Namespace.AddClassOf((*ErrInvalidPath)(nil))
	Namespace.AddClassOf((*Hierarchy)(nil))
	Namespace.AddClassOf((*HierarchyList)(nil))
	Namespace.AddClassOf((*MemoryInfo)(nil))
	Namespace.AddClassOf((*RenderSettings)(nil))
	Namespace.AddClassOf((*ReportItem)(nil))
	Namespace.AddClassOf((*Report)(nil))
	Namespace.AddClassOf((*ResourceInfo)(nil))
	Namespace.AddClassOf((*Resources)(nil))
	Namespace.AddClassOf((*TimingInfo)(nil))
	Namespace.AddClassOf((*callBeginCPUProfile)(nil))
	Namespace.AddClassOf((*callEndCPUProfile)(nil))
	Namespace.AddClassOf((*callFollow)(nil))
	Namespace.AddClassOf((*callGet)(nil))
	Namespace.AddClassOf((*callGetAvailableStringTables)(nil))
	Namespace.AddClassOf((*callGetCaptures)(nil))
	Namespace.AddClassOf((*callGetDevices)(nil))
	Namespace.AddClassOf((*callGetFeatures)(nil))
	Namespace.AddClassOf((*callGetFramebufferColor)(nil))
	Namespace.AddClassOf((*callGetFramebufferDepth)(nil))
	Namespace.AddClassOf((*callGetSchema)(nil))
	Namespace.AddClassOf((*callGetStringTable)(nil))
	Namespace.AddClassOf((*callGetTimingInfo)(nil))
	Namespace.AddClassOf((*callImportCapture)(nil))
	Namespace.AddClassOf((*callLoadCapture)(nil))
	Namespace.AddClassOf((*callSet)(nil))
	Namespace.AddClassOf((*resultBeginCPUProfile)(nil))
	Namespace.AddClassOf((*resultEndCPUProfile)(nil))
	Namespace.AddClassOf((*resultFollow)(nil))
	Namespace.AddClassOf((*resultGet)(nil))
	Namespace.AddClassOf((*resultGetAvailableStringTables)(nil))
	Namespace.AddClassOf((*resultGetCaptures)(nil))
	Namespace.AddClassOf((*resultGetDevices)(nil))
	Namespace.AddClassOf((*resultGetFeatures)(nil))
	Namespace.AddClassOf((*resultGetFramebufferColor)(nil))
	Namespace.AddClassOf((*resultGetFramebufferDepth)(nil))
	Namespace.AddClassOf((*resultGetSchema)(nil))
	Namespace.AddClassOf((*resultGetStringTable)(nil))
	Namespace.AddClassOf((*resultGetTimingInfo)(nil))
	Namespace.AddClassOf((*resultImportCapture)(nil))
	Namespace.AddClassOf((*resultLoadCapture)(nil))
	Namespace.AddClassOf((*resultSet)(nil))
}

type binaryClassAtomRangeTimer struct{}

func (*AtomRangeTimer) Class() binary.Class {
	return (*binaryClassAtomRangeTimer)(nil)
}
func doEncodeAtomRangeTimer(e binary.Writer, o *AtomRangeTimer) {
	e.Uint64(o.FromAtomIndex)
	e.Uint64(o.ToAtomIndex)
	e.Uint64(o.Nanoseconds)
}
func doDecodeAtomRangeTimer(d binary.Reader, o *AtomRangeTimer) {
	o.FromAtomIndex = uint64(d.Uint64())
	o.ToAtomIndex = uint64(d.Uint64())
	o.Nanoseconds = uint64(d.Uint64())
}
func (*binaryClassAtomRangeTimer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtomRangeTimer(e, obj.(*AtomRangeTimer))
}
func (*binaryClassAtomRangeTimer) New() binary.Object {
	return &AtomRangeTimer{}
}
func (*binaryClassAtomRangeTimer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtomRangeTimer(d, obj.(*AtomRangeTimer))
}
func (o *AtomRangeTimer) WriteSimple(w binary.Writer) {
	doEncodeAtomRangeTimer(w, o)
}
func (o *AtomRangeTimer) ReadSimple(r binary.Reader) {
	doDecodeAtomRangeTimer(r, o)
}
func (c *binaryClassAtomRangeTimer) Schema() *binary.Entity {
	return &entities[ixǁAtomRangeTimer]
}

type binaryClassAtomTimer struct{}

func (*AtomTimer) Class() binary.Class {
	return (*binaryClassAtomTimer)(nil)
}
func doEncodeAtomTimer(e binary.Writer, o *AtomTimer) {
	e.Uint64(o.AtomIndex)
	e.Uint64(o.Nanoseconds)
}
func doDecodeAtomTimer(d binary.Reader, o *AtomTimer) {
	o.AtomIndex = uint64(d.Uint64())
	o.Nanoseconds = uint64(d.Uint64())
}
func (*binaryClassAtomTimer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtomTimer(e, obj.(*AtomTimer))
}
func (*binaryClassAtomTimer) New() binary.Object {
	return &AtomTimer{}
}
func (*binaryClassAtomTimer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtomTimer(d, obj.(*AtomTimer))
}
func (o *AtomTimer) WriteSimple(w binary.Writer) {
	doEncodeAtomTimer(w, o)
}
func (o *AtomTimer) ReadSimple(r binary.Reader) {
	doDecodeAtomTimer(r, o)
}
func (c *binaryClassAtomTimer) Schema() *binary.Entity {
	return &entities[ixǁAtomTimer]
}

type binaryClassCapture struct{}

func (*Capture) Class() binary.Class {
	return (*binaryClassCapture)(nil)
}
func doEncodeCapture(e binary.Writer, o *Capture) {
	e.String(o.Name)
	e.Data(o.Atoms[:20])
	e.Uint32(uint32(len(o.Apis)))
	for i := range o.Apis {
		curr := &o.Apis[i]
		e.Data((*curr)[:20])
	}
}
func doDecodeCapture(d binary.Reader, o *Capture) {
	o.Name = string(d.String())
	d.Data(o.Atoms[:20])
	if count := d.Count(); count > 0 {
		o.Apis = make([]ApiID, count)
		for i := range o.Apis {
			curr := &o.Apis[i]
			d.Data((*curr)[: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 binaryClassContext struct{}

func (*Context) Class() binary.Class {
	return (*binaryClassContext)(nil)
}
func doEncodeContext(e binary.Writer, o *Context) {
	e.Data(o.ID[:20])
	e.String(o.Name)
	e.Data(o.Api[:20])
	e.Uint32(uint32(len(o.Ranges)))
	for i := range o.Ranges {
		curr := &o.Ranges[i]
		e.Simple(&(*curr))
	}
}
func doDecodeContext(d binary.Reader, o *Context) {
	d.Data(o.ID[:20])
	o.Name = string(d.String())
	d.Data(o.Api[:20])
	if count := d.Count(); count > 0 {
		o.Ranges = make(atom.RangeList, count)
		for i := range o.Ranges {
			curr := &o.Ranges[i]
			d.Simple(&(*curr))
		}
	}
}
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 (o *Context) WriteSimple(w binary.Writer) {
	doEncodeContext(w, o)
}
func (o *Context) ReadSimple(r binary.Reader) {
	doDecodeContext(r, o)
}
func (c *binaryClassContext) Schema() *binary.Entity {
	return &entities[ixǁContext]
}

type binaryClassContextList struct{}

func (*ContextList) Class() binary.Class {
	return (*binaryClassContextList)(nil)
}
func doEncodeContextList(e binary.Encoder, o *ContextList) {
	e.Uint32(uint32(len(o.Contexts)))
	for i := range o.Contexts {
		curr := &o.Contexts[i]
		e.Simple(&(*curr))
	}
}
func doDecodeContextList(d binary.Decoder, o *ContextList) {
	if count := d.Count(); count > 0 {
		o.Contexts = make([]Context, count)
		for i := range o.Contexts {
			curr := &o.Contexts[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassContextList) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeContextList(e, obj.(*ContextList))
}
func (*binaryClassContextList) New() binary.Object {
	return &ContextList{}
}
func (*binaryClassContextList) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeContextList(d, obj.(*ContextList))
}
func (c *binaryClassContextList) Schema() *binary.Entity {
	return &entities[ixǁContextList]
}

type binaryClassDevice struct{}

func (*Device) Class() binary.Class {
	return (*binaryClassDevice)(nil)
}
func doEncodeDevice(e binary.Writer, o *Device) {
	e.String(o.Name)
	e.String(o.Model)
	e.String(o.OS)
	e.Uint8(o.PointerSize)
	e.Uint8(o.PointerAlignment)
	e.Uint64(o.MaxMemorySize)
	e.String(o.Extensions)
	e.String(o.Renderer)
	e.String(o.Vendor)
	e.String(o.Version)
}
func doDecodeDevice(d binary.Reader, o *Device) {
	o.Name = string(d.String())
	o.Model = string(d.String())
	o.OS = string(d.String())
	o.PointerSize = uint8(d.Uint8())
	o.PointerAlignment = uint8(d.Uint8())
	o.MaxMemorySize = uint64(d.Uint64())
	o.Extensions = string(d.String())
	o.Renderer = string(d.String())
	o.Vendor = string(d.String())
	o.Version = string(d.String())
}
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 = (*ErrDataUnavailable)(nil) // Interface compliance check.
type binaryClassErrDataUnavailable struct{}

func (*ErrDataUnavailable) Class() binary.Class {
	return (*binaryClassErrDataUnavailable)(nil)
}
func doEncodeErrDataUnavailable(e binary.Encoder, o *ErrDataUnavailable) {
	if o.Reason != nil {
		e.Object(o.Reason)
	} else {
		e.Object(nil)
	}
	e.Bool(o.Transient)
}
func doDecodeErrDataUnavailable(d binary.Decoder, o *ErrDataUnavailable) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
	o.Transient = bool(d.Bool())
}
func (*binaryClassErrDataUnavailable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrDataUnavailable(e, obj.(*ErrDataUnavailable))
}
func (*binaryClassErrDataUnavailable) New() binary.Object {
	return &ErrDataUnavailable{}
}
func (*binaryClassErrDataUnavailable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrDataUnavailable(d, obj.(*ErrDataUnavailable))
}
func (c *binaryClassErrDataUnavailable) Schema() *binary.Entity {
	return &entities[ixǁErrDataUnavailable]
}

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

func (*ErrInvalidArgument) Class() binary.Class {
	return (*binaryClassErrInvalidArgument)(nil)
}
func doEncodeErrInvalidArgument(e binary.Encoder, o *ErrInvalidArgument) {
	if o.Reason != nil {
		e.Object(o.Reason)
	} else {
		e.Object(nil)
	}
}
func doDecodeErrInvalidArgument(d binary.Decoder, o *ErrInvalidArgument) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
}
func (*binaryClassErrInvalidArgument) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrInvalidArgument(e, obj.(*ErrInvalidArgument))
}
func (*binaryClassErrInvalidArgument) New() binary.Object {
	return &ErrInvalidArgument{}
}
func (*binaryClassErrInvalidArgument) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrInvalidArgument(d, obj.(*ErrInvalidArgument))
}
func (c *binaryClassErrInvalidArgument) Schema() *binary.Entity {
	return &entities[ixǁErrInvalidArgument]
}

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

func (*ErrInvalidPath) Class() binary.Class {
	return (*binaryClassErrInvalidPath)(nil)
}
func doEncodeErrInvalidPath(e binary.Encoder, o *ErrInvalidPath) {
	if o.Reason != nil {
		e.Object(o.Reason)
	} else {
		e.Object(nil)
	}
	e.Object(o.Path)
}
func doDecodeErrInvalidPath(d binary.Decoder, o *ErrInvalidPath) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
	o.Path = path.PathCast(d.Object())
}
func (*binaryClassErrInvalidPath) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrInvalidPath(e, obj.(*ErrInvalidPath))
}
func (*binaryClassErrInvalidPath) New() binary.Object {
	return &ErrInvalidPath{}
}
func (*binaryClassErrInvalidPath) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrInvalidPath(d, obj.(*ErrInvalidPath))
}
func (c *binaryClassErrInvalidPath) Schema() *binary.Entity {
	return &entities[ixǁErrInvalidPath]
}

type binaryClassHierarchy struct{}

func (*Hierarchy) Class() binary.Class {
	return (*binaryClassHierarchy)(nil)
}
func doEncodeHierarchy(e binary.Encoder, o *Hierarchy) {
	e.String(o.Name)
	e.Data(o.Context[:20])
	e.Struct(&o.Root)
}
func doDecodeHierarchy(d binary.Decoder, o *Hierarchy) {
	o.Name = string(d.String())
	d.Data(o.Context[:20])
	d.Struct(&o.Root)
}
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 binaryClassHierarchyList struct{}

func (*HierarchyList) Class() binary.Class {
	return (*binaryClassHierarchyList)(nil)
}
func doEncodeHierarchyList(e binary.Encoder, o *HierarchyList) {
	e.Uint32(uint32(len(o.Hierarchies)))
	for i := range o.Hierarchies {
		curr := &o.Hierarchies[i]
		e.Struct(&(*curr))
	}
}
func doDecodeHierarchyList(d binary.Decoder, o *HierarchyList) {
	if count := d.Count(); count > 0 {
		o.Hierarchies = make([]Hierarchy, count)
		for i := range o.Hierarchies {
			curr := &o.Hierarchies[i]
			d.Struct(&(*curr))
		}
	}
}
func (*binaryClassHierarchyList) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeHierarchyList(e, obj.(*HierarchyList))
}
func (*binaryClassHierarchyList) New() binary.Object {
	return &HierarchyList{}
}
func (*binaryClassHierarchyList) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeHierarchyList(d, obj.(*HierarchyList))
}
func (c *binaryClassHierarchyList) Schema() *binary.Entity {
	return &entities[ixǁHierarchyList]
}

type binaryClassMemoryInfo struct{}

func (*MemoryInfo) Class() binary.Class {
	return (*binaryClassMemoryInfo)(nil)
}
func doEncodeMemoryInfo(e binary.Writer, o *MemoryInfo) {
	e.Uint32(uint32(len(o.Data)))
	e.Data(o.Data)
	e.Uint32(uint32(len(o.Reads)))
	for i := range o.Reads {
		curr := &o.Reads[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Writes)))
	for i := range o.Writes {
		curr := &o.Writes[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Observed)))
	for i := range o.Observed {
		curr := &o.Observed[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMemoryInfo(d binary.Reader, o *MemoryInfo) {
	if count := d.Count(); count > 0 {
		o.Data = make([]uint8, count)
		d.Data(o.Data)
	}
	if count := d.Count(); count > 0 {
		o.Reads = make(memory.RangeList, count)
		for i := range o.Reads {
			curr := &o.Reads[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Writes = make(memory.RangeList, count)
		for i := range o.Writes {
			curr := &o.Writes[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Observed = make(memory.RangeList, count)
		for i := range o.Observed {
			curr := &o.Observed[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassMemoryInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMemoryInfo(e, obj.(*MemoryInfo))
}
func (*binaryClassMemoryInfo) New() binary.Object {
	return &MemoryInfo{}
}
func (*binaryClassMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMemoryInfo(d, obj.(*MemoryInfo))
}
func (o *MemoryInfo) WriteSimple(w binary.Writer) {
	doEncodeMemoryInfo(w, o)
}
func (o *MemoryInfo) ReadSimple(r binary.Reader) {
	doDecodeMemoryInfo(r, o)
}
func (c *binaryClassMemoryInfo) Schema() *binary.Entity {
	return &entities[ixǁMemoryInfo]
}

type binaryClassRenderSettings struct{}

func (*RenderSettings) Class() binary.Class {
	return (*binaryClassRenderSettings)(nil)
}
func doEncodeRenderSettings(e binary.Writer, o *RenderSettings) {
	e.Uint32(o.MaxWidth)
	e.Uint32(o.MaxHeight)
	e.Int32(int32(o.WireframeMode))
}
func doDecodeRenderSettings(d binary.Reader, o *RenderSettings) {
	o.MaxWidth = uint32(d.Uint32())
	o.MaxHeight = uint32(d.Uint32())
	o.WireframeMode = WireframeMode(d.Int32())
}
func (*binaryClassRenderSettings) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderSettings(e, obj.(*RenderSettings))
}
func (*binaryClassRenderSettings) New() binary.Object {
	return &RenderSettings{}
}
func (*binaryClassRenderSettings) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderSettings(d, obj.(*RenderSettings))
}
func (o *RenderSettings) WriteSimple(w binary.Writer) {
	doEncodeRenderSettings(w, o)
}
func (o *RenderSettings) ReadSimple(r binary.Reader) {
	doDecodeRenderSettings(r, o)
}
func (c *binaryClassRenderSettings) Schema() *binary.Entity {
	return &entities[ixǁRenderSettings]
}

type binaryClassReportItem struct{}

func (*ReportItem) Class() binary.Class {
	return (*binaryClassReportItem)(nil)
}
func doEncodeReportItem(e binary.Writer, o *ReportItem) {
	e.Int32(int32(o.Severity))
	e.String(o.Message)
	e.Uint64(o.Atom)
}
func doDecodeReportItem(d binary.Reader, o *ReportItem) {
	o.Severity = log.Severity(d.Int32())
	o.Message = string(d.String())
	o.Atom = 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 (o *ReportItem) WriteSimple(w binary.Writer) {
	doEncodeReportItem(w, o)
}
func (o *ReportItem) ReadSimple(r binary.Reader) {
	doDecodeReportItem(r, o)
}
func (c *binaryClassReportItem) Schema() *binary.Entity {
	return &entities[ixǁReportItem]
}

type binaryClassReport struct{}

func (*Report) Class() binary.Class {
	return (*binaryClassReport)(nil)
}
func doEncodeReport(e binary.Writer, o *Report) {
	e.Uint32(uint32(len(o.Items)))
	for i := range o.Items {
		curr := &o.Items[i]
		e.Simple(&(*curr))
	}
}
func doDecodeReport(d binary.Reader, o *Report) {
	if count := d.Count(); count > 0 {
		o.Items = make([]ReportItem, count)
		for i := range o.Items {
			curr := &o.Items[i]
			d.Simple(&(*curr))
		}
	}
}
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 (o *Report) WriteSimple(w binary.Writer) {
	doEncodeReport(w, o)
}
func (o *Report) ReadSimple(r binary.Reader) {
	doDecodeReport(r, o)
}
func (c *binaryClassReport) Schema() *binary.Entity {
	return &entities[ixǁReport]
}

type binaryClassResourceInfo struct{}

func (*ResourceInfo) Class() binary.Class {
	return (*binaryClassResourceInfo)(nil)
}
func doEncodeResourceInfo(e binary.Writer, o *ResourceInfo) {
	e.Data(o.ID[:20])
	e.String(o.Name)
	e.Uint32(uint32(len(o.Accesses)))
	for i := range o.Accesses {
		curr := &o.Accesses[i]
		e.Uint64(*curr)
	}
}
func doDecodeResourceInfo(d binary.Reader, o *ResourceInfo) {
	d.Data(o.ID[:20])
	o.Name = string(d.String())
	if count := d.Count(); count > 0 {
		o.Accesses = make([]uint64, count)
		for i := range o.Accesses {
			curr := &o.Accesses[i]
			*curr = uint64(d.Uint64())
		}
	}
}
func (*binaryClassResourceInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResourceInfo(e, obj.(*ResourceInfo))
}
func (*binaryClassResourceInfo) New() binary.Object {
	return &ResourceInfo{}
}
func (*binaryClassResourceInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResourceInfo(d, obj.(*ResourceInfo))
}
func (o *ResourceInfo) WriteSimple(w binary.Writer) {
	doEncodeResourceInfo(w, o)
}
func (o *ResourceInfo) ReadSimple(r binary.Reader) {
	doDecodeResourceInfo(r, o)
}
func (c *binaryClassResourceInfo) Schema() *binary.Entity {
	return &entities[ixǁResourceInfo]
}

type binaryClassResources struct{}

func (*Resources) Class() binary.Class {
	return (*binaryClassResources)(nil)
}
func doEncodeResources(e binary.Encoder, o *Resources) {
	e.Uint32(uint32(len(o.Textures1D)))
	for i := range o.Textures1D {
		curr := &o.Textures1D[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Textures2D)))
	for i := range o.Textures2D {
		curr := &o.Textures2D[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Textures3D)))
	for i := range o.Textures3D {
		curr := &o.Textures3D[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Cubemaps)))
	for i := range o.Cubemaps {
		curr := &o.Cubemaps[i]
		e.Simple(&(*curr))
	}
}
func doDecodeResources(d binary.Decoder, o *Resources) {
	if count := d.Count(); count > 0 {
		o.Textures1D = make([]ResourceInfo, count)
		for i := range o.Textures1D {
			curr := &o.Textures1D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Textures2D = make([]ResourceInfo, count)
		for i := range o.Textures2D {
			curr := &o.Textures2D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Textures3D = make([]ResourceInfo, count)
		for i := range o.Textures3D {
			curr := &o.Textures3D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Cubemaps = make([]ResourceInfo, count)
		for i := range o.Cubemaps {
			curr := &o.Cubemaps[i]
			d.Simple(&(*curr))
		}
	}
}
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 binaryClassTimingInfo struct{}

func (*TimingInfo) Class() binary.Class {
	return (*binaryClassTimingInfo)(nil)
}
func doEncodeTimingInfo(e binary.Writer, o *TimingInfo) {
	e.Uint32(uint32(len(o.PerCommand)))
	for i := range o.PerCommand {
		curr := &o.PerCommand[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.PerDrawCall)))
	for i := range o.PerDrawCall {
		curr := &o.PerDrawCall[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.PerFrame)))
	for i := range o.PerFrame {
		curr := &o.PerFrame[i]
		e.Simple(&(*curr))
	}
}
func doDecodeTimingInfo(d binary.Reader, o *TimingInfo) {
	if count := d.Count(); count > 0 {
		o.PerCommand = make([]AtomTimer, count)
		for i := range o.PerCommand {
			curr := &o.PerCommand[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.PerDrawCall = make([]AtomRangeTimer, count)
		for i := range o.PerDrawCall {
			curr := &o.PerDrawCall[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.PerFrame = make([]AtomRangeTimer, count)
		for i := range o.PerFrame {
			curr := &o.PerFrame[i]
			d.Simple(&(*curr))
		}
	}
}
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 binaryClasscallBeginCPUProfile struct{}

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

type binaryClasscallEndCPUProfile struct{}

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

type binaryClasscallFollow struct{}

func (*callFollow) Class() binary.Class {
	return (*binaryClasscallFollow)(nil)
}
func doEncodecallFollow(e binary.Encoder, o *callFollow) {
	e.Object(o.p)
}
func doDecodecallFollow(d binary.Decoder, o *callFollow) {
	o.p = path.PathCast(d.Object())
}
func (*binaryClasscallFollow) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallFollow(e, obj.(*callFollow))
}
func (*binaryClasscallFollow) New() binary.Object {
	return &callFollow{}
}
func (*binaryClasscallFollow) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallFollow(d, obj.(*callFollow))
}
func (c *binaryClasscallFollow) Schema() *binary.Entity {
	return &entities[ixǁcallFollow]
}

type binaryClasscallGet struct{}

func (*callGet) Class() binary.Class {
	return (*binaryClasscallGet)(nil)
}
func doEncodecallGet(e binary.Encoder, o *callGet) {
	e.Object(o.p)
}
func doDecodecallGet(d binary.Decoder, o *callGet) {
	o.p = path.PathCast(d.Object())
}
func (*binaryClasscallGet) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGet(e, obj.(*callGet))
}
func (*binaryClasscallGet) New() binary.Object {
	return &callGet{}
}
func (*binaryClasscallGet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGet(d, obj.(*callGet))
}
func (c *binaryClasscallGet) Schema() *binary.Entity {
	return &entities[ixǁcallGet]
}

type binaryClasscallGetAvailableStringTables struct{}

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

type binaryClasscallGetCaptures struct{}

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

type binaryClasscallGetDevices struct{}

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

type binaryClasscallGetFeatures struct{}

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

type binaryClasscallGetFramebufferColor struct{}

func (*callGetFramebufferColor) Class() binary.Class {
	return (*binaryClasscallGetFramebufferColor)(nil)
}
func doEncodecallGetFramebufferColor(e binary.Encoder, o *callGetFramebufferColor) {
	if o.device != nil {
		e.Object(o.device)
	} else {
		e.Object(nil)
	}
	if o.after != nil {
		e.Object(o.after)
	} else {
		e.Object(nil)
	}
	e.Simple(&o.settings)
}
func doDecodecallGetFramebufferColor(d binary.Decoder, o *callGetFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
	d.Simple(&o.settings)
}
func (*binaryClasscallGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetFramebufferColor(e, obj.(*callGetFramebufferColor))
}
func (*binaryClasscallGetFramebufferColor) New() binary.Object {
	return &callGetFramebufferColor{}
}
func (*binaryClasscallGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetFramebufferColor(d, obj.(*callGetFramebufferColor))
}
func (c *binaryClasscallGetFramebufferColor) Schema() *binary.Entity {
	return &entities[ixǁcallGetFramebufferColor]
}

type binaryClasscallGetFramebufferDepth struct{}

func (*callGetFramebufferDepth) Class() binary.Class {
	return (*binaryClasscallGetFramebufferDepth)(nil)
}
func doEncodecallGetFramebufferDepth(e binary.Encoder, o *callGetFramebufferDepth) {
	if o.device != nil {
		e.Object(o.device)
	} else {
		e.Object(nil)
	}
	if o.after != nil {
		e.Object(o.after)
	} else {
		e.Object(nil)
	}
}
func doDecodecallGetFramebufferDepth(d binary.Decoder, o *callGetFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
}
func (*binaryClasscallGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetFramebufferDepth(e, obj.(*callGetFramebufferDepth))
}
func (*binaryClasscallGetFramebufferDepth) New() binary.Object {
	return &callGetFramebufferDepth{}
}
func (*binaryClasscallGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetFramebufferDepth(d, obj.(*callGetFramebufferDepth))
}
func (c *binaryClasscallGetFramebufferDepth) Schema() *binary.Entity {
	return &entities[ixǁcallGetFramebufferDepth]
}

type binaryClasscallGetSchema struct{}

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

type binaryClasscallGetStringTable struct{}

func (*callGetStringTable) Class() binary.Class {
	return (*binaryClasscallGetStringTable)(nil)
}
func doEncodecallGetStringTable(e binary.Writer, o *callGetStringTable) {
	e.Simple(&o.info)
}
func doDecodecallGetStringTable(d binary.Reader, o *callGetStringTable) {
	d.Simple(&o.info)
}
func (*binaryClasscallGetStringTable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetStringTable(e, obj.(*callGetStringTable))
}
func (*binaryClasscallGetStringTable) New() binary.Object {
	return &callGetStringTable{}
}
func (*binaryClasscallGetStringTable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetStringTable(d, obj.(*callGetStringTable))
}
func (o *callGetStringTable) WriteSimple(w binary.Writer) {
	doEncodecallGetStringTable(w, o)
}
func (o *callGetStringTable) ReadSimple(r binary.Reader) {
	doDecodecallGetStringTable(r, o)
}
func (c *binaryClasscallGetStringTable) Schema() *binary.Entity {
	return &entities[ixǁcallGetStringTable]
}

type binaryClasscallGetTimingInfo struct{}

func (*callGetTimingInfo) Class() binary.Class {
	return (*binaryClasscallGetTimingInfo)(nil)
}
func doEncodecallGetTimingInfo(e binary.Encoder, o *callGetTimingInfo) {
	if o.device != nil {
		e.Object(o.device)
	} else {
		e.Object(nil)
	}
	if o.capture != nil {
		e.Object(o.capture)
	} else {
		e.Object(nil)
	}
	e.Int32(int32(o.flags))
}
func doDecodecallGetTimingInfo(d binary.Decoder, o *callGetTimingInfo) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.capture = obj.(*path.Capture)
	} else {
		o.capture = nil
	}
	o.flags = TimingFlags(d.Int32())
}
func (*binaryClasscallGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetTimingInfo(e, obj.(*callGetTimingInfo))
}
func (*binaryClasscallGetTimingInfo) New() binary.Object {
	return &callGetTimingInfo{}
}
func (*binaryClasscallGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetTimingInfo(d, obj.(*callGetTimingInfo))
}
func (c *binaryClasscallGetTimingInfo) Schema() *binary.Entity {
	return &entities[ixǁcallGetTimingInfo]
}

type binaryClasscallImportCapture struct{}

func (*callImportCapture) Class() binary.Class {
	return (*binaryClasscallImportCapture)(nil)
}
func doEncodecallImportCapture(e binary.Writer, o *callImportCapture) {
	e.String(o.name)
	e.Uint32(uint32(len(o.Data)))
	e.Data(o.Data)
}
func doDecodecallImportCapture(d binary.Reader, o *callImportCapture) {
	o.name = string(d.String())
	if count := d.Count(); count > 0 {
		o.Data = make([]uint8, count)
		d.Data(o.Data)
	}
}
func (*binaryClasscallImportCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallImportCapture(e, obj.(*callImportCapture))
}
func (*binaryClasscallImportCapture) New() binary.Object {
	return &callImportCapture{}
}
func (*binaryClasscallImportCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallImportCapture(d, obj.(*callImportCapture))
}
func (o *callImportCapture) WriteSimple(w binary.Writer) {
	doEncodecallImportCapture(w, o)
}
func (o *callImportCapture) ReadSimple(r binary.Reader) {
	doDecodecallImportCapture(r, o)
}
func (c *binaryClasscallImportCapture) Schema() *binary.Entity {
	return &entities[ixǁcallImportCapture]
}

type binaryClasscallLoadCapture struct{}

func (*callLoadCapture) Class() binary.Class {
	return (*binaryClasscallLoadCapture)(nil)
}
func doEncodecallLoadCapture(e binary.Writer, o *callLoadCapture) {
	e.String(o.path)
}
func doDecodecallLoadCapture(d binary.Reader, o *callLoadCapture) {
	o.path = string(d.String())
}
func (*binaryClasscallLoadCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallLoadCapture(e, obj.(*callLoadCapture))
}
func (*binaryClasscallLoadCapture) New() binary.Object {
	return &callLoadCapture{}
}
func (*binaryClasscallLoadCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallLoadCapture(d, obj.(*callLoadCapture))
}
func (o *callLoadCapture) WriteSimple(w binary.Writer) {
	doEncodecallLoadCapture(w, o)
}
func (o *callLoadCapture) ReadSimple(r binary.Reader) {
	doDecodecallLoadCapture(r, o)
}
func (c *binaryClasscallLoadCapture) Schema() *binary.Entity {
	return &entities[ixǁcallLoadCapture]
}

type binaryClasscallSet struct{}

func (*callSet) Class() binary.Class {
	return (*binaryClasscallSet)(nil)
}
func doEncodecallSet(e binary.Encoder, o *callSet) {
	e.Object(o.p)
	schema.Any{}.EncodeValue(e, o.v)
}
func doDecodecallSet(d binary.Decoder, o *callSet) {
	o.p = path.PathCast(d.Object())
	o.v = schema.Any{}.DecodeValue(d)
}
func (*binaryClasscallSet) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallSet(e, obj.(*callSet))
}
func (*binaryClasscallSet) New() binary.Object {
	return &callSet{}
}
func (*binaryClasscallSet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallSet(d, obj.(*callSet))
}
func (c *binaryClasscallSet) Schema() *binary.Entity {
	return &entities[ixǁcallSet]
}

type binaryClassresultBeginCPUProfile struct{}

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

type binaryClassresultEndCPUProfile struct{}

func (*resultEndCPUProfile) Class() binary.Class {
	return (*binaryClassresultEndCPUProfile)(nil)
}
func doEncoderesultEndCPUProfile(e binary.Writer, o *resultEndCPUProfile) {
	e.Uint32(uint32(len(o.value)))
	e.Data(o.value)
}
func doDecoderesultEndCPUProfile(d binary.Reader, o *resultEndCPUProfile) {
	if count := d.Count(); count > 0 {
		o.value = make([]byte, count)
		d.Data(o.value)
	}
}
func (*binaryClassresultEndCPUProfile) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultEndCPUProfile(e, obj.(*resultEndCPUProfile))
}
func (*binaryClassresultEndCPUProfile) New() binary.Object {
	return &resultEndCPUProfile{}
}
func (*binaryClassresultEndCPUProfile) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultEndCPUProfile(d, obj.(*resultEndCPUProfile))
}
func (o *resultEndCPUProfile) WriteSimple(w binary.Writer) {
	doEncoderesultEndCPUProfile(w, o)
}
func (o *resultEndCPUProfile) ReadSimple(r binary.Reader) {
	doDecoderesultEndCPUProfile(r, o)
}
func (c *binaryClassresultEndCPUProfile) Schema() *binary.Entity {
	return &entities[ixǁresultEndCPUProfile]
}

type binaryClassresultFollow struct{}

func (*resultFollow) Class() binary.Class {
	return (*binaryClassresultFollow)(nil)
}
func doEncoderesultFollow(e binary.Encoder, o *resultFollow) {
	e.Object(o.value)
}
func doDecoderesultFollow(d binary.Decoder, o *resultFollow) {
	o.value = path.PathCast(d.Object())
}
func (*binaryClassresultFollow) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultFollow(e, obj.(*resultFollow))
}
func (*binaryClassresultFollow) New() binary.Object {
	return &resultFollow{}
}
func (*binaryClassresultFollow) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultFollow(d, obj.(*resultFollow))
}
func (c *binaryClassresultFollow) Schema() *binary.Entity {
	return &entities[ixǁresultFollow]
}

type binaryClassresultGet struct{}

func (*resultGet) Class() binary.Class {
	return (*binaryClassresultGet)(nil)
}
func doEncoderesultGet(e binary.Encoder, o *resultGet) {
	schema.Any{}.EncodeValue(e, o.value)
}
func doDecoderesultGet(d binary.Decoder, o *resultGet) {
	o.value = schema.Any{}.DecodeValue(d)
}
func (*binaryClassresultGet) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGet(e, obj.(*resultGet))
}
func (*binaryClassresultGet) New() binary.Object {
	return &resultGet{}
}
func (*binaryClassresultGet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGet(d, obj.(*resultGet))
}
func (c *binaryClassresultGet) Schema() *binary.Entity {
	return &entities[ixǁresultGet]
}

type binaryClassresultGetAvailableStringTables struct{}

func (*resultGetAvailableStringTables) Class() binary.Class {
	return (*binaryClassresultGetAvailableStringTables)(nil)
}
func doEncoderesultGetAvailableStringTables(e binary.Writer, o *resultGetAvailableStringTables) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		e.Simple(&(*curr))
	}
}
func doDecoderesultGetAvailableStringTables(d binary.Reader, o *resultGetAvailableStringTables) {
	if count := d.Count(); count > 0 {
		o.value = make([]stringtable.Info, count)
		for i := range o.value {
			curr := &o.value[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassresultGetAvailableStringTables) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetAvailableStringTables(e, obj.(*resultGetAvailableStringTables))
}
func (*binaryClassresultGetAvailableStringTables) New() binary.Object {
	return &resultGetAvailableStringTables{}
}
func (*binaryClassresultGetAvailableStringTables) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetAvailableStringTables(d, obj.(*resultGetAvailableStringTables))
}
func (o *resultGetAvailableStringTables) WriteSimple(w binary.Writer) {
	doEncoderesultGetAvailableStringTables(w, o)
}
func (o *resultGetAvailableStringTables) ReadSimple(r binary.Reader) {
	doDecoderesultGetAvailableStringTables(r, o)
}
func (c *binaryClassresultGetAvailableStringTables) Schema() *binary.Entity {
	return &entities[ixǁresultGetAvailableStringTables]
}

type binaryClassresultGetCaptures struct{}

func (*resultGetCaptures) Class() binary.Class {
	return (*binaryClassresultGetCaptures)(nil)
}
func doEncoderesultGetCaptures(e binary.Encoder, o *resultGetCaptures) {
	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 doDecoderesultGetCaptures(d binary.Decoder, o *resultGetCaptures) {
	if count := d.Count(); count > 0 {
		o.value = make([]*path.Capture, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*path.Capture)
			} else {
				*curr = nil
			}
		}
	}
}
func (*binaryClassresultGetCaptures) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetCaptures(e, obj.(*resultGetCaptures))
}
func (*binaryClassresultGetCaptures) New() binary.Object {
	return &resultGetCaptures{}
}
func (*binaryClassresultGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetCaptures(d, obj.(*resultGetCaptures))
}
func (c *binaryClassresultGetCaptures) Schema() *binary.Entity {
	return &entities[ixǁresultGetCaptures]
}

type binaryClassresultGetDevices struct{}

func (*resultGetDevices) Class() binary.Class {
	return (*binaryClassresultGetDevices)(nil)
}
func doEncoderesultGetDevices(e binary.Encoder, o *resultGetDevices) {
	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 doDecoderesultGetDevices(d binary.Decoder, o *resultGetDevices) {
	if count := d.Count(); count > 0 {
		o.value = make([]*path.Device, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*path.Device)
			} else {
				*curr = nil
			}
		}
	}
}
func (*binaryClassresultGetDevices) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetDevices(e, obj.(*resultGetDevices))
}
func (*binaryClassresultGetDevices) New() binary.Object {
	return &resultGetDevices{}
}
func (*binaryClassresultGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetDevices(d, obj.(*resultGetDevices))
}
func (c *binaryClassresultGetDevices) Schema() *binary.Entity {
	return &entities[ixǁresultGetDevices]
}

type binaryClassresultGetFeatures struct{}

func (*resultGetFeatures) Class() binary.Class {
	return (*binaryClassresultGetFeatures)(nil)
}
func doEncoderesultGetFeatures(e binary.Writer, o *resultGetFeatures) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		e.String(*curr)
	}
}
func doDecoderesultGetFeatures(d binary.Reader, o *resultGetFeatures) {
	if count := d.Count(); count > 0 {
		o.value = make([]string, count)
		for i := range o.value {
			curr := &o.value[i]
			*curr = string(d.String())
		}
	}
}
func (*binaryClassresultGetFeatures) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFeatures(e, obj.(*resultGetFeatures))
}
func (*binaryClassresultGetFeatures) New() binary.Object {
	return &resultGetFeatures{}
}
func (*binaryClassresultGetFeatures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFeatures(d, obj.(*resultGetFeatures))
}
func (o *resultGetFeatures) WriteSimple(w binary.Writer) {
	doEncoderesultGetFeatures(w, o)
}
func (o *resultGetFeatures) ReadSimple(r binary.Reader) {
	doDecoderesultGetFeatures(r, o)
}
func (c *binaryClassresultGetFeatures) Schema() *binary.Entity {
	return &entities[ixǁresultGetFeatures]
}

type binaryClassresultGetFramebufferColor struct{}

func (*resultGetFramebufferColor) Class() binary.Class {
	return (*binaryClassresultGetFramebufferColor)(nil)
}
func doEncoderesultGetFramebufferColor(e binary.Encoder, o *resultGetFramebufferColor) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetFramebufferColor(d binary.Decoder, o *resultGetFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFramebufferColor(e, obj.(*resultGetFramebufferColor))
}
func (*binaryClassresultGetFramebufferColor) New() binary.Object {
	return &resultGetFramebufferColor{}
}
func (*binaryClassresultGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFramebufferColor(d, obj.(*resultGetFramebufferColor))
}
func (c *binaryClassresultGetFramebufferColor) Schema() *binary.Entity {
	return &entities[ixǁresultGetFramebufferColor]
}

type binaryClassresultGetFramebufferDepth struct{}

func (*resultGetFramebufferDepth) Class() binary.Class {
	return (*binaryClassresultGetFramebufferDepth)(nil)
}
func doEncoderesultGetFramebufferDepth(e binary.Encoder, o *resultGetFramebufferDepth) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetFramebufferDepth(d binary.Decoder, o *resultGetFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFramebufferDepth(e, obj.(*resultGetFramebufferDepth))
}
func (*binaryClassresultGetFramebufferDepth) New() binary.Object {
	return &resultGetFramebufferDepth{}
}
func (*binaryClassresultGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFramebufferDepth(d, obj.(*resultGetFramebufferDepth))
}
func (c *binaryClassresultGetFramebufferDepth) Schema() *binary.Entity {
	return &entities[ixǁresultGetFramebufferDepth]
}

type binaryClassresultGetSchema struct{}

func (*resultGetSchema) Class() binary.Class {
	return (*binaryClassresultGetSchema)(nil)
}
func doEncoderesultGetSchema(e binary.Encoder, o *resultGetSchema) {
	e.Struct(&o.value)
}
func doDecoderesultGetSchema(d binary.Decoder, o *resultGetSchema) {
	d.Struct(&o.value)
}
func (*binaryClassresultGetSchema) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetSchema(e, obj.(*resultGetSchema))
}
func (*binaryClassresultGetSchema) New() binary.Object {
	return &resultGetSchema{}
}
func (*binaryClassresultGetSchema) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetSchema(d, obj.(*resultGetSchema))
}
func (c *binaryClassresultGetSchema) Schema() *binary.Entity {
	return &entities[ixǁresultGetSchema]
}

type binaryClassresultGetStringTable struct{}

func (*resultGetStringTable) Class() binary.Class {
	return (*binaryClassresultGetStringTable)(nil)
}
func doEncoderesultGetStringTable(e binary.Encoder, o *resultGetStringTable) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetStringTable(d binary.Decoder, o *resultGetStringTable) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*stringtable.StringTable)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetStringTable) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetStringTable(e, obj.(*resultGetStringTable))
}
func (*binaryClassresultGetStringTable) New() binary.Object {
	return &resultGetStringTable{}
}
func (*binaryClassresultGetStringTable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetStringTable(d, obj.(*resultGetStringTable))
}
func (c *binaryClassresultGetStringTable) Schema() *binary.Entity {
	return &entities[ixǁresultGetStringTable]
}

type binaryClassresultGetTimingInfo struct{}

func (*resultGetTimingInfo) Class() binary.Class {
	return (*binaryClassresultGetTimingInfo)(nil)
}
func doEncoderesultGetTimingInfo(e binary.Encoder, o *resultGetTimingInfo) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetTimingInfo(d binary.Decoder, o *resultGetTimingInfo) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.TimingInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetTimingInfo(e, obj.(*resultGetTimingInfo))
}
func (*binaryClassresultGetTimingInfo) New() binary.Object {
	return &resultGetTimingInfo{}
}
func (*binaryClassresultGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetTimingInfo(d, obj.(*resultGetTimingInfo))
}
func (c *binaryClassresultGetTimingInfo) Schema() *binary.Entity {
	return &entities[ixǁresultGetTimingInfo]
}

type binaryClassresultImportCapture struct{}

func (*resultImportCapture) Class() binary.Class {
	return (*binaryClassresultImportCapture)(nil)
}
func doEncoderesultImportCapture(e binary.Encoder, o *resultImportCapture) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultImportCapture(d binary.Decoder, o *resultImportCapture) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultImportCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultImportCapture(e, obj.(*resultImportCapture))
}
func (*binaryClassresultImportCapture) New() binary.Object {
	return &resultImportCapture{}
}
func (*binaryClassresultImportCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultImportCapture(d, obj.(*resultImportCapture))
}
func (c *binaryClassresultImportCapture) Schema() *binary.Entity {
	return &entities[ixǁresultImportCapture]
}

type binaryClassresultLoadCapture struct{}

func (*resultLoadCapture) Class() binary.Class {
	return (*binaryClassresultLoadCapture)(nil)
}
func doEncoderesultLoadCapture(e binary.Encoder, o *resultLoadCapture) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultLoadCapture(d binary.Decoder, o *resultLoadCapture) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultLoadCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultLoadCapture(e, obj.(*resultLoadCapture))
}
func (*binaryClassresultLoadCapture) New() binary.Object {
	return &resultLoadCapture{}
}
func (*binaryClassresultLoadCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultLoadCapture(d, obj.(*resultLoadCapture))
}
func (c *binaryClassresultLoadCapture) Schema() *binary.Entity {
	return &entities[ixǁresultLoadCapture]
}

type binaryClassresultSet struct{}

func (*resultSet) Class() binary.Class {
	return (*binaryClassresultSet)(nil)
}
func doEncoderesultSet(e binary.Encoder, o *resultSet) {
	e.Object(o.value)
}
func doDecoderesultSet(d binary.Decoder, o *resultSet) {
	o.value = path.PathCast(d.Object())
}
func (*binaryClassresultSet) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultSet(e, obj.(*resultSet))
}
func (*binaryClassresultSet) New() binary.Object {
	return &resultSet{}
}
func (*binaryClassresultSet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultSet(d, obj.(*resultSet))
}
func (c *binaryClassresultSet) Schema() *binary.Entity {
	return &entities[ixǁresultSet]
}