service/path/path_binary.go

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

package path

import (
	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/binary/registry"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
	"android.googlesource.com/platform/tools/gpu/rpc"
)

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

const (
	ixǁArrayIndex = iota
	ixǁAs
	ixǁCapture
	ixǁAtoms
	ixǁAtom
	ixǁBlob
	ixǁDevice
	ixǁErrNotFollowable
	ixǁField
	ixǁHierarchy
	ixǁImageInfo
	ixǁMapIndex
	ixǁMemoryRange
	ixǁReport
	ixǁResource
	ixǁResources
	ixǁSlice
	ixǁState
	ixǁThumbnail
	ixǁTimingInfo
)

var entities [20]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*ArrayIndex)(nil))
	Namespace.AddClassOf((*As)(nil))
	Namespace.AddClassOf((*Capture)(nil))
	Namespace.AddClassOf((*Atoms)(nil))
	Namespace.AddClassOf((*Atom)(nil))
	Namespace.AddClassOf((*Blob)(nil))
	Namespace.AddClassOf((*Device)(nil))
	Namespace.AddClassOf((*ErrNotFollowable)(nil))
	Namespace.AddClassOf((*Field)(nil))
	Namespace.AddClassOf((*Hierarchy)(nil))
	Namespace.AddClassOf((*ImageInfo)(nil))
	Namespace.AddClassOf((*MapIndex)(nil))
	Namespace.AddClassOf((*MemoryRange)(nil))
	Namespace.AddClassOf((*Report)(nil))
	Namespace.AddClassOf((*Resource)(nil))
	Namespace.AddClassOf((*Resources)(nil))
	Namespace.AddClassOf((*Slice)(nil))
	Namespace.AddClassOf((*State)(nil))
	Namespace.AddClassOf((*Thumbnail)(nil))
	Namespace.AddClassOf((*TimingInfo)(nil))
}

type binaryClassArrayIndex struct{}

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

type binaryClassAs struct{}

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

type binaryClassCapture struct{}

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

type binaryClassAtoms struct{}

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

type binaryClassAtom struct{}

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

type binaryClassBlob struct{}

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

type binaryClassDevice struct{}

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

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

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

type binaryClassField struct{}

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

type binaryClassHierarchy struct{}

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

type binaryClassImageInfo struct{}

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

type binaryClassMapIndex struct{}

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

type binaryClassMemoryRange struct{}

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

type binaryClassReport struct{}

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

type binaryClassResource struct{}

func (*Resource) Class() binary.Class {
	return (*binaryClassResource)(nil)
}
func doEncodeResource(e binary.Encoder, o *Resource) {
	e.Data(o.ID[:20])
	if o.After != nil {
		e.Object(o.After)
	} else {
		e.Object(nil)
	}
}
func doDecodeResource(d binary.Decoder, o *Resource) {
	d.Data(o.ID[:20])
	if obj := d.Object(); obj != nil {
		o.After = obj.(*Atom)
	} else {
		o.After = nil
	}
}
func (*binaryClassResource) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResource(e, obj.(*Resource))
}
func (*binaryClassResource) New() binary.Object {
	return &Resource{}
}
func (*binaryClassResource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResource(d, obj.(*Resource))
}
func (c *binaryClassResource) Schema() *binary.Entity {
	return &entities[ixǁResource]
}

type binaryClassResources struct{}

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

type binaryClassSlice struct{}

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

type binaryClassState struct{}

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

type binaryClassThumbnail struct{}

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

type binaryClassTimingInfo struct{}

func (*TimingInfo) Class() binary.Class {
	return (*binaryClassTimingInfo)(nil)
}
func doEncodeTimingInfo(e binary.Writer, o *TimingInfo) {
	e.Data(o.ID[:20])
}
func doDecodeTimingInfo(d binary.Reader, o *TimingInfo) {
	d.Data(o.ID[:20])
}
func (*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]
}