service/service_binary.go

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

package service

import (
	"fmt"

	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/binary/any"
	"android.googlesource.com/platform/tools/gpu/binary/registry"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
	"android.googlesource.com/platform/tools/gpu/image"
	"android.googlesource.com/platform/tools/gpu/log"
	"android.googlesource.com/platform/tools/gpu/memory"
	"android.googlesource.com/platform/tools/gpu/service/path"
)

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.Add((*AtomRangeTimer)(nil).Class())
	Namespace.Add((*AtomTimer)(nil).Class())
	Namespace.Add((*Capture)(nil).Class())
	Namespace.Add((*Device)(nil).Class())
	Namespace.Add((*ImageInfo)(nil).Class())
	Namespace.Add((*MemoryInfo)(nil).Class())
	Namespace.Add((*RenderSettings)(nil).Class())
	Namespace.Add((*ReportItem)(nil).Class())
	Namespace.Add((*Report)(nil).Class())
	Namespace.Add((*Schema)(nil).Class())
	Namespace.Add((*TimingInfo)(nil).Class())
	Namespace.Add((*callFollow)(nil).Class())
	Namespace.Add((*callGet)(nil).Class())
	Namespace.Add((*callGetCaptures)(nil).Class())
	Namespace.Add((*callGetDevices)(nil).Class())
	Namespace.Add((*callGetFramebufferColor)(nil).Class())
	Namespace.Add((*callGetFramebufferDepth)(nil).Class())
	Namespace.Add((*callGetSchema)(nil).Class())
	Namespace.Add((*callGetTimingInfo)(nil).Class())
	Namespace.Add((*callImport)(nil).Class())
	Namespace.Add((*callPrerenderFramebuffers)(nil).Class())
	Namespace.Add((*callSet)(nil).Class())
	Namespace.Add((*resultFollow)(nil).Class())
	Namespace.Add((*resultGet)(nil).Class())
	Namespace.Add((*resultGetCaptures)(nil).Class())
	Namespace.Add((*resultGetDevices)(nil).Class())
	Namespace.Add((*resultGetFramebufferColor)(nil).Class())
	Namespace.Add((*resultGetFramebufferDepth)(nil).Class())
	Namespace.Add((*resultGetSchema)(nil).Class())
	Namespace.Add((*resultGetTimingInfo)(nil).Class())
	Namespace.Add((*resultImport)(nil).Class())
	Namespace.Add((*resultPrerenderFramebuffers)(nil).Class())
	Namespace.Add((*resultSet)(nil).Class())
}

var (
	binaryIDAtomRangeTimer              = binary.ID{0x2a, 0x69, 0xe8, 0xa2, 0x17, 0xc3, 0x2d, 0xe8, 0x4e, 0x9c, 0x00, 0x01, 0x5b, 0x63, 0xde, 0xb4, 0xf1, 0xf6, 0x27, 0x64}
	binaryIDAtomTimer                   = binary.ID{0xa9, 0xad, 0x32, 0xa8, 0xd8, 0xa8, 0xc3, 0xff, 0x44, 0x94, 0x47, 0xd3, 0xaa, 0xd2, 0xce, 0x8f, 0x70, 0xc6, 0xc6, 0x04}
	binaryIDCapture                     = binary.ID{0x53, 0x83, 0xdc, 0x37, 0x1e, 0x26, 0x9f, 0xb9, 0xc9, 0xf8, 0x6f, 0x4b, 0x42, 0x3b, 0xcd, 0xbc, 0x01, 0x83, 0x76, 0xe2}
	binaryIDDevice                      = binary.ID{0x54, 0xf6, 0x8f, 0x5c, 0xcc, 0xe5, 0x1e, 0x5e, 0x3a, 0xa5, 0x96, 0xa9, 0xc7, 0x60, 0x03, 0x51, 0x67, 0x38, 0x4f, 0x51}
	binaryIDImageInfo                   = binary.ID{0x2d, 0xaa, 0x5c, 0x7f, 0x36, 0x92, 0xad, 0xf2, 0x8d, 0xfc, 0xc0, 0x47, 0x69, 0x59, 0x60, 0xcc, 0xdd, 0x06, 0xf1, 0xa6}
	binaryIDMemoryInfo                  = binary.ID{0xd0, 0x51, 0x4d, 0xc0, 0xeb, 0xf4, 0xbb, 0x6d, 0x46, 0xfa, 0x3e, 0x02, 0x94, 0x84, 0xcc, 0x9f, 0x82, 0xc9, 0xc4, 0x9e}
	binaryIDRenderSettings              = binary.ID{0xf8, 0x94, 0x85, 0x1d, 0x97, 0x54, 0x1c, 0xb7, 0x82, 0x93, 0x7a, 0x28, 0x65, 0xe7, 0x55, 0x95, 0x4d, 0x89, 0x7a, 0x02}
	binaryIDReportItem                  = binary.ID{0x8a, 0xb2, 0x14, 0x6f, 0x40, 0xb0, 0x0b, 0x10, 0xa9, 0x02, 0xfb, 0xa1, 0x76, 0x1a, 0xe9, 0xd7, 0x9c, 0x62, 0x40, 0x93}
	binaryIDReport                      = binary.ID{0xc3, 0xd0, 0x8a, 0x62, 0x38, 0x91, 0xba, 0x62, 0xc8, 0x4b, 0x71, 0x55, 0x78, 0x58, 0x73, 0xd4, 0x06, 0x52, 0x71, 0x15}
	binaryIDSchema                      = binary.ID{0x74, 0xe2, 0x21, 0xf1, 0x49, 0x8f, 0x1b, 0x90, 0xf3, 0x8b, 0xe8, 0x56, 0xef, 0xbf, 0x17, 0x79, 0xdf, 0xfc, 0x38, 0x25}
	binaryIDTimingInfo                  = binary.ID{0xf8, 0xfe, 0x88, 0x50, 0x3d, 0x72, 0xb3, 0x55, 0xb0, 0x01, 0x73, 0xfe, 0x8a, 0x82, 0xbd, 0x1e, 0xb7, 0xc9, 0x5b, 0xb1}
	binaryIDcallFollow                  = binary.ID{0xe1, 0x2c, 0x0d, 0x00, 0xd2, 0x83, 0xe0, 0xd5, 0x61, 0xf9, 0x0f, 0xce, 0xfe, 0xb7, 0x3a, 0x65, 0x6d, 0x3e, 0xb9, 0x8e}
	binaryIDcallGet                     = binary.ID{0x5c, 0xaa, 0xed, 0xc9, 0xd2, 0x90, 0xe7, 0xb2, 0xae, 0x34, 0x5d, 0x9f, 0x32, 0x67, 0x6c, 0x27, 0xc6, 0x0e, 0x33, 0x96}
	binaryIDcallGetCaptures             = binary.ID{0xb0, 0x2f, 0x3d, 0xa5, 0x85, 0x95, 0xf4, 0x21, 0x20, 0x76, 0xa8, 0xa6, 0x5a, 0x53, 0x9f, 0xfc, 0xd8, 0x10, 0xdb, 0x15}
	binaryIDcallGetDevices              = binary.ID{0x19, 0x14, 0x64, 0x05, 0xf6, 0xad, 0x8d, 0x48, 0xc3, 0x8e, 0x7b, 0xc8, 0x18, 0x5b, 0x2f, 0x7c, 0xb7, 0x9f, 0x5c, 0x73}
	binaryIDcallGetFramebufferColor     = binary.ID{0xb3, 0x38, 0x68, 0x8d, 0x4f, 0xfa, 0x98, 0x22, 0x57, 0xe0, 0x73, 0x90, 0xa7, 0x07, 0x5a, 0x5d, 0xb5, 0x01, 0xfa, 0xe1}
	binaryIDcallGetFramebufferDepth     = binary.ID{0x96, 0x26, 0xb8, 0x24, 0x39, 0x5b, 0xc4, 0x53, 0xd4, 0xfd, 0x0d, 0xa3, 0x54, 0xbc, 0xfa, 0x78, 0xaf, 0xd2, 0xf6, 0x9d}
	binaryIDcallGetSchema               = binary.ID{0x5f, 0xfd, 0x99, 0xc4, 0x18, 0x36, 0x9a, 0x3f, 0xc8, 0x69, 0xe8, 0xd0, 0xf4, 0xfa, 0x16, 0xc4, 0xfc, 0xea, 0x0c, 0xc2}
	binaryIDcallGetTimingInfo           = binary.ID{0x00, 0xed, 0x86, 0x08, 0xac, 0xd7, 0xd9, 0x7d, 0x3f, 0xf4, 0x38, 0xf4, 0xb3, 0xde, 0xc8, 0x9b, 0xd6, 0xc9, 0xc2, 0xb0}
	binaryIDcallImport                  = binary.ID{0xa8, 0x48, 0x6d, 0xd8, 0xc4, 0xf4, 0x48, 0x53, 0xc4, 0x74, 0xb1, 0xcf, 0xad, 0x37, 0xca, 0x5b, 0x1e, 0xfd, 0x1a, 0xb3}
	binaryIDcallPrerenderFramebuffers   = binary.ID{0xce, 0xd0, 0x43, 0x9a, 0x0a, 0x96, 0xbd, 0x47, 0xe1, 0x4e, 0x08, 0xf0, 0x67, 0x37, 0x96, 0x84, 0x1a, 0x06, 0xb0, 0xfc}
	binaryIDcallSet                     = binary.ID{0xb7, 0x80, 0x14, 0xe1, 0x84, 0xb1, 0x09, 0xb2, 0xff, 0x7e, 0x86, 0xb8, 0x71, 0x35, 0xce, 0xcf, 0xa2, 0xa5, 0x0d, 0xf9}
	binaryIDresultFollow                = binary.ID{0x9b, 0xd0, 0xad, 0xb0, 0x41, 0x98, 0x0d, 0xf5, 0x6e, 0x07, 0xe3, 0x9b, 0xc2, 0x03, 0x48, 0xfa, 0xca, 0xef, 0x4a, 0xb3}
	binaryIDresultGet                   = binary.ID{0xa5, 0xb7, 0xa2, 0xb7, 0x3b, 0x2f, 0x10, 0xc9, 0xf7, 0x8c, 0xe8, 0xdd, 0x9c, 0x60, 0x5d, 0x65, 0x54, 0x2d, 0xde, 0x29}
	binaryIDresultGetCaptures           = binary.ID{0x14, 0x96, 0x06, 0x2f, 0x82, 0x18, 0x13, 0xf0, 0x93, 0x27, 0x63, 0x81, 0x7f, 0x8b, 0x35, 0xc4, 0x37, 0x2f, 0x76, 0x4e}
	binaryIDresultGetDevices            = binary.ID{0x33, 0xf5, 0xb9, 0xd1, 0x24, 0x9d, 0x0d, 0x9f, 0x2c, 0x00, 0x4f, 0xed, 0xd6, 0x2f, 0x76, 0xa8, 0x76, 0x74, 0x3c, 0x09}
	binaryIDresultGetFramebufferColor   = binary.ID{0xc2, 0x21, 0x36, 0xf1, 0xf5, 0xd9, 0x4f, 0x63, 0x51, 0x79, 0x9a, 0xc1, 0xb2, 0x2f, 0x0c, 0xe4, 0x52, 0x50, 0xf2, 0xac}
	binaryIDresultGetFramebufferDepth   = binary.ID{0xeb, 0x6a, 0x50, 0x23, 0x07, 0x9f, 0xe3, 0x4d, 0xa1, 0x83, 0x1e, 0xe8, 0x1b, 0x77, 0x9e, 0x69, 0x5f, 0xd7, 0x5c, 0x9c}
	binaryIDresultGetSchema             = binary.ID{0xd0, 0x54, 0xb1, 0x58, 0x23, 0xd7, 0x0d, 0x2b, 0x65, 0xee, 0xcc, 0x2a, 0xb8, 0x12, 0x27, 0x6c, 0x8f, 0xcd, 0x75, 0x8a}
	binaryIDresultGetTimingInfo         = binary.ID{0xb0, 0x3b, 0x55, 0xec, 0xe2, 0xf1, 0x87, 0x15, 0x8c, 0x11, 0x5d, 0x12, 0x3a, 0xc7, 0x1f, 0x7f, 0xfd, 0xe9, 0x20, 0xd3}
	binaryIDresultImport                = binary.ID{0x25, 0x0d, 0x7b, 0xc7, 0x15, 0xd0, 0x88, 0x75, 0x71, 0xf0, 0xe4, 0x79, 0x84, 0xd9, 0xb8, 0xe8, 0x98, 0x27, 0x33, 0xa4}
	binaryIDresultPrerenderFramebuffers = binary.ID{0x57, 0xca, 0x1f, 0x8b, 0x4a, 0x3b, 0x6c, 0xf8, 0xeb, 0xe0, 0x5a, 0xd8, 0xe4, 0x8b, 0x24, 0xbe, 0x6f, 0x61, 0x65, 0xd0}
	binaryIDresultSet                   = binary.ID{0x86, 0x91, 0xf0, 0x3f, 0xf8, 0x37, 0xf5, 0x8d, 0x70, 0xeb, 0xc0, 0x87, 0x00, 0x9e, 0x42, 0xd4, 0x8e, 0x89, 0xc3, 0xdb}
)

type binaryClassAtomRangeTimer struct{}

func (*AtomRangeTimer) Class() binary.Class {
	return (*binaryClassAtomRangeTimer)(nil)
}
func doEncodeAtomRangeTimer(e binary.Encoder, o *AtomRangeTimer) error {
	if err := e.Uint64(o.FromAtomID); err != nil {
		return err
	}
	if err := e.Uint64(o.ToAtomID); err != nil {
		return err
	}
	if err := e.Uint64(o.Nanoseconds); err != nil {
		return err
	}
	return nil
}
func doDecodeAtomRangeTimer(d binary.Decoder, o *AtomRangeTimer) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.FromAtomID = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.ToAtomID = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Nanoseconds = uint64(obj)
	}
	return nil
}
func doSkipAtomRangeTimer(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassAtomRangeTimer) ID() binary.ID      { return binaryIDAtomRangeTimer }
func (*binaryClassAtomRangeTimer) New() binary.Object { return &AtomRangeTimer{} }
func (*binaryClassAtomRangeTimer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomRangeTimer(e, obj.(*AtomRangeTimer))
}
func (*binaryClassAtomRangeTimer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomRangeTimer{}
	return obj, doDecodeAtomRangeTimer(d, obj)
}
func (*binaryClassAtomRangeTimer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomRangeTimer(d, obj.(*AtomRangeTimer))
}
func (*binaryClassAtomRangeTimer) Skip(d binary.Decoder) error { return doSkipAtomRangeTimer(d) }
func (*binaryClassAtomRangeTimer) Schema() *schema.Class       { return schemaAtomRangeTimer }

var schemaAtomRangeTimer = &schema.Class{
	TypeID:  binaryIDAtomRangeTimer,
	Package: "service",
	Name:    "AtomRangeTimer",
	Fields: []schema.Field{
		{Declared: "FromAtomID", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "ToAtomID", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "Nanoseconds", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassAtomTimer struct{}

func (*AtomTimer) Class() binary.Class {
	return (*binaryClassAtomTimer)(nil)
}
func doEncodeAtomTimer(e binary.Encoder, o *AtomTimer) error {
	if err := e.Uint64(o.AtomID); err != nil {
		return err
	}
	if err := e.Uint64(o.Nanoseconds); err != nil {
		return err
	}
	return nil
}
func doDecodeAtomTimer(d binary.Decoder, o *AtomTimer) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.AtomID = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Nanoseconds = uint64(obj)
	}
	return nil
}
func doSkipAtomTimer(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassAtomTimer) ID() binary.ID      { return binaryIDAtomTimer }
func (*binaryClassAtomTimer) New() binary.Object { return &AtomTimer{} }
func (*binaryClassAtomTimer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomTimer(e, obj.(*AtomTimer))
}
func (*binaryClassAtomTimer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomTimer{}
	return obj, doDecodeAtomTimer(d, obj)
}
func (*binaryClassAtomTimer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomTimer(d, obj.(*AtomTimer))
}
func (*binaryClassAtomTimer) Skip(d binary.Decoder) error { return doSkipAtomTimer(d) }
func (*binaryClassAtomTimer) Schema() *schema.Class       { return schemaAtomTimer }

var schemaAtomTimer = &schema.Class{
	TypeID:  binaryIDAtomTimer,
	Package: "service",
	Name:    "AtomTimer",
	Fields: []schema.Field{
		{Declared: "AtomID", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "Nanoseconds", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassCapture struct{}

func (*Capture) Class() binary.Class {
	return (*binaryClassCapture)(nil)
}
func doEncodeCapture(e binary.Encoder, o *Capture) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.ID(binary.ID(o.Atoms)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Apis))); err != nil {
		return err
	}
	for i := range o.Apis {
		if err := e.ID(binary.ID(o.Apis[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeCapture(d binary.Decoder, o *Capture) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.Atoms = AtomsID(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Apis = make([]ApiID, count)
		for i := range o.Apis {
			if obj, err := d.ID(); err != nil {
				return err
			} else {
				o.Apis[i] = ApiID(obj)
			}
		}
	}
	return nil
}
func doSkipCapture(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipID(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipID(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassCapture) ID() binary.ID      { return binaryIDCapture }
func (*binaryClassCapture) New() binary.Object { return &Capture{} }
func (*binaryClassCapture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCapture(e, obj.(*Capture))
}
func (*binaryClassCapture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Capture{}
	return obj, doDecodeCapture(d, obj)
}
func (*binaryClassCapture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCapture(d, obj.(*Capture))
}
func (*binaryClassCapture) Skip(d binary.Decoder) error { return doSkipCapture(d) }
func (*binaryClassCapture) Schema() *schema.Class       { return schemaCapture }

var schemaCapture = &schema.Class{
	TypeID:  binaryIDCapture,
	Package: "service",
	Name:    "Capture",
	Fields: []schema.Field{
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Atoms", Type: &schema.Primitive{Name: "AtomsID", Method: schema.ID}},
		{Declared: "Apis", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "ApiID", Method: schema.ID}}},
	},
}

type binaryClassDevice struct{}

func (*Device) Class() binary.Class {
	return (*binaryClassDevice)(nil)
}
func doEncodeDevice(e binary.Encoder, o *Device) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.String(o.Model); err != nil {
		return err
	}
	if err := e.String(o.OS); err != nil {
		return err
	}
	if err := e.Uint8(o.PointerSize); err != nil {
		return err
	}
	if err := e.Uint8(o.PointerAlignment); err != nil {
		return err
	}
	if err := e.Uint64(o.MaxMemorySize); err != nil {
		return err
	}
	if err := e.String(o.Extensions); err != nil {
		return err
	}
	if err := e.String(o.Renderer); err != nil {
		return err
	}
	if err := e.String(o.Vendor); err != nil {
		return err
	}
	if err := e.String(o.Version); err != nil {
		return err
	}
	return nil
}
func doDecodeDevice(d binary.Decoder, o *Device) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Model = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.OS = string(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.PointerSize = uint8(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.PointerAlignment = uint8(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.MaxMemorySize = uint64(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Extensions = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Renderer = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Vendor = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Version = string(obj)
	}
	return nil
}
func doSkipDevice(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassDevice) ID() binary.ID      { return binaryIDDevice }
func (*binaryClassDevice) New() binary.Object { return &Device{} }
func (*binaryClassDevice) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeDevice(e, obj.(*Device))
}
func (*binaryClassDevice) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Device{}
	return obj, doDecodeDevice(d, obj)
}
func (*binaryClassDevice) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeDevice(d, obj.(*Device))
}
func (*binaryClassDevice) Skip(d binary.Decoder) error { return doSkipDevice(d) }
func (*binaryClassDevice) Schema() *schema.Class       { return schemaDevice }

var schemaDevice = &schema.Class{
	TypeID:  binaryIDDevice,
	Package: "service",
	Name:    "Device",
	Fields: []schema.Field{
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Model", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "OS", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "PointerSize", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
		{Declared: "PointerAlignment", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
		{Declared: "MaxMemorySize", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "Extensions", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Renderer", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Vendor", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Version", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassImageInfo struct{}

func (*ImageInfo) Class() binary.Class {
	return (*binaryClassImageInfo)(nil)
}
func doEncodeImageInfo(e binary.Encoder, o *ImageInfo) error {
	if o.Format != nil {
		if err := e.Object(o.Format); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Uint32(o.Width); err != nil {
		return err
	}
	if err := e.Uint32(o.Height); err != nil {
		return err
	}
	if o.Data != nil {
		if err := e.Object(o.Data); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeImageInfo(d binary.Decoder, o *ImageInfo) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Format = obj.(image.Format)
	} else {
		o.Format = nil
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = uint32(obj)
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Data = obj.(*path.Blob)
	} else {
		o.Data = nil
	}
	return nil
}
func doSkipImageInfo(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassImageInfo) ID() binary.ID      { return binaryIDImageInfo }
func (*binaryClassImageInfo) New() binary.Object { return &ImageInfo{} }
func (*binaryClassImageInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeImageInfo(e, obj.(*ImageInfo))
}
func (*binaryClassImageInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ImageInfo{}
	return obj, doDecodeImageInfo(d, obj)
}
func (*binaryClassImageInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeImageInfo(d, obj.(*ImageInfo))
}
func (*binaryClassImageInfo) Skip(d binary.Decoder) error { return doSkipImageInfo(d) }
func (*binaryClassImageInfo) Schema() *schema.Class       { return schemaImageInfo }

var schemaImageInfo = &schema.Class{
	TypeID:  binaryIDImageInfo,
	Package: "service",
	Name:    "ImageInfo",
	Fields: []schema.Field{
		{Declared: "Format", Type: &schema.Interface{Name: "image.Format"}},
		{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Blob", ID: (*path.Blob)(nil).Class().ID()}}},
	},
}

type binaryClassMemoryInfo struct{}

func (*MemoryInfo) Class() binary.Class {
	return (*binaryClassMemoryInfo)(nil)
}
func doEncodeMemoryInfo(e binary.Encoder, o *MemoryInfo) error {
	if err := e.Uint32(uint32(len(o.Data))); err != nil {
		return err
	}
	if err := e.Data(o.Data); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Reads))); err != nil {
		return err
	}
	for i := range o.Reads {
		if err := e.Value(&o.Reads[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Writes))); err != nil {
		return err
	}
	for i := range o.Writes {
		if err := e.Value(&o.Writes[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Observed))); err != nil {
		return err
	}
	for i := range o.Observed {
		if err := e.Value(&o.Observed[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeMemoryInfo(d binary.Decoder, o *MemoryInfo) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Data = make([]uint8, count)
		if err := d.Data(o.Data); err != nil {
			return err
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Reads = make(memory.RangeList, count)
		for i := range o.Reads {
			if err := d.Value(&o.Reads[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Writes = make(memory.RangeList, count)
		for i := range o.Writes {
			if err := d.Value(&o.Writes[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Observed = make(memory.RangeList, count)
		for i := range o.Observed {
			if err := d.Value(&o.Observed[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipMemoryInfo(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		if err := d.Skip(count); err != nil {
			return err
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*memory.Range)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*memory.Range)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*memory.Range)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassMemoryInfo) ID() binary.ID      { return binaryIDMemoryInfo }
func (*binaryClassMemoryInfo) New() binary.Object { return &MemoryInfo{} }
func (*binaryClassMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMemoryInfo(e, obj.(*MemoryInfo))
}
func (*binaryClassMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &MemoryInfo{}
	return obj, doDecodeMemoryInfo(d, obj)
}
func (*binaryClassMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMemoryInfo(d, obj.(*MemoryInfo))
}
func (*binaryClassMemoryInfo) Skip(d binary.Decoder) error { return doSkipMemoryInfo(d) }
func (*binaryClassMemoryInfo) Schema() *schema.Class       { return schemaMemoryInfo }

var schemaMemoryInfo = &schema.Class{
	TypeID:  binaryIDMemoryInfo,
	Package: "service",
	Name:    "MemoryInfo",
	Fields: []schema.Field{
		{Declared: "Data", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}},
		{Declared: "Reads", Type: &schema.Slice{Alias: "memory.RangeList", ValueType: &schema.Struct{Name: "memory.Range", ID: (*memory.Range)(nil).Class().ID()}}},
		{Declared: "Writes", Type: &schema.Slice{Alias: "memory.RangeList", ValueType: &schema.Struct{Name: "memory.Range", ID: (*memory.Range)(nil).Class().ID()}}},
		{Declared: "Observed", Type: &schema.Slice{Alias: "memory.RangeList", ValueType: &schema.Struct{Name: "memory.Range", ID: (*memory.Range)(nil).Class().ID()}}},
	},
}

type binaryClassRenderSettings struct{}

func (*RenderSettings) Class() binary.Class {
	return (*binaryClassRenderSettings)(nil)
}
func doEncodeRenderSettings(e binary.Encoder, o *RenderSettings) error {
	if err := e.Uint32(o.MaxWidth); err != nil {
		return err
	}
	if err := e.Uint32(o.MaxHeight); err != nil {
		return err
	}
	if err := e.Int32(int32(o.WireframeMode)); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderSettings(d binary.Decoder, o *RenderSettings) error {
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MaxWidth = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MaxHeight = uint32(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.WireframeMode = WireframeMode(obj)
	}
	return nil
}
func doSkipRenderSettings(d binary.Decoder) error {
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderSettings) ID() binary.ID      { return binaryIDRenderSettings }
func (*binaryClassRenderSettings) New() binary.Object { return &RenderSettings{} }
func (*binaryClassRenderSettings) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderSettings(e, obj.(*RenderSettings))
}
func (*binaryClassRenderSettings) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderSettings{}
	return obj, doDecodeRenderSettings(d, obj)
}
func (*binaryClassRenderSettings) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderSettings(d, obj.(*RenderSettings))
}
func (*binaryClassRenderSettings) Skip(d binary.Decoder) error { return doSkipRenderSettings(d) }
func (*binaryClassRenderSettings) Schema() *schema.Class       { return schemaRenderSettings }

var schemaRenderSettings = &schema.Class{
	TypeID:  binaryIDRenderSettings,
	Package: "service",
	Name:    "RenderSettings",
	Fields: []schema.Field{
		{Declared: "MaxWidth", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "MaxHeight", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "WireframeMode", Type: &schema.Primitive{Name: "WireframeMode", Method: schema.Int32}},
	},
}

type binaryClassReportItem struct{}

func (*ReportItem) Class() binary.Class {
	return (*binaryClassReportItem)(nil)
}
func doEncodeReportItem(e binary.Encoder, o *ReportItem) error {
	if err := e.Int32(int32(o.Severity)); err != nil {
		return err
	}
	if err := e.String(o.Message); err != nil {
		return err
	}
	if err := e.Uint64(o.Atom); err != nil {
		return err
	}
	return nil
}
func doDecodeReportItem(d binary.Decoder, o *ReportItem) error {
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Severity = log.Severity(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Message = string(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Atom = uint64(obj)
	}
	return nil
}
func doSkipReportItem(d binary.Decoder) error {
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassReportItem) ID() binary.ID      { return binaryIDReportItem }
func (*binaryClassReportItem) New() binary.Object { return &ReportItem{} }
func (*binaryClassReportItem) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeReportItem(e, obj.(*ReportItem))
}
func (*binaryClassReportItem) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ReportItem{}
	return obj, doDecodeReportItem(d, obj)
}
func (*binaryClassReportItem) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeReportItem(d, obj.(*ReportItem))
}
func (*binaryClassReportItem) Skip(d binary.Decoder) error { return doSkipReportItem(d) }
func (*binaryClassReportItem) Schema() *schema.Class       { return schemaReportItem }

var schemaReportItem = &schema.Class{
	TypeID:  binaryIDReportItem,
	Package: "service",
	Name:    "ReportItem",
	Fields: []schema.Field{
		{Declared: "Severity", Type: &schema.Primitive{Name: "log.Severity", Method: schema.Int32}},
		{Declared: "Message", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Atom", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassReport struct{}

func (*Report) Class() binary.Class {
	return (*binaryClassReport)(nil)
}
func doEncodeReport(e binary.Encoder, o *Report) error {
	if err := e.Uint32(uint32(len(o.Items))); err != nil {
		return err
	}
	for i := range o.Items {
		if err := e.Value(&o.Items[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeReport(d binary.Decoder, o *Report) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Items = make([]ReportItem, count)
		for i := range o.Items {
			if err := d.Value(&o.Items[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipReport(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*ReportItem)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassReport) ID() binary.ID      { return binaryIDReport }
func (*binaryClassReport) New() binary.Object { return &Report{} }
func (*binaryClassReport) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeReport(e, obj.(*Report))
}
func (*binaryClassReport) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Report{}
	return obj, doDecodeReport(d, obj)
}
func (*binaryClassReport) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeReport(d, obj.(*Report))
}
func (*binaryClassReport) Skip(d binary.Decoder) error { return doSkipReport(d) }
func (*binaryClassReport) Schema() *schema.Class       { return schemaReport }

var schemaReport = &schema.Class{
	TypeID:  binaryIDReport,
	Package: "service",
	Name:    "Report",
	Fields: []schema.Field{
		{Declared: "Items", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "ReportItem", ID: (*ReportItem)(nil).Class().ID()}}},
	},
}

type binaryClassSchema struct{}

func (*Schema) Class() binary.Class {
	return (*binaryClassSchema)(nil)
}
func doEncodeSchema(e binary.Encoder, o *Schema) error {
	if err := e.Uint32(uint32(len(o.Classes))); err != nil {
		return err
	}
	for i := range o.Classes {
		if o.Classes[i] != nil {
			if err := e.Object(o.Classes[i]); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Constants))); err != nil {
		return err
	}
	for i := range o.Constants {
		if err := e.Value(&o.Constants[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeSchema(d binary.Decoder, o *Schema) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Classes = make([]*schema.Class, count)
		for i := range o.Classes {
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				o.Classes[i] = obj.(*schema.Class)
			} else {
				o.Classes[i] = nil
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Constants = make([]schema.ConstantSet, count)
		for i := range o.Constants {
			if err := d.Value(&o.Constants[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipSchema(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*schema.ConstantSet)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassSchema) ID() binary.ID      { return binaryIDSchema }
func (*binaryClassSchema) New() binary.Object { return &Schema{} }
func (*binaryClassSchema) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSchema(e, obj.(*Schema))
}
func (*binaryClassSchema) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Schema{}
	return obj, doDecodeSchema(d, obj)
}
func (*binaryClassSchema) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSchema(d, obj.(*Schema))
}
func (*binaryClassSchema) Skip(d binary.Decoder) error { return doSkipSchema(d) }
func (*binaryClassSchema) Schema() *schema.Class       { return schemaSchema }

var schemaSchema = &schema.Class{
	TypeID:  binaryIDSchema,
	Package: "service",
	Name:    "Schema",
	Fields: []schema.Field{
		{Declared: "Classes", Type: &schema.Slice{Alias: "", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "schema.Class", ID: (*schema.Class)(nil).Class().ID()}}}},
		{Declared: "Constants", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "schema.ConstantSet", ID: (*schema.ConstantSet)(nil).Class().ID()}}},
	},
}

type binaryClassTimingInfo struct{}

func (*TimingInfo) Class() binary.Class {
	return (*binaryClassTimingInfo)(nil)
}
func doEncodeTimingInfo(e binary.Encoder, o *TimingInfo) error {
	if err := e.Uint32(uint32(len(o.PerCommand))); err != nil {
		return err
	}
	for i := range o.PerCommand {
		if err := e.Value(&o.PerCommand[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.PerDrawCall))); err != nil {
		return err
	}
	for i := range o.PerDrawCall {
		if err := e.Value(&o.PerDrawCall[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.PerFrame))); err != nil {
		return err
	}
	for i := range o.PerFrame {
		if err := e.Value(&o.PerFrame[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeTimingInfo(d binary.Decoder, o *TimingInfo) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PerCommand = make([]AtomTimer, count)
		for i := range o.PerCommand {
			if err := d.Value(&o.PerCommand[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PerDrawCall = make([]AtomRangeTimer, count)
		for i := range o.PerDrawCall {
			if err := d.Value(&o.PerDrawCall[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PerFrame = make([]AtomRangeTimer, count)
		for i := range o.PerFrame {
			if err := d.Value(&o.PerFrame[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipTimingInfo(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*AtomTimer)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*AtomRangeTimer)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*AtomRangeTimer)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassTimingInfo) ID() binary.ID      { return binaryIDTimingInfo }
func (*binaryClassTimingInfo) New() binary.Object { return &TimingInfo{} }
func (*binaryClassTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTimingInfo(e, obj.(*TimingInfo))
}
func (*binaryClassTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TimingInfo{}
	return obj, doDecodeTimingInfo(d, obj)
}
func (*binaryClassTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTimingInfo(d, obj.(*TimingInfo))
}
func (*binaryClassTimingInfo) Skip(d binary.Decoder) error { return doSkipTimingInfo(d) }
func (*binaryClassTimingInfo) Schema() *schema.Class       { return schemaTimingInfo }

var schemaTimingInfo = &schema.Class{
	TypeID:  binaryIDTimingInfo,
	Package: "service",
	Name:    "TimingInfo",
	Fields: []schema.Field{
		{Declared: "PerCommand", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "AtomTimer", ID: (*AtomTimer)(nil).Class().ID()}}},
		{Declared: "PerDrawCall", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "AtomRangeTimer", ID: (*AtomRangeTimer)(nil).Class().ID()}}},
		{Declared: "PerFrame", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "AtomRangeTimer", ID: (*AtomRangeTimer)(nil).Class().ID()}}},
	},
}

type binaryClasscallFollow struct{}

func (*callFollow) Class() binary.Class {
	return (*binaryClasscallFollow)(nil)
}
func doEncodecallFollow(e binary.Encoder, o *callFollow) error {
	if o.p != nil {
		if err := e.Object(o.p); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodecallFollow(d binary.Decoder, o *callFollow) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.p = obj.(path.Path)
	} else {
		o.p = nil
	}
	return nil
}
func doSkipcallFollow(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallFollow) ID() binary.ID      { return binaryIDcallFollow }
func (*binaryClasscallFollow) New() binary.Object { return &callFollow{} }
func (*binaryClasscallFollow) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallFollow(e, obj.(*callFollow))
}
func (*binaryClasscallFollow) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callFollow{}
	return obj, doDecodecallFollow(d, obj)
}
func (*binaryClasscallFollow) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallFollow(d, obj.(*callFollow))
}
func (*binaryClasscallFollow) Skip(d binary.Decoder) error { return doSkipcallFollow(d) }
func (*binaryClasscallFollow) Schema() *schema.Class       { return schemacallFollow }

var schemacallFollow = &schema.Class{
	TypeID:  binaryIDcallFollow,
	Package: "service",
	Name:    "callFollow",
	Fields: []schema.Field{
		{Declared: "p", Type: &schema.Interface{Name: "path.Path"}},
	},
}

type binaryClasscallGet struct{}

func (*callGet) Class() binary.Class {
	return (*binaryClasscallGet)(nil)
}
func doEncodecallGet(e binary.Encoder, o *callGet) error {
	if o.p != nil {
		if err := e.Object(o.p); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodecallGet(d binary.Decoder, o *callGet) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.p = obj.(path.Path)
	} else {
		o.p = nil
	}
	return nil
}
func doSkipcallGet(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGet) ID() binary.ID      { return binaryIDcallGet }
func (*binaryClasscallGet) New() binary.Object { return &callGet{} }
func (*binaryClasscallGet) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGet(e, obj.(*callGet))
}
func (*binaryClasscallGet) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGet{}
	return obj, doDecodecallGet(d, obj)
}
func (*binaryClasscallGet) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGet(d, obj.(*callGet))
}
func (*binaryClasscallGet) Skip(d binary.Decoder) error { return doSkipcallGet(d) }
func (*binaryClasscallGet) Schema() *schema.Class       { return schemacallGet }

var schemacallGet = &schema.Class{
	TypeID:  binaryIDcallGet,
	Package: "service",
	Name:    "callGet",
	Fields: []schema.Field{
		{Declared: "p", Type: &schema.Interface{Name: "path.Path"}},
	},
}

type binaryClasscallGetCaptures struct{}

func (*callGetCaptures) Class() binary.Class {
	return (*binaryClasscallGetCaptures)(nil)
}
func doEncodecallGetCaptures(e binary.Encoder, o *callGetCaptures) error {
	return nil
}
func doDecodecallGetCaptures(d binary.Decoder, o *callGetCaptures) error {
	return nil
}
func doSkipcallGetCaptures(d binary.Decoder) error {
	return nil
}
func (*binaryClasscallGetCaptures) ID() binary.ID      { return binaryIDcallGetCaptures }
func (*binaryClasscallGetCaptures) New() binary.Object { return &callGetCaptures{} }
func (*binaryClasscallGetCaptures) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetCaptures(e, obj.(*callGetCaptures))
}
func (*binaryClasscallGetCaptures) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetCaptures{}
	return obj, doDecodecallGetCaptures(d, obj)
}
func (*binaryClasscallGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetCaptures(d, obj.(*callGetCaptures))
}
func (*binaryClasscallGetCaptures) Skip(d binary.Decoder) error { return doSkipcallGetCaptures(d) }
func (*binaryClasscallGetCaptures) Schema() *schema.Class       { return schemacallGetCaptures }

var schemacallGetCaptures = &schema.Class{
	TypeID:  binaryIDcallGetCaptures,
	Package: "service",
	Name:    "callGetCaptures",
	Fields:  []schema.Field{},
}

type binaryClasscallGetDevices struct{}

func (*callGetDevices) Class() binary.Class {
	return (*binaryClasscallGetDevices)(nil)
}
func doEncodecallGetDevices(e binary.Encoder, o *callGetDevices) error {
	return nil
}
func doDecodecallGetDevices(d binary.Decoder, o *callGetDevices) error {
	return nil
}
func doSkipcallGetDevices(d binary.Decoder) error {
	return nil
}
func (*binaryClasscallGetDevices) ID() binary.ID      { return binaryIDcallGetDevices }
func (*binaryClasscallGetDevices) New() binary.Object { return &callGetDevices{} }
func (*binaryClasscallGetDevices) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetDevices(e, obj.(*callGetDevices))
}
func (*binaryClasscallGetDevices) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetDevices{}
	return obj, doDecodecallGetDevices(d, obj)
}
func (*binaryClasscallGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetDevices(d, obj.(*callGetDevices))
}
func (*binaryClasscallGetDevices) Skip(d binary.Decoder) error { return doSkipcallGetDevices(d) }
func (*binaryClasscallGetDevices) Schema() *schema.Class       { return schemacallGetDevices }

var schemacallGetDevices = &schema.Class{
	TypeID:  binaryIDcallGetDevices,
	Package: "service",
	Name:    "callGetDevices",
	Fields:  []schema.Field{},
}

type binaryClasscallGetFramebufferColor struct{}

func (*callGetFramebufferColor) Class() binary.Class {
	return (*binaryClasscallGetFramebufferColor)(nil)
}
func doEncodecallGetFramebufferColor(e binary.Encoder, o *callGetFramebufferColor) error {
	if o.device != nil {
		if err := e.Object(o.device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.after != nil {
		if err := e.Object(o.after); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Value(&o.settings); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetFramebufferColor(d binary.Decoder, o *callGetFramebufferColor) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
	if err := d.Value(&o.settings); err != nil {
		return err
	}
	return nil
}
func doSkipcallGetFramebufferColor(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if err := d.SkipValue((*RenderSettings)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetFramebufferColor) ID() binary.ID      { return binaryIDcallGetFramebufferColor }
func (*binaryClasscallGetFramebufferColor) New() binary.Object { return &callGetFramebufferColor{} }
func (*binaryClasscallGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetFramebufferColor(e, obj.(*callGetFramebufferColor))
}
func (*binaryClasscallGetFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetFramebufferColor{}
	return obj, doDecodecallGetFramebufferColor(d, obj)
}
func (*binaryClasscallGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetFramebufferColor(d, obj.(*callGetFramebufferColor))
}
func (*binaryClasscallGetFramebufferColor) Skip(d binary.Decoder) error {
	return doSkipcallGetFramebufferColor(d)
}
func (*binaryClasscallGetFramebufferColor) Schema() *schema.Class {
	return schemacallGetFramebufferColor
}

var schemacallGetFramebufferColor = &schema.Class{
	TypeID:  binaryIDcallGetFramebufferColor,
	Package: "service",
	Name:    "callGetFramebufferColor",
	Fields: []schema.Field{
		{Declared: "device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "after", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Atom", ID: (*path.Atom)(nil).Class().ID()}}},
		{Declared: "settings", Type: &schema.Struct{Name: "RenderSettings", ID: (*RenderSettings)(nil).Class().ID()}},
	},
}

type binaryClasscallGetFramebufferDepth struct{}

func (*callGetFramebufferDepth) Class() binary.Class {
	return (*binaryClasscallGetFramebufferDepth)(nil)
}
func doEncodecallGetFramebufferDepth(e binary.Encoder, o *callGetFramebufferDepth) error {
	if o.device != nil {
		if err := e.Object(o.device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.after != nil {
		if err := e.Object(o.after); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetFramebufferDepth(d binary.Decoder, o *callGetFramebufferDepth) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
	return nil
}
func doSkipcallGetFramebufferDepth(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetFramebufferDepth) ID() binary.ID      { return binaryIDcallGetFramebufferDepth }
func (*binaryClasscallGetFramebufferDepth) New() binary.Object { return &callGetFramebufferDepth{} }
func (*binaryClasscallGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetFramebufferDepth(e, obj.(*callGetFramebufferDepth))
}
func (*binaryClasscallGetFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetFramebufferDepth{}
	return obj, doDecodecallGetFramebufferDepth(d, obj)
}
func (*binaryClasscallGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetFramebufferDepth(d, obj.(*callGetFramebufferDepth))
}
func (*binaryClasscallGetFramebufferDepth) Skip(d binary.Decoder) error {
	return doSkipcallGetFramebufferDepth(d)
}
func (*binaryClasscallGetFramebufferDepth) Schema() *schema.Class {
	return schemacallGetFramebufferDepth
}

var schemacallGetFramebufferDepth = &schema.Class{
	TypeID:  binaryIDcallGetFramebufferDepth,
	Package: "service",
	Name:    "callGetFramebufferDepth",
	Fields: []schema.Field{
		{Declared: "device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "after", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Atom", ID: (*path.Atom)(nil).Class().ID()}}},
	},
}

type binaryClasscallGetSchema struct{}

func (*callGetSchema) Class() binary.Class {
	return (*binaryClasscallGetSchema)(nil)
}
func doEncodecallGetSchema(e binary.Encoder, o *callGetSchema) error {
	return nil
}
func doDecodecallGetSchema(d binary.Decoder, o *callGetSchema) error {
	return nil
}
func doSkipcallGetSchema(d binary.Decoder) error {
	return nil
}
func (*binaryClasscallGetSchema) ID() binary.ID      { return binaryIDcallGetSchema }
func (*binaryClasscallGetSchema) New() binary.Object { return &callGetSchema{} }
func (*binaryClasscallGetSchema) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetSchema(e, obj.(*callGetSchema))
}
func (*binaryClasscallGetSchema) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetSchema{}
	return obj, doDecodecallGetSchema(d, obj)
}
func (*binaryClasscallGetSchema) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetSchema(d, obj.(*callGetSchema))
}
func (*binaryClasscallGetSchema) Skip(d binary.Decoder) error { return doSkipcallGetSchema(d) }
func (*binaryClasscallGetSchema) Schema() *schema.Class       { return schemacallGetSchema }

var schemacallGetSchema = &schema.Class{
	TypeID:  binaryIDcallGetSchema,
	Package: "service",
	Name:    "callGetSchema",
	Fields:  []schema.Field{},
}

type binaryClasscallGetTimingInfo struct{}

func (*callGetTimingInfo) Class() binary.Class {
	return (*binaryClasscallGetTimingInfo)(nil)
}
func doEncodecallGetTimingInfo(e binary.Encoder, o *callGetTimingInfo) error {
	if o.device != nil {
		if err := e.Object(o.device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.capture != nil {
		if err := e.Object(o.capture); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Int32(int32(o.flags)); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetTimingInfo(d binary.Decoder, o *callGetTimingInfo) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.capture = obj.(*path.Capture)
	} else {
		o.capture = nil
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.flags = TimingFlags(obj)
	}
	return nil
}
func doSkipcallGetTimingInfo(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetTimingInfo) ID() binary.ID      { return binaryIDcallGetTimingInfo }
func (*binaryClasscallGetTimingInfo) New() binary.Object { return &callGetTimingInfo{} }
func (*binaryClasscallGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetTimingInfo(e, obj.(*callGetTimingInfo))
}
func (*binaryClasscallGetTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetTimingInfo{}
	return obj, doDecodecallGetTimingInfo(d, obj)
}
func (*binaryClasscallGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetTimingInfo(d, obj.(*callGetTimingInfo))
}
func (*binaryClasscallGetTimingInfo) Skip(d binary.Decoder) error { return doSkipcallGetTimingInfo(d) }
func (*binaryClasscallGetTimingInfo) Schema() *schema.Class       { return schemacallGetTimingInfo }

var schemacallGetTimingInfo = &schema.Class{
	TypeID:  binaryIDcallGetTimingInfo,
	Package: "service",
	Name:    "callGetTimingInfo",
	Fields: []schema.Field{
		{Declared: "device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "capture", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}},
		{Declared: "flags", Type: &schema.Primitive{Name: "TimingFlags", Method: schema.Int32}},
	},
}

type binaryClasscallImport struct{}

func (*callImport) Class() binary.Class {
	return (*binaryClasscallImport)(nil)
}
func doEncodecallImport(e binary.Encoder, o *callImport) error {
	if err := e.String(o.name); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Data))); err != nil {
		return err
	}
	if err := e.Data(o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodecallImport(d binary.Decoder, o *callImport) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.name = string(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Data = make([]uint8, count)
		if err := d.Data(o.Data); err != nil {
			return err
		}
	}
	return nil
}
func doSkipcallImport(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		if err := d.Skip(count); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClasscallImport) ID() binary.ID      { return binaryIDcallImport }
func (*binaryClasscallImport) New() binary.Object { return &callImport{} }
func (*binaryClasscallImport) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallImport(e, obj.(*callImport))
}
func (*binaryClasscallImport) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callImport{}
	return obj, doDecodecallImport(d, obj)
}
func (*binaryClasscallImport) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallImport(d, obj.(*callImport))
}
func (*binaryClasscallImport) Skip(d binary.Decoder) error { return doSkipcallImport(d) }
func (*binaryClasscallImport) Schema() *schema.Class       { return schemacallImport }

var schemacallImport = &schema.Class{
	TypeID:  binaryIDcallImport,
	Package: "service",
	Name:    "callImport",
	Fields: []schema.Field{
		{Declared: "name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Data", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}},
	},
}

type binaryClasscallPrerenderFramebuffers struct{}

func (*callPrerenderFramebuffers) Class() binary.Class {
	return (*binaryClasscallPrerenderFramebuffers)(nil)
}
func doEncodecallPrerenderFramebuffers(e binary.Encoder, o *callPrerenderFramebuffers) error {
	if o.device != nil {
		if err := e.Object(o.device); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.capture != nil {
		if err := e.Object(o.capture); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.ID(binary.ID(o.api)); err != nil {
		return err
	}
	if err := e.Uint32(o.width); err != nil {
		return err
	}
	if err := e.Uint32(o.height); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.atomIDs))); err != nil {
		return err
	}
	for i := range o.atomIDs {
		if err := e.Uint64(o.atomIDs[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodecallPrerenderFramebuffers(d binary.Decoder, o *callPrerenderFramebuffers) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.capture = obj.(*path.Capture)
	} else {
		o.capture = nil
	}
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.api = ApiID(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.height = uint32(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.atomIDs = make([]uint64, count)
		for i := range o.atomIDs {
			if obj, err := d.Uint64(); err != nil {
				return err
			} else {
				o.atomIDs[i] = uint64(obj)
			}
		}
	}
	return nil
}
func doSkipcallPrerenderFramebuffers(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if err := d.SkipID(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint64(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClasscallPrerenderFramebuffers) ID() binary.ID      { return binaryIDcallPrerenderFramebuffers }
func (*binaryClasscallPrerenderFramebuffers) New() binary.Object { return &callPrerenderFramebuffers{} }
func (*binaryClasscallPrerenderFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallPrerenderFramebuffers(e, obj.(*callPrerenderFramebuffers))
}
func (*binaryClasscallPrerenderFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callPrerenderFramebuffers{}
	return obj, doDecodecallPrerenderFramebuffers(d, obj)
}
func (*binaryClasscallPrerenderFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallPrerenderFramebuffers(d, obj.(*callPrerenderFramebuffers))
}
func (*binaryClasscallPrerenderFramebuffers) Skip(d binary.Decoder) error {
	return doSkipcallPrerenderFramebuffers(d)
}
func (*binaryClasscallPrerenderFramebuffers) Schema() *schema.Class {
	return schemacallPrerenderFramebuffers
}

var schemacallPrerenderFramebuffers = &schema.Class{
	TypeID:  binaryIDcallPrerenderFramebuffers,
	Package: "service",
	Name:    "callPrerenderFramebuffers",
	Fields: []schema.Field{
		{Declared: "device", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}},
		{Declared: "capture", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}},
		{Declared: "api", Type: &schema.Primitive{Name: "ApiID", Method: schema.ID}},
		{Declared: "width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "atomIDs", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}},
	},
}

type binaryClasscallSet struct{}

func (*callSet) Class() binary.Class {
	return (*binaryClasscallSet)(nil)
}
func doEncodecallSet(e binary.Encoder, o *callSet) error {
	if o.p != nil {
		if err := e.Object(o.p); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.v != nil {
		var boxed binary.Object
		boxed, err := any.Box(o.v)
		if err != nil {
			return err
		}
		if err := e.Variant(boxed); err != nil {
			return err
		}
	} else if err := e.Variant(nil); err != nil {
		return err
	}
	return nil
}
func doDecodecallSet(d binary.Decoder, o *callSet) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.p = obj.(path.Path)
	} else {
		o.p = nil
	}
	if boxed, err := d.Variant(); err != nil {
		return err
	} else if boxed != nil {
		if o.v, err = any.Unbox(boxed); err != nil {
			return err
		}
	} else {
		o.v = nil
	}
	return nil
}
func doSkipcallSet(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipVariant(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallSet) ID() binary.ID      { return binaryIDcallSet }
func (*binaryClasscallSet) New() binary.Object { return &callSet{} }
func (*binaryClasscallSet) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallSet(e, obj.(*callSet))
}
func (*binaryClasscallSet) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callSet{}
	return obj, doDecodecallSet(d, obj)
}
func (*binaryClasscallSet) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallSet(d, obj.(*callSet))
}
func (*binaryClasscallSet) Skip(d binary.Decoder) error { return doSkipcallSet(d) }
func (*binaryClasscallSet) Schema() *schema.Class       { return schemacallSet }

var schemacallSet = &schema.Class{
	TypeID:  binaryIDcallSet,
	Package: "service",
	Name:    "callSet",
	Fields: []schema.Field{
		{Declared: "p", Type: &schema.Interface{Name: "path.Path"}},
		{Declared: "v", Type: &any.Any{}},
	},
}

type binaryClassresultFollow struct{}

func (*resultFollow) Class() binary.Class {
	return (*binaryClassresultFollow)(nil)
}
func doEncoderesultFollow(e binary.Encoder, o *resultFollow) error {
	if o.value != nil {
		if err := e.Object(o.value); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecoderesultFollow(d binary.Decoder, o *resultFollow) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.value = obj.(path.Path)
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultFollow(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultFollow) ID() binary.ID      { return binaryIDresultFollow }
func (*binaryClassresultFollow) New() binary.Object { return &resultFollow{} }
func (*binaryClassresultFollow) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultFollow(e, obj.(*resultFollow))
}
func (*binaryClassresultFollow) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultFollow{}
	return obj, doDecoderesultFollow(d, obj)
}
func (*binaryClassresultFollow) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultFollow(d, obj.(*resultFollow))
}
func (*binaryClassresultFollow) Skip(d binary.Decoder) error { return doSkipresultFollow(d) }
func (*binaryClassresultFollow) Schema() *schema.Class       { return schemaresultFollow }

var schemaresultFollow = &schema.Class{
	TypeID:  binaryIDresultFollow,
	Package: "service",
	Name:    "resultFollow",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Interface{Name: "path.Path"}},
	},
}

type binaryClassresultGet struct{}

func (*resultGet) Class() binary.Class {
	return (*binaryClassresultGet)(nil)
}
func doEncoderesultGet(e binary.Encoder, o *resultGet) error {
	if o.value != nil {
		var boxed binary.Object
		boxed, err := any.Box(o.value)
		if err != nil {
			return err
		}
		if err := e.Variant(boxed); err != nil {
			return err
		}
	} else if err := e.Variant(nil); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGet(d binary.Decoder, o *resultGet) error {
	if boxed, err := d.Variant(); err != nil {
		return err
	} else if boxed != nil {
		if o.value, err = any.Unbox(boxed); err != nil {
			return err
		}
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultGet(d binary.Decoder) error {
	if _, err := d.SkipVariant(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGet) ID() binary.ID      { return binaryIDresultGet }
func (*binaryClassresultGet) New() binary.Object { return &resultGet{} }
func (*binaryClassresultGet) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGet(e, obj.(*resultGet))
}
func (*binaryClassresultGet) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGet{}
	return obj, doDecoderesultGet(d, obj)
}
func (*binaryClassresultGet) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGet(d, obj.(*resultGet))
}
func (*binaryClassresultGet) Skip(d binary.Decoder) error { return doSkipresultGet(d) }
func (*binaryClassresultGet) Schema() *schema.Class       { return schemaresultGet }

var schemaresultGet = &schema.Class{
	TypeID:  binaryIDresultGet,
	Package: "service",
	Name:    "resultGet",
	Fields: []schema.Field{
		{Declared: "value", Type: &any.Any{}},
	},
}

type binaryClassresultGetCaptures struct{}

func (*resultGetCaptures) Class() binary.Class {
	return (*binaryClassresultGetCaptures)(nil)
}
func doEncoderesultGetCaptures(e binary.Encoder, o *resultGetCaptures) error {
	if err := e.Uint32(uint32(len(o.value))); err != nil {
		return err
	}
	for i := range o.value {
		if o.value[i] != nil {
			if err := e.Object(o.value[i]); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	return nil
}
func doDecoderesultGetCaptures(d binary.Decoder, o *resultGetCaptures) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.value = make([]*path.Capture, count)
		for i := range o.value {
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				o.value[i] = obj.(*path.Capture)
			} else {
				o.value[i] = nil
			}
		}
	}
	return nil
}
func doSkipresultGetCaptures(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassresultGetCaptures) ID() binary.ID      { return binaryIDresultGetCaptures }
func (*binaryClassresultGetCaptures) New() binary.Object { return &resultGetCaptures{} }
func (*binaryClassresultGetCaptures) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetCaptures(e, obj.(*resultGetCaptures))
}
func (*binaryClassresultGetCaptures) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetCaptures{}
	return obj, doDecoderesultGetCaptures(d, obj)
}
func (*binaryClassresultGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetCaptures(d, obj.(*resultGetCaptures))
}
func (*binaryClassresultGetCaptures) Skip(d binary.Decoder) error { return doSkipresultGetCaptures(d) }
func (*binaryClassresultGetCaptures) Schema() *schema.Class       { return schemaresultGetCaptures }

var schemaresultGetCaptures = &schema.Class{
	TypeID:  binaryIDresultGetCaptures,
	Package: "service",
	Name:    "resultGetCaptures",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Slice{Alias: "", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}}},
	},
}

type binaryClassresultGetDevices struct{}

func (*resultGetDevices) Class() binary.Class {
	return (*binaryClassresultGetDevices)(nil)
}
func doEncoderesultGetDevices(e binary.Encoder, o *resultGetDevices) error {
	if err := e.Uint32(uint32(len(o.value))); err != nil {
		return err
	}
	for i := range o.value {
		if o.value[i] != nil {
			if err := e.Object(o.value[i]); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	return nil
}
func doDecoderesultGetDevices(d binary.Decoder, o *resultGetDevices) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.value = make([]*path.Device, count)
		for i := range o.value {
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				o.value[i] = obj.(*path.Device)
			} else {
				o.value[i] = nil
			}
		}
	}
	return nil
}
func doSkipresultGetDevices(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassresultGetDevices) ID() binary.ID      { return binaryIDresultGetDevices }
func (*binaryClassresultGetDevices) New() binary.Object { return &resultGetDevices{} }
func (*binaryClassresultGetDevices) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetDevices(e, obj.(*resultGetDevices))
}
func (*binaryClassresultGetDevices) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetDevices{}
	return obj, doDecoderesultGetDevices(d, obj)
}
func (*binaryClassresultGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetDevices(d, obj.(*resultGetDevices))
}
func (*binaryClassresultGetDevices) Skip(d binary.Decoder) error { return doSkipresultGetDevices(d) }
func (*binaryClassresultGetDevices) Schema() *schema.Class       { return schemaresultGetDevices }

var schemaresultGetDevices = &schema.Class{
	TypeID:  binaryIDresultGetDevices,
	Package: "service",
	Name:    "resultGetDevices",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Slice{Alias: "", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "path.Device", ID: (*path.Device)(nil).Class().ID()}}}},
	},
}

type binaryClassresultGetFramebufferColor struct{}

func (*resultGetFramebufferColor) Class() binary.Class {
	return (*binaryClassresultGetFramebufferColor)(nil)
}
func doEncoderesultGetFramebufferColor(e binary.Encoder, o *resultGetFramebufferColor) error {
	if o.value != nil {
		if err := e.Object(o.value); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetFramebufferColor(d binary.Decoder, o *resultGetFramebufferColor) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultGetFramebufferColor(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetFramebufferColor) ID() binary.ID      { return binaryIDresultGetFramebufferColor }
func (*binaryClassresultGetFramebufferColor) New() binary.Object { return &resultGetFramebufferColor{} }
func (*binaryClassresultGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetFramebufferColor(e, obj.(*resultGetFramebufferColor))
}
func (*binaryClassresultGetFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetFramebufferColor{}
	return obj, doDecoderesultGetFramebufferColor(d, obj)
}
func (*binaryClassresultGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetFramebufferColor(d, obj.(*resultGetFramebufferColor))
}
func (*binaryClassresultGetFramebufferColor) Skip(d binary.Decoder) error {
	return doSkipresultGetFramebufferColor(d)
}
func (*binaryClassresultGetFramebufferColor) Schema() *schema.Class {
	return schemaresultGetFramebufferColor
}

var schemaresultGetFramebufferColor = &schema.Class{
	TypeID:  binaryIDresultGetFramebufferColor,
	Package: "service",
	Name:    "resultGetFramebufferColor",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.ImageInfo", ID: (*path.ImageInfo)(nil).Class().ID()}}},
	},
}

type binaryClassresultGetFramebufferDepth struct{}

func (*resultGetFramebufferDepth) Class() binary.Class {
	return (*binaryClassresultGetFramebufferDepth)(nil)
}
func doEncoderesultGetFramebufferDepth(e binary.Encoder, o *resultGetFramebufferDepth) error {
	if o.value != nil {
		if err := e.Object(o.value); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetFramebufferDepth(d binary.Decoder, o *resultGetFramebufferDepth) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultGetFramebufferDepth(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetFramebufferDepth) ID() binary.ID      { return binaryIDresultGetFramebufferDepth }
func (*binaryClassresultGetFramebufferDepth) New() binary.Object { return &resultGetFramebufferDepth{} }
func (*binaryClassresultGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetFramebufferDepth(e, obj.(*resultGetFramebufferDepth))
}
func (*binaryClassresultGetFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetFramebufferDepth{}
	return obj, doDecoderesultGetFramebufferDepth(d, obj)
}
func (*binaryClassresultGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetFramebufferDepth(d, obj.(*resultGetFramebufferDepth))
}
func (*binaryClassresultGetFramebufferDepth) Skip(d binary.Decoder) error {
	return doSkipresultGetFramebufferDepth(d)
}
func (*binaryClassresultGetFramebufferDepth) Schema() *schema.Class {
	return schemaresultGetFramebufferDepth
}

var schemaresultGetFramebufferDepth = &schema.Class{
	TypeID:  binaryIDresultGetFramebufferDepth,
	Package: "service",
	Name:    "resultGetFramebufferDepth",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.ImageInfo", ID: (*path.ImageInfo)(nil).Class().ID()}}},
	},
}

type binaryClassresultGetSchema struct{}

func (*resultGetSchema) Class() binary.Class {
	return (*binaryClassresultGetSchema)(nil)
}
func doEncoderesultGetSchema(e binary.Encoder, o *resultGetSchema) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetSchema(d binary.Decoder, o *resultGetSchema) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultGetSchema(d binary.Decoder) error {
	if err := d.SkipValue((*Schema)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetSchema) ID() binary.ID      { return binaryIDresultGetSchema }
func (*binaryClassresultGetSchema) New() binary.Object { return &resultGetSchema{} }
func (*binaryClassresultGetSchema) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetSchema(e, obj.(*resultGetSchema))
}
func (*binaryClassresultGetSchema) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetSchema{}
	return obj, doDecoderesultGetSchema(d, obj)
}
func (*binaryClassresultGetSchema) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetSchema(d, obj.(*resultGetSchema))
}
func (*binaryClassresultGetSchema) Skip(d binary.Decoder) error { return doSkipresultGetSchema(d) }
func (*binaryClassresultGetSchema) Schema() *schema.Class       { return schemaresultGetSchema }

var schemaresultGetSchema = &schema.Class{
	TypeID:  binaryIDresultGetSchema,
	Package: "service",
	Name:    "resultGetSchema",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Struct{Name: "Schema", ID: (*Schema)(nil).Class().ID()}},
	},
}

type binaryClassresultGetTimingInfo struct{}

func (*resultGetTimingInfo) Class() binary.Class {
	return (*binaryClassresultGetTimingInfo)(nil)
}
func doEncoderesultGetTimingInfo(e binary.Encoder, o *resultGetTimingInfo) error {
	if o.value != nil {
		if err := e.Object(o.value); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetTimingInfo(d binary.Decoder, o *resultGetTimingInfo) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.value = obj.(*path.TimingInfo)
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultGetTimingInfo(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetTimingInfo) ID() binary.ID      { return binaryIDresultGetTimingInfo }
func (*binaryClassresultGetTimingInfo) New() binary.Object { return &resultGetTimingInfo{} }
func (*binaryClassresultGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetTimingInfo(e, obj.(*resultGetTimingInfo))
}
func (*binaryClassresultGetTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetTimingInfo{}
	return obj, doDecoderesultGetTimingInfo(d, obj)
}
func (*binaryClassresultGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetTimingInfo(d, obj.(*resultGetTimingInfo))
}
func (*binaryClassresultGetTimingInfo) Skip(d binary.Decoder) error {
	return doSkipresultGetTimingInfo(d)
}
func (*binaryClassresultGetTimingInfo) Schema() *schema.Class { return schemaresultGetTimingInfo }

var schemaresultGetTimingInfo = &schema.Class{
	TypeID:  binaryIDresultGetTimingInfo,
	Package: "service",
	Name:    "resultGetTimingInfo",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.TimingInfo", ID: (*path.TimingInfo)(nil).Class().ID()}}},
	},
}

type binaryClassresultImport struct{}

func (*resultImport) Class() binary.Class {
	return (*binaryClassresultImport)(nil)
}
func doEncoderesultImport(e binary.Encoder, o *resultImport) error {
	if o.value != nil {
		if err := e.Object(o.value); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecoderesultImport(d binary.Decoder, o *resultImport) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultImport(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultImport) ID() binary.ID      { return binaryIDresultImport }
func (*binaryClassresultImport) New() binary.Object { return &resultImport{} }
func (*binaryClassresultImport) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultImport(e, obj.(*resultImport))
}
func (*binaryClassresultImport) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultImport{}
	return obj, doDecoderesultImport(d, obj)
}
func (*binaryClassresultImport) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultImport(d, obj.(*resultImport))
}
func (*binaryClassresultImport) Skip(d binary.Decoder) error { return doSkipresultImport(d) }
func (*binaryClassresultImport) Schema() *schema.Class       { return schemaresultImport }

var schemaresultImport = &schema.Class{
	TypeID:  binaryIDresultImport,
	Package: "service",
	Name:    "resultImport",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Pointer{Type: &schema.Struct{Name: "path.Capture", ID: (*path.Capture)(nil).Class().ID()}}},
	},
}

type binaryClassresultPrerenderFramebuffers struct{}

func (*resultPrerenderFramebuffers) Class() binary.Class {
	return (*binaryClassresultPrerenderFramebuffers)(nil)
}
func doEncoderesultPrerenderFramebuffers(e binary.Encoder, o *resultPrerenderFramebuffers) error {
	return nil
}
func doDecoderesultPrerenderFramebuffers(d binary.Decoder, o *resultPrerenderFramebuffers) error {
	return nil
}
func doSkipresultPrerenderFramebuffers(d binary.Decoder) error {
	return nil
}
func (*binaryClassresultPrerenderFramebuffers) ID() binary.ID {
	return binaryIDresultPrerenderFramebuffers
}
func (*binaryClassresultPrerenderFramebuffers) New() binary.Object {
	return &resultPrerenderFramebuffers{}
}
func (*binaryClassresultPrerenderFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultPrerenderFramebuffers(e, obj.(*resultPrerenderFramebuffers))
}
func (*binaryClassresultPrerenderFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultPrerenderFramebuffers{}
	return obj, doDecoderesultPrerenderFramebuffers(d, obj)
}
func (*binaryClassresultPrerenderFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultPrerenderFramebuffers(d, obj.(*resultPrerenderFramebuffers))
}
func (*binaryClassresultPrerenderFramebuffers) Skip(d binary.Decoder) error {
	return doSkipresultPrerenderFramebuffers(d)
}
func (*binaryClassresultPrerenderFramebuffers) Schema() *schema.Class {
	return schemaresultPrerenderFramebuffers
}

var schemaresultPrerenderFramebuffers = &schema.Class{
	TypeID:  binaryIDresultPrerenderFramebuffers,
	Package: "service",
	Name:    "resultPrerenderFramebuffers",
	Fields:  []schema.Field{},
}

type binaryClassresultSet struct{}

func (*resultSet) Class() binary.Class {
	return (*binaryClassresultSet)(nil)
}
func doEncoderesultSet(e binary.Encoder, o *resultSet) error {
	if o.value != nil {
		if err := e.Object(o.value); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecoderesultSet(d binary.Decoder, o *resultSet) error {
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.value = obj.(path.Path)
	} else {
		o.value = nil
	}
	return nil
}
func doSkipresultSet(d binary.Decoder) error {
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultSet) ID() binary.ID      { return binaryIDresultSet }
func (*binaryClassresultSet) New() binary.Object { return &resultSet{} }
func (*binaryClassresultSet) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultSet(e, obj.(*resultSet))
}
func (*binaryClassresultSet) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultSet{}
	return obj, doDecoderesultSet(d, obj)
}
func (*binaryClassresultSet) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultSet(d, obj.(*resultSet))
}
func (*binaryClassresultSet) Skip(d binary.Decoder) error { return doSkipresultSet(d) }
func (*binaryClassresultSet) Schema() *schema.Class       { return schemaresultSet }

var schemaresultSet = &schema.Class{
	TypeID:  binaryIDresultSet,
	Package: "service",
	Name:    "resultSet",
	Fields: []schema.Field{
		{Declared: "value", Type: &schema.Interface{Name: "path.Path"}},
	},
}

var ConstantValues schema.Constants

const _TimingFlags_name = "TimingCPUTimingGPUTimingPerCommandTimingPerDrawCallTimingPerFrame"

var _TimingFlags_map = map[TimingFlags]string{}

func init() {
	_TimingFlags_map[0] = _TimingFlags_name[0:9]
	_TimingFlags_map[1] = _TimingFlags_name[9:18]
	_TimingFlags_map[2] = _TimingFlags_name[18:34]
	_TimingFlags_map[4] = _TimingFlags_name[34:51]
	_TimingFlags_map[8] = _TimingFlags_name[51:65]

	ConstantValues = append(ConstantValues, schema.ConstantSet{
		Type: &schema.Primitive{Name: "TimingFlags", Method: schema.Int32},
		Entries: []schema.Constant{
			{Name: _TimingFlags_name[0:9], Value: int32(0)},
			{Name: _TimingFlags_name[9:18], Value: int32(1)},
			{Name: _TimingFlags_name[18:34], Value: int32(2)},
			{Name: _TimingFlags_name[34:51], Value: int32(4)},
			{Name: _TimingFlags_name[51:65], Value: int32(8)},
		},
	})
}

func (v TimingFlags) String() string {
	if s, ok := _TimingFlags_map[v]; ok {
		return s
	}
	return fmt.Sprintf("TimingFlags(%d)", v)
}

func (v *TimingFlags) Parse(s string) error {
	for k, t := range _TimingFlags_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in TimingFlags", s)
}

const _WireframeMode_name = "NoWireframeWireframeOverlayAllWireframe"

var _WireframeMode_map = map[WireframeMode]string{}

func init() {
	_WireframeMode_map[0] = _WireframeMode_name[0:11]
	_WireframeMode_map[1] = _WireframeMode_name[11:27]
	_WireframeMode_map[2] = _WireframeMode_name[27:39]

	ConstantValues = append(ConstantValues, schema.ConstantSet{
		Type: &schema.Primitive{Name: "WireframeMode", Method: schema.Int32},
		Entries: []schema.Constant{
			{Name: _WireframeMode_name[0:11], Value: int32(0)},
			{Name: _WireframeMode_name[11:27], Value: int32(1)},
			{Name: _WireframeMode_name[27:39], Value: int32(2)},
		},
	})
}

func (v WireframeMode) String() string {
	if s, ok := _WireframeMode_map[v]; ok {
		return s
	}
	return fmt.Sprintf("WireframeMode(%d)", v)
}

func (v *WireframeMode) Parse(s string) error {
	for k, t := range _WireframeMode_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in WireframeMode", s)
}