binary/generate/go.tmpl - platform/tools/gpu - Git at Google

 {{/*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */}}

 {{define "Go.ID"}} {{.IDName}} = binary.ID{ {{range .ID}}{{printf "0x%2.2x" .}}, {{end}} } {{end}}

 {{define "Go.Init"}} registry.Add((*{{.Name}})(nil).Class()){{end}}

 {{define "Go.Class"}} type binaryClass{{.Name}} struct{}
 func (*{{.Name}}) Class() binary.Class {
 	return (*binaryClass{{.Name}})(nil)
 }
 func doEncode{{.Name}}(e binary.Encoder, o *{{.Name}}) error {
 	{{range .Fields}}{{Encode (print "o." .Name) .Type}}
 {{end}} return nil
 }
 func doDecode{{.Name}}(d binary.Decoder, o *{{.Name}}) error {
 	{{range .Fields}}{{Decode (print "o." .Name) .Type}}
 {{end}} return nil
 }
 func doSkip{{.Name}}(d binary.Decoder) error {
 	{{range .Fields}}{{Skip (print "_." .Name) .Type}}
 {{end}} return nil
 }
 func (*binaryClass{{.Name}}) ID() binary.ID { return {{.IDName}} }
 func (*binaryClass{{.Name}}) New() binary.Object { return &{{.Name}}{} }
 func (*binaryClass{{.Name}}) Encode(e binary.Encoder, obj binary.Object) error {return doEncode{{.Name}}(e, obj.(*{{.Name}})) }
 func (*binaryClass{{.Name}}) Decode(d binary.Decoder) (binary.Object, error) {obj := &{{.Name}}{}; return obj, doDecode{{.Name}}(d, obj) }
 func (*binaryClass{{.Name}}) DecodeTo(d binary.Decoder, obj binary.Object) error {return doDecode{{.Name}}(d, obj.(*{{.Name}})) }
 func (*binaryClass{{.Name}}) Skip(d binary.Decoder) error {return doSkip{{.Name}}(d) }
 func (*binaryClass{{.Name}}) Schema() *{{SchemaPrefix}}Class { return schema{{.Name}} }
 var schema{{.Name}} = &{{SchemaPrefix}}Class{
 	TypeID: {{.IDName}},
 	Name: "{{.Name}}",
 	Fields: []{{SchemaPrefix}}Field{
 		{{range .Fields}}{{SchemaPrefix}}Field{ Declared:"{{.Name}}", Type:{{Schema .Type}} },
 	{{end}} },
 }
 {{end}}

 {{define "Go.EncodePrimitive"}}{{/*
 */}}{{if eq .Type.Native .Type.Name}}{{/*
 */}}if err := e.{{.Type.Method}}({{.Name}}); err != nil { return err } {{/*
 */}}{{else}}{{/*
 */}}if err := e.{{.Type.Method}}({{.Type.Native}}({{.Name}})); err != nil { return err } {{/*
 */}}{{end}}{{end}}

 {{define "Go.EncodeStruct"}} if err := e.Value(&{{.Name}}); err != nil { return err } {{end}}

 {{define "Go.EncodePointer"}} if {{.Name}} != nil {
 			if err := e.Object({{.Name}}); err != nil {
 				return err
 			}
 		} else if err := e.Object(nil); err != nil {
 			return err
 		} {{end}}

 {{define "Go.EncodeInterface"}} if {{.Name}} != nil {
 			if err := e.Object({{.Name}}); err != nil {
 				return err
 			}
 		} else if err := e.Object(nil); err != nil {
 			return err
 		} {{end}}

 {{define "Go.EncodeSlice"}} if err := e.Uint32(uint32(len({{.Name}}))); err != nil {
 			return err
 		}
 		{{$vt := print .Type.ValueType}}{{if or (eq $vt "uint8") (eq $vt "byte")}} if err := e.Data({{.Name}}); err != nil { return err} {{else}}{{/*
 		*/}} for i := range {{.Name}} {
 			{{Encode (print .Name "[i]") .Type.ValueType}}
 		}{{end}} {{end}}

 {{define "Go.EncodeArray"}} for i := range {{.Name}} {
 			{{Encode (print .Name "[i]") .Type.ValueType}}
 		}{{end}}

 {{define "Go.EncodeStream"}}for _, o := range {{.Name}} {
 			if err := e.Object(o); err != nil {
 				return err
 			}
 		}
 		if err := e.Object((*objects.Terminator)(nil)); err != nil {
 			return err
 		}{{end}}

 {{define "Go.EncodeMap"}} if err := e.Uint32(uint32(len({{.Name}}))); err != nil {
 			return err
 		}
 		for k, v := range {{.Name}} {
 			{{Encode "k" .Type.KeyType}}
 			{{Encode "v" .Type.ValueType}}
 		} {{end}}

 {{define "Go.DecodePrimitive"}} if obj, err := d.{{.Type.Method}}(); err != nil {
 			return err
 		} else {
 			{{.Name}} = {{.Type.Name}}(obj)
 		} {{end}}

 {{define "Go.DecodeStruct"}} if err := d.Value(&{{.Name}}); err != nil { return err } {{end}}

 {{define "Go.DecodePointer"}} if obj, err := d.Object(); err != nil {
 			return err
 		} else if obj != nil {
 			{{.Name}} = obj.({{.Type}})
 		} else {
 			{{.Name}} = nil
 		} {{end}}

 {{define "Go.DecodeInterface"}} if obj, err := d.Object(); err != nil {
 			return err
 		} else if obj != nil {
 			{{.Name}} = obj.({{.Type.Name}})
 		} else {
 			{{.Name}} = nil
 		} {{end}}

 {{define "Go.DecodeSlice"}} if count, err := d.Uint32(); err != nil {
 			return err
 		} else {
 			{{.Name}} = make({{.Type}}, count)
 			{{$vt := print .Type.ValueType}}{{if or (eq $vt "uint8") (eq $vt "byte")}} if err := d.Data({{.Name}}); err != nil { return err} {{else}}{{/*
 			*/}} for i := range {{.Name}} {
 				{{Decode (print .Name "[i]") .Type.ValueType}}
 			}{{end}}
 		} {{end}}

 {{define "Go.DecodeArray"}} for i := range {{.Name}} {
 				{{Decode (print .Name "[i]") .Type.ValueType}}
 			}{{end}}

 {{define "Go.DecodeStream"}}for {
 			if obj, err := d.Object(); err != nil {
 				return err
 			} else if _, end := obj.(*objects.Terminator); end {
 				break
 			} else {
 				{{.Name}} = append({{.Name}}, obj.({{.Type.ValueType}}))
 			}
 		} {{end}}

 {{define "Go.DecodeMap"}} if count, err := d.Uint32(); err != nil {
 			return err
 		} else {
 			{{.Name}} = make({{.Type}}, count)
 			m := {{.Name}}
 			for i := uint32(0); i < count; i++ {
 				var k {{.Type.KeyType}}
 				var v {{.Type.ValueType}}
 				{{Decode "k" .Type.KeyType}}
 				{{Decode "v" .Type.ValueType}}
 				m[k] = v
 			}
 		} {{end}}

 {{define "Go.SkipPrimitive"}}{{if .Type.Method.Skippable}}if err := d.Skip{{.Type.Method}}(); err != nil {
 	return err
 } {{else}}if _,err := d.{{.Type.Method}}(); err != nil {
 		return err
 } {{end}} {{end}}
 {{define "Go.SkipStruct"}} if err := d.SkipValue((*{{.Type.Name}})(nil)); err != nil { return err } {{end}}
 {{define "Go.SkipPointer"}} if _, err := d.SkipObject(); err != nil { return err } {{end}}
 {{define "Go.SkipInterface"}} if _, err := d.SkipObject(); err != nil { return err } {{end}}

 {{define "Go.SkipSlice"}} if count, err := d.Uint32(); err != nil {
 			return err
 		} else {
 			{{$vt := print .Type.ValueType}}{{if or (eq $vt "uint8") (eq $vt "byte")}} if err := d.Skip(count); err != nil { return err} {{else}}{{/*
 			*/}} for i := uint32(0); i < count; i++ {
 				{{Skip (print .Name "[i]") .Type.ValueType}}
 			}{{end}}
 		} {{end}}

 {{define "Go.SkipArray"}}for i := uint32(0); i < {{.Type.Length}}; i++ {
 			{{Skip (print .Name "[i]") .Type.ValueType}}
 		}{{end}}


 {{define "Go.SkipStream"}}for {
 			if id, err := d.SkipObject(); err != nil {
 				return err
 			} else if id == objects.TerminatorID {
 				break
 			}
 		} {{end}}

 {{define "Go.SkipMap"}} if count, err := d.Uint32(); err != nil {
 			return err
 		} else {
 			for i := uint32(0); i < count; i++ {
 				{{Skip "k" .Type.KeyType}}
 				{{Skip "v" .Type.ValueType}}
 			}
 		} {{end}}

 {{define "Go.SchemaPrimitive"}}&{{SchemaPrefix}}Primitive{ Name: "{{.Name}}", Method: {{SchemaPrefix}}{{.Method}} }{{end}}
 {{define "Go.SchemaStruct"}}&{{SchemaPrefix}}Struct{Name: "{{.Name}}"}{{end}}
 {{define "Go.SchemaPointer"}}&{{SchemaPrefix}}Pointer{ Type: {{Schema .Type}} }{{end}}
 {{define "Go.SchemaInterface"}}&{{SchemaPrefix}}Interface{ Name: "{{.Name}}"}{{end}}
 {{define "Go.SchemaSlice"}}&{{SchemaPrefix}}Slice{Alias: "{{.Alias}}", ValueType: {{Schema .ValueType}} }{{end}}
 {{define "Go.SchemaArray"}}&{{SchemaPrefix}}Array{Alias: "{{.Alias}}", ValueType: {{Schema .ValueType}}, Size: {{.Size}} }{{end}}
 {{define "Go.SchemaStream"}}&{{SchemaPrefix}}Stream{Alias: "{{.Alias}}", ValueType: {{Schema .ValueType}} }{{end}}
 {{define "Go.SchemaMap"}}&{{SchemaPrefix}}Map{Alias: "{{.Alias}}", KeyType: {{Schema .KeyType}}, ValueType: {{Schema .ValueType}} }{{end}}

 {{define "Go.Constants"}}{{if Directive (print .Type ".String") true}}{{$name := print .Type}}{{$c := Counter "Go.Constants"}}
 const _{{$name}}_name = "{{range .Values}}{{.Name}}{{end}}"
 var _{{$name}}_map = map[{{.Type}}]string{ {{$c.Set 0}}{{range .Values}}
 	{{.Value}}: _{{$name}}_name[{{$c}}:{{$c.AddLen .Name}}{{$c}}],{{end}}
 }

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

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

 {{define "Go.File"}}
 {{$.Copyright}}

 package {{.Package}}

 import (
 	"reflect"
 	"android.googlesource.com/platform/tools/gpu/binary/registry"
 	{{range $imp, $v := .Imports}}"{{$imp}}"
 {{end}})

 func init() {
 	{{range .Structs}}{{template "Go.Init" .}}
 	{{end}} }

 var (
 {{range .Structs}} {{template "Go.ID" .}}
 {{end}} )

 {{range .Structs}} {{template "Go.Class" .}}
 {{end}}

 {{range .Constants}}{{template "Go.Constants" .}}
 {{end}}
 {{end}}
	{{/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/}}

	{{define "Go.ID"}} {{.IDName}} = binary.ID{ {{range .ID}}{{printf "0x%2.2x" .}}, {{end}} } {{end}}

	{{define "Go.Init"}} registry.Add((*{{.Name}})(nil).Class()){{end}}

	{{define "Go.Class"}} type binaryClass{{.Name}} struct{}
	func (*{{.Name}}) Class() binary.Class {
	return (*binaryClass{{.Name}})(nil)
	}
	func doEncode{{.Name}}(e binary.Encoder, o *{{.Name}}) error {
	{{range .Fields}}{{Encode (print "o." .Name) .Type}}
	{{end}} return nil
	}
	func doDecode{{.Name}}(d binary.Decoder, o *{{.Name}}) error {
	{{range .Fields}}{{Decode (print "o." .Name) .Type}}
	{{end}} return nil
	}
	func doSkip{{.Name}}(d binary.Decoder) error {
	{{range .Fields}}{{Skip (print "_." .Name) .Type}}
	{{end}} return nil
	}
	func (*binaryClass{{.Name}}) ID() binary.ID { return {{.IDName}} }
	func (*binaryClass{{.Name}}) New() binary.Object { return &{{.Name}}{} }
	func (binaryClass{{.Name}}) Encode(e binary.Encoder, obj binary.Object) error {return doEncode{{.Name}}(e, obj.({{.Name}})) }
	func (*binaryClass{{.Name}}) Decode(d binary.Decoder) (binary.Object, error) {obj := &{{.Name}}{}; return obj, doDecode{{.Name}}(d, obj) }
	func (binaryClass{{.Name}}) DecodeTo(d binary.Decoder, obj binary.Object) error {return doDecode{{.Name}}(d, obj.({{.Name}})) }
	func (*binaryClass{{.Name}}) Skip(d binary.Decoder) error {return doSkip{{.Name}}(d) }
	func (binaryClass{{.Name}}) Schema() {{SchemaPrefix}}Class { return schema{{.Name}} }
	var schema{{.Name}} = &{{SchemaPrefix}}Class{
	TypeID: {{.IDName}},
	Name: "{{.Name}}",
	Fields: []{{SchemaPrefix}}Field{
	{{range .Fields}}{{SchemaPrefix}}Field{ Declared:"{{.Name}}", Type:{{Schema .Type}} },
	{{end}} },
	}
	{{end}}

	{{define "Go.EncodePrimitive"}}{{/*
	/}}{{if eq .Type.Native .Type.Name}}{{/
	/}}if err := e.{{.Type.Method}}({{.Name}}); err != nil { return err } {{/
	/}}{{else}}{{/
	/}}if err := e.{{.Type.Method}}({{.Type.Native}}({{.Name}})); err != nil { return err } {{/
	*/}}{{end}}{{end}}

	{{define "Go.EncodeStruct"}} if err := e.Value(&{{.Name}}); err != nil { return err } {{end}}

	{{define "Go.EncodePointer"}} if {{.Name}} != nil {
	if err := e.Object({{.Name}}); err != nil {
	return err
	}
	} else if err := e.Object(nil); err != nil {
	return err
	} {{end}}

	{{define "Go.EncodeInterface"}} if {{.Name}} != nil {
	if err := e.Object({{.Name}}); err != nil {
	return err
	}
	} else if err := e.Object(nil); err != nil {
	return err
	} {{end}}

	{{define "Go.EncodeSlice"}} if err := e.Uint32(uint32(len({{.Name}}))); err != nil {
	return err
	}
	{{$vt := print .Type.ValueType}}{{if or (eq $vt "uint8") (eq $vt "byte")}} if err := e.Data({{.Name}}); err != nil { return err} {{else}}{{/*
	*/}} for i := range {{.Name}} {
	{{Encode (print .Name "[i]") .Type.ValueType}}
	}{{end}} {{end}}

	{{define "Go.EncodeArray"}} for i := range {{.Name}} {
	{{Encode (print .Name "[i]") .Type.ValueType}}
	}{{end}}

	{{define "Go.EncodeStream"}}for _, o := range {{.Name}} {
	if err := e.Object(o); err != nil {
	return err
	}
	}
	if err := e.Object((*objects.Terminator)(nil)); err != nil {
	return err
	}{{end}}

	{{define "Go.EncodeMap"}} if err := e.Uint32(uint32(len({{.Name}}))); err != nil {
	return err
	}
	for k, v := range {{.Name}} {
	{{Encode "k" .Type.KeyType}}
	{{Encode "v" .Type.ValueType}}
	} {{end}}

	{{define "Go.DecodePrimitive"}} if obj, err := d.{{.Type.Method}}(); err != nil {
	return err
	} else {
	{{.Name}} = {{.Type.Name}}(obj)
	} {{end}}

	{{define "Go.DecodeStruct"}} if err := d.Value(&{{.Name}}); err != nil { return err } {{end}}

	{{define "Go.DecodePointer"}} if obj, err := d.Object(); err != nil {
	return err
	} else if obj != nil {
	{{.Name}} = obj.({{.Type}})
	} else {
	{{.Name}} = nil
	} {{end}}

	{{define "Go.DecodeInterface"}} if obj, err := d.Object(); err != nil {
	return err
	} else if obj != nil {
	{{.Name}} = obj.({{.Type.Name}})
	} else {
	{{.Name}} = nil
	} {{end}}

	{{define "Go.DecodeSlice"}} if count, err := d.Uint32(); err != nil {
	return err
	} else {
	{{.Name}} = make({{.Type}}, count)
	{{$vt := print .Type.ValueType}}{{if or (eq $vt "uint8") (eq $vt "byte")}} if err := d.Data({{.Name}}); err != nil { return err} {{else}}{{/*
	*/}} for i := range {{.Name}} {
	{{Decode (print .Name "[i]") .Type.ValueType}}
	}{{end}}
	} {{end}}

	{{define "Go.DecodeArray"}} for i := range {{.Name}} {
	{{Decode (print .Name "[i]") .Type.ValueType}}
	}{{end}}

	{{define "Go.DecodeStream"}}for {
	if obj, err := d.Object(); err != nil {
	return err
	} else if _, end := obj.(*objects.Terminator); end {
	break
	} else {
	{{.Name}} = append({{.Name}}, obj.({{.Type.ValueType}}))
	}
	} {{end}}

	{{define "Go.DecodeMap"}} if count, err := d.Uint32(); err != nil {
	return err
	} else {
	{{.Name}} = make({{.Type}}, count)
	m := {{.Name}}
	for i := uint32(0); i < count; i++ {
	var k {{.Type.KeyType}}
	var v {{.Type.ValueType}}
	{{Decode "k" .Type.KeyType}}
	{{Decode "v" .Type.ValueType}}
	m[k] = v
	}
	} {{end}}

	{{define "Go.SkipPrimitive"}}{{if .Type.Method.Skippable}}if err := d.Skip{{.Type.Method}}(); err != nil {
	return err
	} {{else}}if _,err := d.{{.Type.Method}}(); err != nil {
	return err
	} {{end}} {{end}}
	{{define "Go.SkipStruct"}} if err := d.SkipValue((*{{.Type.Name}})(nil)); err != nil { return err } {{end}}
	{{define "Go.SkipPointer"}} if _, err := d.SkipObject(); err != nil { return err } {{end}}
	{{define "Go.SkipInterface"}} if _, err := d.SkipObject(); err != nil { return err } {{end}}

	{{define "Go.SkipSlice"}} if count, err := d.Uint32(); err != nil {
	return err
	} else {
	{{$vt := print .Type.ValueType}}{{if or (eq $vt "uint8") (eq $vt "byte")}} if err := d.Skip(count); err != nil { return err} {{else}}{{/*
	*/}} for i := uint32(0); i < count; i++ {
	{{Skip (print .Name "[i]") .Type.ValueType}}
	}{{end}}
	} {{end}}

	{{define "Go.SkipArray"}}for i := uint32(0); i < {{.Type.Length}}; i++ {
	{{Skip (print .Name "[i]") .Type.ValueType}}
	}{{end}}


	{{define "Go.SkipStream"}}for {
	if id, err := d.SkipObject(); err != nil {
	return err
	} else if id == objects.TerminatorID {
	break
	}
	} {{end}}

	{{define "Go.SkipMap"}} if count, err := d.Uint32(); err != nil {
	return err
	} else {
	for i := uint32(0); i < count; i++ {
	{{Skip "k" .Type.KeyType}}
	{{Skip "v" .Type.ValueType}}
	}
	} {{end}}

	{{define "Go.SchemaPrimitive"}}&{{SchemaPrefix}}Primitive{ Name: "{{.Name}}", Method: {{SchemaPrefix}}{{.Method}} }{{end}}
	{{define "Go.SchemaStruct"}}&{{SchemaPrefix}}Struct{Name: "{{.Name}}"}{{end}}
	{{define "Go.SchemaPointer"}}&{{SchemaPrefix}}Pointer{ Type: {{Schema .Type}} }{{end}}
	{{define "Go.SchemaInterface"}}&{{SchemaPrefix}}Interface{ Name: "{{.Name}}"}{{end}}
	{{define "Go.SchemaSlice"}}&{{SchemaPrefix}}Slice{Alias: "{{.Alias}}", ValueType: {{Schema .ValueType}} }{{end}}
	{{define "Go.SchemaArray"}}&{{SchemaPrefix}}Array{Alias: "{{.Alias}}", ValueType: {{Schema .ValueType}}, Size: {{.Size}} }{{end}}
	{{define "Go.SchemaStream"}}&{{SchemaPrefix}}Stream{Alias: "{{.Alias}}", ValueType: {{Schema .ValueType}} }{{end}}
	{{define "Go.SchemaMap"}}&{{SchemaPrefix}}Map{Alias: "{{.Alias}}", KeyType: {{Schema .KeyType}}, ValueType: {{Schema .ValueType}} }{{end}}

	{{define "Go.Constants"}}{{if Directive (print .Type ".String") true}}{{$name := print .Type}}{{$c := Counter "Go.Constants"}}
	const _{{$name}}_name = "{{range .Values}}{{.Name}}{{end}}"
	var _{{$name}}_map = map[{{.Type}}]string{ {{$c.Set 0}}{{range .Values}}
	{{.Value}}: _{{$name}}_name[{{$c}}:{{$c.AddLen .Name}}{{$c}}],{{end}}
	}

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

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

	{{define "Go.File"}}
	{{$.Copyright}}

	package {{.Package}}

	import (
	"reflect"
	"android.googlesource.com/platform/tools/gpu/binary/registry"
	{{range $imp, $v := .Imports}}"{{$imp}}"
	{{end}})

	func init() {
	{{range .Structs}}{{template "Go.Init" .}}
	{{end}} }

	var (
	{{range .Structs}} {{template "Go.ID" .}}
	{{end}} )

	{{range .Structs}} {{template "Go.Class" .}}
	{{end}}

	{{range .Constants}}{{template "Go.Constants" .}}
	{{end}}
	{{end}}