| //////////////////////////////////////////////////////////////////////////////// |
| // Do not modify! |
| // Generated by codergen |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| package memory |
| |
| 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" |
| ) |
| |
| var Namespace = registry.NewNamespace() |
| |
| func init() { |
| registry.Global.AddFallbacks(Namespace) |
| Namespace.Add((*Pointer)(nil).Class()) |
| Namespace.Add((*Range)(nil).Class()) |
| } |
| |
| var ( |
| binaryIDPointer = binary.ID{0x32, 0x91, 0x20, 0x2c, 0x71, 0x1c, 0x99, 0xd3, 0xde, 0xad, 0xd6, 0xab, 0xac, 0x67, 0x78, 0xad, 0xfd, 0xb5, 0x05, 0xf9} |
| binaryIDRange = binary.ID{0x4d, 0x08, 0x43, 0xb3, 0xb7, 0x7d, 0x8c, 0x7b, 0x5f, 0x7f, 0x54, 0xb7, 0x7b, 0xa3, 0xd6, 0x55, 0x77, 0x01, 0x52, 0x2c} |
| ) |
| |
| type binaryClassPointer struct{} |
| |
| func (*Pointer) Class() binary.Class { |
| return (*binaryClassPointer)(nil) |
| } |
| func doEncodePointer(e binary.Encoder, o *Pointer) error { |
| if err := e.Uint64(o.Address); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(o.Pool)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodePointer(d binary.Decoder, o *Pointer) error { |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.Address = uint64(obj) |
| } |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Pool = PoolID(obj) |
| } |
| return nil |
| } |
| func doSkipPointer(d binary.Decoder) error { |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassPointer) ID() binary.ID { return binaryIDPointer } |
| func (*binaryClassPointer) New() binary.Object { return &Pointer{} } |
| func (*binaryClassPointer) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodePointer(e, obj.(*Pointer)) |
| } |
| func (*binaryClassPointer) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &Pointer{} |
| return obj, doDecodePointer(d, obj) |
| } |
| func (*binaryClassPointer) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodePointer(d, obj.(*Pointer)) |
| } |
| func (*binaryClassPointer) Skip(d binary.Decoder) error { return doSkipPointer(d) } |
| func (*binaryClassPointer) Schema() *schema.Class { return schemaPointer } |
| |
| var schemaPointer = &schema.Class{ |
| TypeID: binaryIDPointer, |
| Package: "memory", |
| Name: "Pointer", |
| Fields: []schema.Field{ |
| {Declared: "Address", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| {Declared: "Pool", Type: &schema.Primitive{Name: "PoolID", Method: schema.Uint32}}, |
| }, |
| } |
| |
| type binaryClassRange struct{} |
| |
| func (*Range) Class() binary.Class { |
| return (*binaryClassRange)(nil) |
| } |
| func doEncodeRange(e binary.Encoder, o *Range) error { |
| if err := e.Uint64(o.Base); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.Size); 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.Base = uint64(obj) |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.Size = uint64(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: "memory", |
| Name: "Range", |
| Fields: []schema.Field{ |
| {Declared: "Base", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| {Declared: "Size", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| }, |
| } |
| |
| var ConstantValues schema.Constants |
| |
| const _PoolID_name = "ApplicationPool" |
| |
| var _PoolID_map = map[PoolID]string{} |
| |
| func init() { |
| _PoolID_map[0] = _PoolID_name[0:15] |
| |
| ConstantValues = append(ConstantValues, schema.ConstantSet{ |
| Type: &schema.Primitive{Name: "PoolID", Method: schema.Uint32}, |
| Entries: []schema.Constant{ |
| {Name: _PoolID_name[0:15], Value: uint32(0)}, |
| }, |
| }) |
| } |
| |
| func (v PoolID) String() string { |
| if s, ok := _PoolID_map[v]; ok { |
| return s |
| } |
| return fmt.Sprintf("PoolID(%d)", v) |
| } |
| |
| func (v *PoolID) Parse(s string) error { |
| for k, t := range _PoolID_map { |
| if s == t { |
| *v = k |
| return nil |
| } |
| } |
| return fmt.Errorf("%s not in PoolID", s) |
| } |