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

package builder

import (
	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/binary/any"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
	"android.googlesource.com/platform/tools/gpu/gfxapi"
)

func init() {
	Namespace.Add((*testStruct)(nil).Class())
	Namespace.Add((*testAtom)(nil).Class())
}

var (
	binaryIDtestStruct = binary.ID{0x93, 0x39, 0x46, 0x5d, 0x2e, 0x91, 0x59, 0x69, 0x3a, 0x17, 0x8d, 0x2f, 0xc2, 0x43, 0xb7, 0x33, 0x93, 0xcc, 0xb3, 0x4a}
	binaryIDtestAtom   = binary.ID{0x71, 0x4f, 0xb5, 0x0a, 0x96, 0x6a, 0x28, 0xb8, 0xc0, 0xd5, 0x05, 0x8a, 0x90, 0x9f, 0x37, 0x61, 0x15, 0xa5, 0xb0, 0x22}
)

type binaryClasstestStruct struct{}

func (*testStruct) Class() binary.Class {
	return (*binaryClasstestStruct)(nil)
}
func doEncodetestStruct(e binary.Encoder, o *testStruct) error {
	if err := e.String(o.Str); err != nil {
		return err
	}
	if o.Ptr != nil {
		if err := e.Object(o.Ptr); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodetestStruct(d binary.Decoder, o *testStruct) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Str = string(obj)
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Ptr = obj.(*testStruct)
	} else {
		o.Ptr = nil
	}
	return nil
}
func doSkiptestStruct(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasstestStruct) ID() binary.ID      { return binaryIDtestStruct }
func (*binaryClasstestStruct) New() binary.Object { return &testStruct{} }
func (*binaryClasstestStruct) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodetestStruct(e, obj.(*testStruct))
}
func (*binaryClasstestStruct) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &testStruct{}
	return obj, doDecodetestStruct(d, obj)
}
func (*binaryClasstestStruct) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodetestStruct(d, obj.(*testStruct))
}
func (*binaryClasstestStruct) Skip(d binary.Decoder) error { return doSkiptestStruct(d) }
func (*binaryClasstestStruct) Schema() *schema.Class       { return schematestStruct }

var schematestStruct = &schema.Class{
	TypeID:  binaryIDtestStruct,
	Package: "builder",
	Name:    "testStruct",
	Fields: []schema.Field{
		{Declared: "Str", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Ptr", Type: &schema.Pointer{Type: &schema.Struct{Name: "testStruct", ID: (*testStruct)(nil).Class().ID()}}},
	},
}

type binaryClasstestAtom struct{}

func (*testAtom) Class() binary.Class {
	return (*binaryClasstestAtom)(nil)
}
func doEncodetestAtom(e binary.Encoder, o *testAtom) error {
	if err := e.ID(binary.ID(o.api)); err != nil {
		return err
	}
	if err := e.String(o.Str); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Sli))); err != nil {
		return err
	}
	for i := range o.Sli {
		if err := e.Bool(o.Sli[i]); err != nil {
			return err
		}
	}
	if o.Any != nil {
		var boxed binary.Object
		boxed, err := any.Box(o.Any)
		if err != nil {
			return err
		}
		if err := e.Variant(boxed); err != nil {
			return err
		}
	} else if err := e.Variant(nil); err != nil {
		return err
	}
	if o.Ptr != nil {
		if err := e.Object(o.Ptr); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Map))); err != nil {
		return err
	}
	for k, v := range o.Map {
		if err := e.String(k); err != nil {
			return err
		}
		if err := e.String(v); err != nil {
			return err
		}
	}
	return nil
}
func doDecodetestAtom(d binary.Decoder, o *testAtom) 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.Str = string(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sli = make([]bool, count)
		for i := range o.Sli {
			if obj, err := d.Bool(); err != nil {
				return err
			} else {
				o.Sli[i] = bool(obj)
			}
		}
	}
	if boxed, err := d.Variant(); err != nil {
		return err
	} else if boxed != nil {
		if o.Any, err = any.Unbox(boxed); err != nil {
			return err
		}
	} else {
		o.Any = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Ptr = obj.(*testStruct)
	} else {
		o.Ptr = nil
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Map = make(map[string]string, count)
		m := o.Map
		for i := uint32(0); i < count; i++ {
			var k string
			var v string
			if obj, err := d.String(); err != nil {
				return err
			} else {
				k = string(obj)
			}
			if obj, err := d.String(); err != nil {
				return err
			} else {
				v = string(obj)
			}
			m[k] = v
		}
	}
	return nil
}
func doSkiptestAtom(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Bool(); err != nil {
				return err
			}
		}
	}
	if _, err := d.SkipVariant(); err != nil {
		return err
	}
	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.SkipString(); err != nil {
				return err
			}
			if err := d.SkipString(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClasstestAtom) ID() binary.ID      { return binaryIDtestAtom }
func (*binaryClasstestAtom) New() binary.Object { return &testAtom{} }
func (*binaryClasstestAtom) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodetestAtom(e, obj.(*testAtom))
}
func (*binaryClasstestAtom) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &testAtom{}
	return obj, doDecodetestAtom(d, obj)
}
func (*binaryClasstestAtom) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodetestAtom(d, obj.(*testAtom))
}
func (*binaryClasstestAtom) Skip(d binary.Decoder) error { return doSkiptestAtom(d) }
func (*binaryClasstestAtom) Schema() *schema.Class       { return schematestAtom }

var schematestAtom = &schema.Class{
	TypeID:  binaryIDtestAtom,
	Package: "builder",
	Name:    "testAtom",
	Fields: []schema.Field{
		{Declared: "api", Type: &schema.Primitive{Name: "gfxapi.ID", Method: schema.ID}},
		{Declared: "Str", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Sli", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "bool", Method: schema.Bool}}},
		{Declared: "Any", Type: &any.Any{}},
		{Declared: "Ptr", Type: &schema.Pointer{Type: &schema.Struct{Name: "testStruct", ID: (*testStruct)(nil).Class().ID()}}},
		{Declared: "Map", Type: &schema.Map{Alias: "", KeyType: &schema.Primitive{Name: "string", Method: schema.String}, ValueType: &schema.Primitive{Name: "string", Method: schema.String}}},
	},
}