atom/atom_binary.go

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

package atom

import (
	"fmt"

	"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/memory"
)

func init() {
	registry.Add((*Range)(nil).Class())
	registry.Add((*Group)(nil).Class())
	registry.Add((*Observation)(nil).Class())
	registry.Add((*Observations)(nil).Class())
	registry.Add((*Resource)(nil).Class())
}

var (
	binaryIDRange        = binary.ID{0x6f, 0xbb, 0x0f, 0x69, 0x4c, 0x19, 0xdb, 0x86, 0x34, 0x4f, 0x63, 0xc3, 0x04, 0xaf, 0x06, 0x89, 0xda, 0x0f, 0xb3, 0x0a}
	binaryIDGroup        = binary.ID{0x1d, 0x80, 0xcc, 0xfa, 0xe5, 0xba, 0x0e, 0x88, 0x3f, 0x11, 0x3b, 0xd5, 0x07, 0x16, 0x56, 0x13, 0xf5, 0x43, 0x42, 0xeb}
	binaryIDObservation  = binary.ID{0xf4, 0xbd, 0xbf, 0xe0, 0x82, 0x78, 0xa4, 0xbd, 0x55, 0xac, 0xeb, 0x1e, 0x0b, 0xde, 0xe5, 0x27, 0x1a, 0xd8, 0x84, 0x0f}
	binaryIDObservations = binary.ID{0x61, 0xdf, 0xaa, 0x12, 0x4f, 0x53, 0x1a, 0x54, 0x92, 0x4e, 0x90, 0xc4, 0x05, 0x7c, 0xf4, 0x5f, 0x00, 0xcb, 0x62, 0xe9}
	binaryIDResource     = binary.ID{0xdd, 0xe2, 0x00, 0x18, 0x25, 0x45, 0x71, 0xb9, 0xdb, 0x6f, 0xed, 0x39, 0xdd, 0x8e, 0x71, 0x4b, 0xf6, 0x76, 0x26, 0xce}
)

type binaryClassRange struct{}

func (*Range) Class() binary.Class {
	return (*binaryClassRange)(nil)
}
func doEncodeRange(e binary.Encoder, o *Range) error {
	if err := e.Uint64(uint64(o.Start)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.End)); err != nil {
		return err
	}
	return nil
}
func doDecodeRange(d binary.Decoder, o *Range) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Start = ID(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.End = ID(obj)
	}
	return nil
}
func doSkipRange(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRange) ID() binary.ID      { return binaryIDRange }
func (*binaryClassRange) New() binary.Object { return &Range{} }
func (*binaryClassRange) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRange(e, obj.(*Range))
}
func (*binaryClassRange) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Range{}
	return obj, doDecodeRange(d, obj)
}
func (*binaryClassRange) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRange(d, obj.(*Range))
}
func (*binaryClassRange) Skip(d binary.Decoder) error { return doSkipRange(d) }
func (*binaryClassRange) Schema() *schema.Class       { return schemaRange }

var schemaRange = &schema.Class{
	TypeID: binaryIDRange,
	Name:   "Range",
	Fields: []schema.Field{
		schema.Field{Declared: "Start", Type: &schema.Primitive{Name: "ID", Method: schema.Uint64}},
		schema.Field{Declared: "End", Type: &schema.Primitive{Name: "ID", Method: schema.Uint64}},
	},
}

type binaryClassGroup struct{}

func (*Group) Class() binary.Class {
	return (*binaryClassGroup)(nil)
}
func doEncodeGroup(e binary.Encoder, o *Group) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Value(&o.Range); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.SubGroups))); err != nil {
		return err
	}
	for i := range o.SubGroups {
		if err := e.Value(&o.SubGroups[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeGroup(d binary.Decoder, o *Group) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if err := d.Value(&o.Range); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SubGroups = make(GroupList, count)
		for i := range o.SubGroups {
			if err := d.Value(&o.SubGroups[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipGroup(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipValue((*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((*Group)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassGroup) ID() binary.ID      { return binaryIDGroup }
func (*binaryClassGroup) New() binary.Object { return &Group{} }
func (*binaryClassGroup) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGroup(e, obj.(*Group))
}
func (*binaryClassGroup) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Group{}
	return obj, doDecodeGroup(d, obj)
}
func (*binaryClassGroup) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGroup(d, obj.(*Group))
}
func (*binaryClassGroup) Skip(d binary.Decoder) error { return doSkipGroup(d) }
func (*binaryClassGroup) Schema() *schema.Class       { return schemaGroup }

var schemaGroup = &schema.Class{
	TypeID: binaryIDGroup,
	Name:   "Group",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Range", Type: &schema.Struct{Name: "Range"}},
		schema.Field{Declared: "SubGroups", Type: &schema.Slice{Alias: "GroupList", ValueType: &schema.Struct{Name: "Group"}}},
	},
}

type binaryClassObservation struct{}

func (*Observation) Class() binary.Class {
	return (*binaryClassObservation)(nil)
}
func doEncodeObservation(e binary.Encoder, o *Observation) error {
	if err := e.Value(&o.Range); err != nil {
		return err
	}
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeObservation(d binary.Decoder, o *Observation) error {
	if err := d.Value(&o.Range); err != nil {
		return err
	}
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipObservation(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Range)(nil)); err != nil {
		return err
	}
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassObservation) ID() binary.ID      { return binaryIDObservation }
func (*binaryClassObservation) New() binary.Object { return &Observation{} }
func (*binaryClassObservation) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeObservation(e, obj.(*Observation))
}
func (*binaryClassObservation) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Observation{}
	return obj, doDecodeObservation(d, obj)
}
func (*binaryClassObservation) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeObservation(d, obj.(*Observation))
}
func (*binaryClassObservation) Skip(d binary.Decoder) error { return doSkipObservation(d) }
func (*binaryClassObservation) Schema() *schema.Class       { return schemaObservation }

var schemaObservation = &schema.Class{
	TypeID: binaryIDObservation,
	Name:   "Observation",
	Fields: []schema.Field{
		schema.Field{Declared: "Range", Type: &schema.Struct{Name: "memory.Range"}},
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassObservations struct{}

func (*Observations) Class() binary.Class {
	return (*binaryClassObservations)(nil)
}
func doEncodeObservations(e binary.Encoder, o *Observations) error {
	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
		}
	}
	return nil
}
func doDecodeObservations(d binary.Decoder, o *Observations) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Reads = make([]Observation, 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([]Observation, count)
		for i := range o.Writes {
			if err := d.Value(&o.Writes[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipObservations(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((*Observation)(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((*Observation)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassObservations) ID() binary.ID      { return binaryIDObservations }
func (*binaryClassObservations) New() binary.Object { return &Observations{} }
func (*binaryClassObservations) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeObservations(e, obj.(*Observations))
}
func (*binaryClassObservations) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Observations{}
	return obj, doDecodeObservations(d, obj)
}
func (*binaryClassObservations) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeObservations(d, obj.(*Observations))
}
func (*binaryClassObservations) Skip(d binary.Decoder) error { return doSkipObservations(d) }
func (*binaryClassObservations) Schema() *schema.Class       { return schemaObservations }

var schemaObservations = &schema.Class{
	TypeID: binaryIDObservations,
	Name:   "Observations",
	Fields: []schema.Field{
		schema.Field{Declared: "Reads", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "Observation"}}},
		schema.Field{Declared: "Writes", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "Observation"}}},
	},
}

type binaryClassResource struct{}

func (*Resource) Class() binary.Class {
	return (*binaryClassResource)(nil)
}
func doEncodeResource(e binary.Encoder, o *Resource) error {
	if err := e.ID(o.ID); 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 doDecodeResource(d binary.Decoder, o *Resource) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Data = make([]byte, count)
		if err := d.Data(o.Data); err != nil {
			return err
		}
	}
	return nil
}
func doSkipResource(d binary.Decoder) error {
	if err := d.SkipID(); 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 (*binaryClassResource) ID() binary.ID      { return binaryIDResource }
func (*binaryClassResource) New() binary.Object { return &Resource{} }
func (*binaryClassResource) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeResource(e, obj.(*Resource))
}
func (*binaryClassResource) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Resource{}
	return obj, doDecodeResource(d, obj)
}
func (*binaryClassResource) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeResource(d, obj.(*Resource))
}
func (*binaryClassResource) Skip(d binary.Decoder) error { return doSkipResource(d) }
func (*binaryClassResource) Schema() *schema.Class       { return schemaResource }

var schemaResource = &schema.Class{
	TypeID: binaryIDResource,
	Name:   "Resource",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
		schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "byte", Method: schema.Uint8}}},
	},
}

const _Flags_name = "DrawCallEndOfFrame"

var _Flags_map = map[Flags]string{
	1: _Flags_name[0:8],
	2: _Flags_name[8:18],
}

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

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

const _ID_name = "NoID"

var _ID_map = map[ID]string{
	18446744073709551615: _ID_name[0:4],
}

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

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

const _TypeID_name = "ResourceEos"

var _TypeID_map = map[TypeID]string{
	65533: _TypeID_name[0:8],
	65535: _TypeID_name[8:11],
}

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

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