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

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/gfxapi"
	"android.googlesource.com/platform/tools/gpu/memory"
)

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.Add((*Range)(nil).Class())
	Namespace.Add((*Group)(nil).Class())
	Namespace.Add((*List)(nil).Class())
	Namespace.Add((*Metadata)(nil).Class())
	Namespace.Add((*Observation)(nil).Class())
	Namespace.Add((*Observations)(nil).Class())
	Namespace.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}
	binaryIDList         = binary.ID{0x02, 0x6b, 0xec, 0xdd, 0x57, 0x69, 0x25, 0xab, 0xfc, 0x6c, 0x21, 0x8e, 0xa6, 0xe1, 0x51, 0xc5, 0x04, 0xf3, 0x8b, 0x2f}
	binaryIDMetadata     = binary.ID{0xb0, 0x6e, 0x0a, 0xcb, 0x6d, 0x82, 0x36, 0x07, 0xa8, 0x83, 0x7c, 0xe9, 0xd3, 0xa6, 0xbc, 0x20, 0x42, 0xe0, 0x28, 0xff}
	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,
	Package: "atom",
	Name:    "Range",
	Fields: []schema.Field{
		{Declared: "Start", Type: &schema.Primitive{Name: "ID", Method: schema.Uint64}},
		{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,
	Package: "atom",
	Name:    "Group",
	Fields: []schema.Field{
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Range", Type: &schema.Struct{Name: "Range", ID: (*Range)(nil).Class().ID()}},
		{Declared: "SubGroups", Type: &schema.Slice{Alias: "GroupList", ValueType: &schema.Struct{Name: "Group", ID: (*Group)(nil).Class().ID()}}},
	},
}

type binaryClassList struct{}

func (*List) Class() binary.Class {
	return (*binaryClassList)(nil)
}
func doEncodeList(e binary.Encoder, o *List) error {
	if err := e.Uint32(uint32(len(o.Atoms))); err != nil {
		return err
	}
	for i := range o.Atoms {
		if o.Atoms[i] != nil {
			if err := e.Object(o.Atoms[i]); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeList(d binary.Decoder, o *List) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Atoms = make([]Atom, count)
		for i := range o.Atoms {
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				o.Atoms[i] = obj.(Atom)
			} else {
				o.Atoms[i] = nil
			}
		}
	}
	return nil
}
func doSkipList(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 (*binaryClassList) ID() binary.ID      { return binaryIDList }
func (*binaryClassList) New() binary.Object { return &List{} }
func (*binaryClassList) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeList(e, obj.(*List))
}
func (*binaryClassList) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &List{}
	return obj, doDecodeList(d, obj)
}
func (*binaryClassList) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeList(d, obj.(*List))
}
func (*binaryClassList) Skip(d binary.Decoder) error { return doSkipList(d) }
func (*binaryClassList) Schema() *schema.Class       { return schemaList }

var schemaList = &schema.Class{
	TypeID:  binaryIDList,
	Package: "atom",
	Name:    "List",
	Fields: []schema.Field{
		{Declared: "Atoms", Type: &schema.Slice{Alias: "", ValueType: &schema.Interface{Name: "Atom"}}},
	},
}

type binaryClassMetadata struct{}

func (*Metadata) Class() binary.Class {
	return (*binaryClassMetadata)(nil)
}
func doEncodeMetadata(e binary.Encoder, o *Metadata) error {
	if err := e.ID(binary.ID(o.API)); err != nil {
		return err
	}
	if err := e.String(o.DisplayName); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Flags)); err != nil {
		return err
	}
	if err := e.String(o.DocumentationUrl); err != nil {
		return err
	}
	return nil
}
func doDecodeMetadata(d binary.Decoder, o *Metadata) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.API = gfxapi.ID(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.DisplayName = string(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Flags = Flags(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.DocumentationUrl = string(obj)
	}
	return nil
}
func doSkipMetadata(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMetadata) ID() binary.ID      { return binaryIDMetadata }
func (*binaryClassMetadata) New() binary.Object { return &Metadata{} }
func (*binaryClassMetadata) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMetadata(e, obj.(*Metadata))
}
func (*binaryClassMetadata) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Metadata{}
	return obj, doDecodeMetadata(d, obj)
}
func (*binaryClassMetadata) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMetadata(d, obj.(*Metadata))
}
func (*binaryClassMetadata) Skip(d binary.Decoder) error { return doSkipMetadata(d) }
func (*binaryClassMetadata) Schema() *schema.Class       { return schemaMetadata }

var schemaMetadata = &schema.Class{
	TypeID:  binaryIDMetadata,
	Package: "atom",
	Name:    "Metadata",
	Fields: []schema.Field{
		{Declared: "API", Type: &schema.Primitive{Name: "gfxapi.ID", Method: schema.ID}},
		{Declared: "DisplayName", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Flags", Type: &schema.Primitive{Name: "Flags", Method: schema.Uint32}},
		{Declared: "DocumentationUrl", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

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,
	Package: "atom",
	Name:    "Observation",
	Fields: []schema.Field{
		{Declared: "Range", Type: &schema.Struct{Name: "memory.Range", ID: (*memory.Range)(nil).Class().ID()}},
		{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,
	Package: "atom",
	Name:    "Observations",
	Fields: []schema.Field{
		{Declared: "Reads", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "Observation", ID: (*Observation)(nil).Class().ID()}}},
		{Declared: "Writes", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "Observation", ID: (*Observation)(nil).Class().ID()}}},
	},
}

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,
	Package: "atom",
	Name:    "Resource",
	Fields: []schema.Field{
		{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
		{Declared: "Data", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "byte", Method: schema.Uint8}}},
	},
}

var ConstantValues schema.Constants

const _Flags_name = "DrawCallEndOfFrame"

var _Flags_map = map[Flags]string{}

func init() {
	_Flags_map[1] = _Flags_name[0:8]
	_Flags_map[2] = _Flags_name[8:18]

	ConstantValues = append(ConstantValues, schema.ConstantSet{
		Type: &schema.Primitive{Name: "Flags", Method: schema.Uint32},
		Entries: []schema.Constant{
			{Name: _Flags_name[0:8], Value: uint32(1)},
			{Name: _Flags_name[8:18], Value: uint32(2)},
		},
	})
}

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{}

func init() {
	_ID_map[9223372036854775807] = _ID_name[0:4]

	ConstantValues = append(ConstantValues, schema.ConstantSet{
		Type: &schema.Primitive{Name: "ID", Method: schema.Uint64},
		Entries: []schema.Constant{
			{Name: _ID_name[0:4], Value: uint64(9223372036854775807)},
		},
	})
}

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)
}