rpc/generate/rpc.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.
  */}}

 {{Global "module" ""}}
 {{Include "rpc_common_go.tmpl"}}
 {{$api := Global "API"}}
 {{$ | Macro "Rpc" "role" "" "api" | GoFmt | Write (print $api "_rpc.go")}}
 {{$ | Macro "Rpc" "role" "Extra" "api" | GoFmt | Write (print $api "_extra.go")}}
 {{$ | Macro "Rpc" "role" "Helpers" "api" | GoFmt | Write (print $api "_helpers.go")}}
 {{$ | Macro "Client" | GoFmt | Write (print $api "_client.go")}}
 {{$ | Macro "Server" | GoFmt | Write (print $api "_server.go")}}

 {{define "Rpc"}}
   {{template "GeneratedHeader"}}
   {{Macro (print "Imports" $.role) $.api}}
 ¶
   {{range $i, $c := $.api.Functions}}
     {{Macro (print "Call" $.role)   $c}}
     {{Macro (print "Result" $.role) $c}}
   {{end}}
 ¶
   {{range $_, $h := $.api.Pseudonyms}}
     {{if GetAnnotation $h "handle"}}
       {{Macro (print "Handle" $.role) $h}}
     {{end}}
   {{end}}
 ¶
   {{range $_, $a := $.api.Slices}}
     {{Macro (print "Array" $.role) $a}}
   {{end}}
 ¶
   {{range $_, $e := $.api.Enums}}
     {{Macro (print "Enum" $.role) $e}}
   {{end}}
 ¶
   {{range $i, $c := $.api.Classes}}
     {{if GetAnnotation $c "Interface"}}
       {{Macro (print "Interface" $.role) $c}}¶
     {{end}}
   {{end}}
 ¶
   {{range $i, $c := $.api.Classes}}
     {{if not (GetAnnotation $c "Interface")}}
       {{Macro (print "Class" $.role) $c}}¶
     {{end}}
   {{end}}
 {{end}}


 {{define "Imports"}}
   package {{Global "OutputDir"}};

   import (
     "android.googlesource.com/platform/tools/gpu/binary"
     "android.googlesource.com/platform/tools/gpu/log"
   )

   type RPC interface {
     {{range $_, $c := $.Functions}}
       {{Macro "RpcInterfaceMethod" $c}}
     {{end}}
   }
 {{end}}

 {{define "ImportsExtra"}}
   package {{Global "OutputDir"}};
 {{end}}

 {{define "ImportsHelpers"}}
   package {{Global "OutputDir"}};

   import (
     "fmt"
     "android.googlesource.com/platform/tools/gpu/binary"
   )
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the interface method declaration for a single RPC command.
 -------------------------------------------------------------------------------
 */}}
 {{define "RpcInterfaceMethod"}}
   {{AssertType $ "Function"}}

   {{Macro "VerifyInterfaceReturnTypeIsRef" $}}
   {{$.Name}}(l log.Logger, {{Macro "Parameters" $}})§
     ({{if not (IsVoid $.Return.Type)}}{{Macro "Type" $.Return.Type}}, {{end}}error)
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits a comma-separated list of command parameters (name followed by type).
 -------------------------------------------------------------------------------
 */}}
 {{define "Parameters"}}
   {{AssertType $ "Function"}}

   {{range $i, $p := $.CallParameters}}
     {{if $i}},{{end}}§
     {{Macro "Parameter" "Parameter" $p "Command" $}}§
   {{end}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits a comma-separated list of command arguments (names).
 -------------------------------------------------------------------------------
 */}}
 {{define "Arguments"}}
   {{AssertType $ "Function"}}

   {{range $i, $p := $.CallParameters}}{{if $i}}, {{end}}§{{$p.Name}}:{{$p.Name}}{{end}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits a single command parameter (name followed by type).
 -------------------------------------------------------------------------------
 */}}
 {{define "Parameter"}}
   {{AssertType $.Parameter "Parameter"}}
   {{AssertType $.Command "Function"}}
   {{Macro "VerifyInterfaceParameterIsRef" "Parameter" $.Parameter "Command" $.Command}}

   {{$.Parameter.Name}} {{Macro "Type" (TypeOf $.Parameter)}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Walks a class hierarchy to visit all the fields, calling the specified macro
   for each field.
 -------------------------------------------------------------------------------
 */}}
 {{define "AllFields"}}
   {{AssertType $.Class "Class"}}
   {{AssertType $.Macro "string"}}

   {{Macro "TraverseFields" "Impl" $.Class "Class" $.Class "Macro" $.Macro}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Walks a class hierarchy to visit all the fields, calling the specified macro
   for each field.
 -------------------------------------------------------------------------------
 */}}
 {{define "TraverseFields"}}
   {{AssertType $.Impl  "Class"}}
   {{AssertType $.Class "Class"}}
   {{AssertType $.Macro "string"}}

   {{range $_, $e := $.Class.Extends}}
     {{Macro "TraverseFields" "Impl" $.Impl "Class" $e "Macro" $.Macro}}
   {{end}}
   {{range $_, $f := $.Class.Fields}}
     {{Macro $.Macro "Impl" $.Impl "Class" $.Class "Field" $f}}
   {{end}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Declares a single field accessor (getter) of an interface.
 -------------------------------------------------------------------------------
 */}}
 {{define "DeclareInterfaceFieldAccessor"}}
   {{AssertType $.Field "Field"}}

   Get{{$.Field.Name}}() {{Macro "Type" (TypeOf $.Field)}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Declares a single class field.
 -------------------------------------------------------------------------------
 */}}
 {{define "DeclareClassField"}}
   {{AssertType $.Field "Field"}}

   {{$.Field.Name}} {{Macro "Type" (TypeOf $.Field)}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits a single field parameter name-type pair for the constructor of a class.
 -------------------------------------------------------------------------------
 */}}
 {{define "CreateClassParameter"}}
   {{AssertType $.Field "Field"}}

   {{$.Field.Name}} {{Macro "Type" (TypeOf $.Field)}},
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits a the initializer for a single class field.
 -------------------------------------------------------------------------------
 */}}
 {{define "AssignClassParameter"}}
   {{AssertType $.Field "Field"}}

   {{$.Field.Name}}: {{$.Field.Name}},
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits a single field accessor (getter) for a concrete class.
 -------------------------------------------------------------------------------
 */}}
 {{define "DefineClassFieldAccessor"}}
   {{AssertType $.Field "Field"}}
   {{AssertType $.Impl  "Class"}}

   func (c *{{$.Impl.Name}}) Get{{$.Field.Name}}() {{Macro "Type" (TypeOf $.Field)}} { return c.{{$.Field.Name}} }
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the interface of a class annotated with @Interface.
 -------------------------------------------------------------------------------
 */}}
 {{define "Interface"}}
   {{AssertType $ "Class"}}

   {{$iname := $.Name}}
   // Interface {{$.Name}}
   type {{$iname}} interface {
     {{if eq (len $.Extends) 0}}
       binary.Object
     {{end}}
     {{Macro "AllFields" "Class" $ "Macro" "DeclareInterfaceFieldAccessor"}}
   }
 {{end}}
 {{define "InterfaceExtra"}}{{end}}
 {{define "InterfaceHelpers"}}{{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the implementation of a class.
 -------------------------------------------------------------------------------
 */}}
 {{define "Class"}}
   {{AssertType $ "Class"}}

   {{Macro "AllFields" "Class" $ "Macro" "VerifyInterfaceFieldIsRef"}}

   // Class {{$.Name}}
   type {{$.Name}} struct {
     binary.Generate
     {{Macro "AllFields" "Class" $ "Macro" "DeclareClassField"}}
   }
 {{end}}

 {{define "ClassExtra"}}{{end}}

 {{define "ClassHelpers"}}
   func Create{{$.Name}}(
     {{Macro "AllFields" "Class" $ "Macro" "CreateClassParameter"}}
   ) *{{$.Name}} {
     return &{{$.Name}} {
       {{Macro "AllFields" "Class" $ "Macro" "AssignClassParameter"}}
     }
   }
 ¶
   {{Macro "AllFields" "Class" $ "Macro" "DefineClassFieldAccessor"}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the encoder of a handle.
 -------------------------------------------------------------------------------
 */}}
 {{define "Handle"}}
   {{AssertType $ "Pseudonym"}}

   // Handle {{$.Name}}
   type {{$.Name}} struct {
     binary.Generate
     ID binary.ID
  }
 {{end}}

 {{define "HandleExtra"}}{{end}}
 {{define "HandleHelpers"}}
 func (h {{$.Name}}) Valid() bool {
   return h.ID.Valid()
 }
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the definition of an array.
 -------------------------------------------------------------------------------
 */}}
 {{define "Array"}}
   {{AssertType $ "Slice"}}

   // Array {{$.Name}}
   type {{Macro "Type" $}} []{{Macro "Type" $.To}}
 {{end}}

 {{define "ArrayExtra"}}
   {{AssertType $ "Slice"}}
 {{end}}

 {{define "ArrayHelpers"}}
   {{AssertType $ "Slice"}}

   func (a {{Macro "Type" $}}) Format(f fmt.State, c rune) {
     fmt.Fprintf(f, "[%d]{{$.Name}}", len(a))
   }
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the definition of an enum.
 -------------------------------------------------------------------------------
 */}}
 {{define "Enum"}}
   {{AssertType $ "Enum"}}

   // Enum {{$.Name}}
   type {{$.Name}} int
 ¶
   const (
     {{range $_, $e := $.Entries}}
       {{$.Name}}{{$e.Name}} {{$.Name}}= {{$e.Value}}
     {{end}}
   )
 {{end}}

 {{define "EnumExtra"}}
   {{AssertType $ "Enum"}}
 {{end}}

 {{define "EnumHelpers"}}
   {{AssertType $ "Enum"}}

   {{range $_, $e := $.Entries}}
     func (i {{$.Name}}) Is{{$e.Name}}() bool { return i == {{$.Name}}{{$e.Name}} }
   {{end}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the name of the call type for a single command.
 -------------------------------------------------------------------------------
 */}}
 {{define "CallName"}}
   {{AssertType $ "Function"}}

   {{print "call" $.Name}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the name of the result type for a single command.
 -------------------------------------------------------------------------------
 */}}
 {{define "ResultName"}}
   {{AssertType $ "Function"}}

   {{print "result" $.Name}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the call structure for a single command.
 -------------------------------------------------------------------------------
 */}}
 {{define "Call"}}
   {{AssertType $ "Function"}}
 {{end}}

 {{define "CallExtra"}}
   {{AssertType $ "Function"}}

   // Call {{$.Name}}
   type {{Macro "CallName" $}} struct {
     binary.Generate
     {{range $i, $p := $.CallParameters}}
       {{$p.Name}} {{Macro "Type" (TypeOf $p)}}
     {{end}}
   }
 {{end}}

 {{define "CallHelpers"}}
   {{AssertType $ "Function"}}

   func (c {{Macro "CallName" $}}) Format(f fmt.State, r rune) {
     fmt.Fprintf(f, "{{$.Name}}(§
       {{range $i, $p := $.CallParameters}}{{if $i}}, {{end}}{{$p.Name}}: %v{{end}})",
       {{range $i, $p := $.CallParameters}}c.{{$p.Name}},{{end}}
     )
   }
 {{end}}

 {{/*
 -------------------------------------------------------------------------------
   Emits the result structure for a single command.
 -------------------------------------------------------------------------------
 */}}
 {{define "Result"}}
   {{AssertType $ "Function"}}
 {{end}}

 {{define "ResultExtra"}}
   {{AssertType $ "Function"}}

   // Result {{$.Name}}
   type {{Macro "ResultName" $}} struct {
     binary.Generate
     {{if not (IsVoid $.Return.Type)}}
       value {{Macro "Type" $.Return.Type}}
     {{end}}
   }
 {{end}}

 {{define "ResultHelpers"}}
   {{AssertType $ "Function"}}

   func (r {{Macro "ResultName" $}}) Format(f fmt.State, c rune) {
     {{if not (IsVoid $.Return.Type)}}
       fmt.Fprintf(f, "res: %#v", r.value)
     {{else}}
       fmt.Fprintf(f, "void")
     {{end}}
   }
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the RPC client implementation
 -------------------------------------------------------------------------------
 */}}
 {{define "Client"}}
   {{AssertType $ "API"}}

   {{template "GeneratedHeader"}}
   package {{Global "OutputDir"}};

   import (
     "io"

     "android.googlesource.com/platform/tools/gpu/log"
     "android.googlesource.com/platform/tools/gpu/rpc"
   )

   type client struct {
     rpc.Client
   }

   func CreateClient(r io.Reader, w io.Writer, mtu int) RPC {
     return client{rpc.NewClient(r, w, mtu)}
   }

   // Client compliance
   {{range $_, $c := $.Functions}}
     {{if not (IsVoid $c.Return.Type)}}
       func (c client) {{$c.Name}}(l log.Logger, {{Macro "Parameters" $c}}) (res {{Macro "Type" $c.Return.Type}}, err error) {
         var val interface{}
         if val, err = c.Send(&{{Macro "CallName" $c}}{ {{Macro "Arguments" $c}} }); err == nil {
           res = val.(*{{Macro "ResultName" $c}}).value
         } else {
           l.Errorf("RPC {{$c.Name}} failed with error: %v", err)
         }
         return
       }
     {{else}}
       func (c client) {{$c.Name}}(l log.Logger, {{Macro "Parameters" $c}}) error {
         _, err := c.Send(&{{Macro "CallName" $c}}{ {{Macro "Arguments" $c}} })
         return err
       }
     {{end}}
     ¶
   {{end}}
 {{end}}


 {{/*
 -------------------------------------------------------------------------------
   Emits the RPC server implementation
 -------------------------------------------------------------------------------
 */}}
 {{define "Server"}}
   {{AssertType $ "API"}}

   {{template "GeneratedHeader"}}
   package {{Global "OutputDir"}};

   import (
     "fmt"
     "io"
     "runtime/debug"

     "android.googlesource.com/platform/tools/gpu/log"
     "android.googlesource.com/platform/tools/gpu/rpc"
   )

   func BindServer(r io.Reader, w io.Writer, mtu int, l log.Logger, server RPC) {
     rpc.Serve(l, r, w, mtu, func(in interface{}) (res binary.Object) {
       l := l.Fork().Enter(fmt.Sprintf("%v", in))
       defer func() {
         if err := recover(); err == nil {
           l.Infof("↪ %v", res)
         } else {
           msg := fmt.Sprintf("Panic: %v\n%v", err, string(debug.Stack()))
           l.Errorf(msg)
           res = rpc.NewError(msg)
         }
       }()

       switch call := in.(type) {
         {{range $i, $c := $.Functions}}
           case *{{Macro "CallName" $c}}:
             {{if not (IsVoid $c.Return.Type)}}
               if res, err := server.{{$c.Name}}(l{{range $p := $c.CallParameters}}, call.{{$p.Name}}{{end}}); err == nil {
                 return &{{Macro "ResultName" $c}}{ value:res }
               } else {
                 return rpc.NewError(err.Error())
               }
             {{else}}
               if err := server.{{$c.Name}}(l{{range $p := $c.CallParameters}}, call.{{$p.Name}}{{end}}); err == nil {
                 return &{{Macro "ResultName" $c}}{}
               } else {
                 return rpc.NewError(err.Error())
               }
             {{end}}
         {{end}}
           default:
             return rpc.NewError("Unexpected RPC function: %T", call)
       }
     })
   }
 {{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.
	*/}}

	{{Global "module" ""}}
	{{Include "rpc_common_go.tmpl"}}
	{{$api := Global "API"}}
	{{$ \| Macro "Rpc" "role" "" "api" \| GoFmt \| Write (print $api "_rpc.go")}}
	{{$ \| Macro "Rpc" "role" "Extra" "api" \| GoFmt \| Write (print $api "_extra.go")}}
	{{$ \| Macro "Rpc" "role" "Helpers" "api" \| GoFmt \| Write (print $api "_helpers.go")}}
	{{$ \| Macro "Client" \| GoFmt \| Write (print $api "_client.go")}}
	{{$ \| Macro "Server" \| GoFmt \| Write (print $api "_server.go")}}

	{{define "Rpc"}}
	{{template "GeneratedHeader"}}
	{{Macro (print "Imports" $.role) $.api}}
	¶
	{{range $i, $c := $.api.Functions}}
	{{Macro (print "Call" $.role) $c}}
	{{Macro (print "Result" $.role) $c}}
	{{end}}
	¶
	{{range $_, $h := $.api.Pseudonyms}}
	{{if GetAnnotation $h "handle"}}
	{{Macro (print "Handle" $.role) $h}}
	{{end}}
	{{end}}
	¶
	{{range $_, $a := $.api.Slices}}
	{{Macro (print "Array" $.role) $a}}
	{{end}}
	¶
	{{range $_, $e := $.api.Enums}}
	{{Macro (print "Enum" $.role) $e}}
	{{end}}
	¶
	{{range $i, $c := $.api.Classes}}
	{{if GetAnnotation $c "Interface"}}
	{{Macro (print "Interface" $.role) $c}}¶
	{{end}}
	{{end}}
	¶
	{{range $i, $c := $.api.Classes}}
	{{if not (GetAnnotation $c "Interface")}}
	{{Macro (print "Class" $.role) $c}}¶
	{{end}}
	{{end}}
	{{end}}


	{{define "Imports"}}
	package {{Global "OutputDir"}};

	import (
	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/log"
	)

	type RPC interface {
	{{range $_, $c := $.Functions}}
	{{Macro "RpcInterfaceMethod" $c}}
	{{end}}
	}
	{{end}}

	{{define "ImportsExtra"}}
	package {{Global "OutputDir"}};
	{{end}}

	{{define "ImportsHelpers"}}
	package {{Global "OutputDir"}};

	import (
	"fmt"
	"android.googlesource.com/platform/tools/gpu/binary"
	)
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the interface method declaration for a single RPC command.
	-------------------------------------------------------------------------------
	*/}}
	{{define "RpcInterfaceMethod"}}
	{{AssertType $ "Function"}}

	{{Macro "VerifyInterfaceReturnTypeIsRef" $}}
	{{$.Name}}(l log.Logger, {{Macro "Parameters" $}})§
	({{if not (IsVoid $.Return.Type)}}{{Macro "Type" $.Return.Type}}, {{end}}error)
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits a comma-separated list of command parameters (name followed by type).
	-------------------------------------------------------------------------------
	*/}}
	{{define "Parameters"}}
	{{AssertType $ "Function"}}

	{{range $i, $p := $.CallParameters}}
	{{if $i}},{{end}}§
	{{Macro "Parameter" "Parameter" $p "Command" $}}§
	{{end}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits a comma-separated list of command arguments (names).
	-------------------------------------------------------------------------------
	*/}}
	{{define "Arguments"}}
	{{AssertType $ "Function"}}

	{{range $i, $p := $.CallParameters}}{{if $i}}, {{end}}§{{$p.Name}}:{{$p.Name}}{{end}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits a single command parameter (name followed by type).
	-------------------------------------------------------------------------------
	*/}}
	{{define "Parameter"}}
	{{AssertType $.Parameter "Parameter"}}
	{{AssertType $.Command "Function"}}
	{{Macro "VerifyInterfaceParameterIsRef" "Parameter" $.Parameter "Command" $.Command}}

	{{$.Parameter.Name}} {{Macro "Type" (TypeOf $.Parameter)}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Walks a class hierarchy to visit all the fields, calling the specified macro
	for each field.
	-------------------------------------------------------------------------------
	*/}}
	{{define "AllFields"}}
	{{AssertType $.Class "Class"}}
	{{AssertType $.Macro "string"}}

	{{Macro "TraverseFields" "Impl" $.Class "Class" $.Class "Macro" $.Macro}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Walks a class hierarchy to visit all the fields, calling the specified macro
	for each field.
	-------------------------------------------------------------------------------
	*/}}
	{{define "TraverseFields"}}
	{{AssertType $.Impl "Class"}}
	{{AssertType $.Class "Class"}}
	{{AssertType $.Macro "string"}}

	{{range $_, $e := $.Class.Extends}}
	{{Macro "TraverseFields" "Impl" $.Impl "Class" $e "Macro" $.Macro}}
	{{end}}
	{{range $_, $f := $.Class.Fields}}
	{{Macro $.Macro "Impl" $.Impl "Class" $.Class "Field" $f}}
	{{end}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Declares a single field accessor (getter) of an interface.
	-------------------------------------------------------------------------------
	*/}}
	{{define "DeclareInterfaceFieldAccessor"}}
	{{AssertType $.Field "Field"}}

	Get{{$.Field.Name}}() {{Macro "Type" (TypeOf $.Field)}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Declares a single class field.
	-------------------------------------------------------------------------------
	*/}}
	{{define "DeclareClassField"}}
	{{AssertType $.Field "Field"}}

	{{$.Field.Name}} {{Macro "Type" (TypeOf $.Field)}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits a single field parameter name-type pair for the constructor of a class.
	-------------------------------------------------------------------------------
	*/}}
	{{define "CreateClassParameter"}}
	{{AssertType $.Field "Field"}}

	{{$.Field.Name}} {{Macro "Type" (TypeOf $.Field)}},
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits a the initializer for a single class field.
	-------------------------------------------------------------------------------
	*/}}
	{{define "AssignClassParameter"}}
	{{AssertType $.Field "Field"}}

	{{$.Field.Name}}: {{$.Field.Name}},
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits a single field accessor (getter) for a concrete class.
	-------------------------------------------------------------------------------
	*/}}
	{{define "DefineClassFieldAccessor"}}
	{{AssertType $.Field "Field"}}
	{{AssertType $.Impl "Class"}}

	func (c *{{$.Impl.Name}}) Get{{$.Field.Name}}() {{Macro "Type" (TypeOf $.Field)}} { return c.{{$.Field.Name}} }
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the interface of a class annotated with @Interface.
	-------------------------------------------------------------------------------
	*/}}
	{{define "Interface"}}
	{{AssertType $ "Class"}}

	{{$iname := $.Name}}
	// Interface {{$.Name}}
	type {{$iname}} interface {
	{{if eq (len $.Extends) 0}}
	binary.Object
	{{end}}
	{{Macro "AllFields" "Class" $ "Macro" "DeclareInterfaceFieldAccessor"}}
	}
	{{end}}
	{{define "InterfaceExtra"}}{{end}}
	{{define "InterfaceHelpers"}}{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the implementation of a class.
	-------------------------------------------------------------------------------
	*/}}
	{{define "Class"}}
	{{AssertType $ "Class"}}

	{{Macro "AllFields" "Class" $ "Macro" "VerifyInterfaceFieldIsRef"}}

	// Class {{$.Name}}
	type {{$.Name}} struct {
	binary.Generate
	{{Macro "AllFields" "Class" $ "Macro" "DeclareClassField"}}
	}
	{{end}}

	{{define "ClassExtra"}}{{end}}

	{{define "ClassHelpers"}}
	func Create{{$.Name}}(
	{{Macro "AllFields" "Class" $ "Macro" "CreateClassParameter"}}
	) *{{$.Name}} {
	return &{{$.Name}} {
	{{Macro "AllFields" "Class" $ "Macro" "AssignClassParameter"}}
	}
	}
	¶
	{{Macro "AllFields" "Class" $ "Macro" "DefineClassFieldAccessor"}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the encoder of a handle.
	-------------------------------------------------------------------------------
	*/}}
	{{define "Handle"}}
	{{AssertType $ "Pseudonym"}}

	// Handle {{$.Name}}
	type {{$.Name}} struct {
	binary.Generate
	ID binary.ID
	}
	{{end}}

	{{define "HandleExtra"}}{{end}}
	{{define "HandleHelpers"}}
	func (h {{$.Name}}) Valid() bool {
	return h.ID.Valid()
	}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the definition of an array.
	-------------------------------------------------------------------------------
	*/}}
	{{define "Array"}}
	{{AssertType $ "Slice"}}

	// Array {{$.Name}}
	type {{Macro "Type" $}} []{{Macro "Type" $.To}}
	{{end}}

	{{define "ArrayExtra"}}
	{{AssertType $ "Slice"}}
	{{end}}

	{{define "ArrayHelpers"}}
	{{AssertType $ "Slice"}}

	func (a {{Macro "Type" $}}) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]{{$.Name}}", len(a))
	}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the definition of an enum.
	-------------------------------------------------------------------------------
	*/}}
	{{define "Enum"}}
	{{AssertType $ "Enum"}}

	// Enum {{$.Name}}
	type {{$.Name}} int
	¶
	const (
	{{range $_, $e := $.Entries}}
	{{$.Name}}{{$e.Name}} {{$.Name}}= {{$e.Value}}
	{{end}}
	)
	{{end}}

	{{define "EnumExtra"}}
	{{AssertType $ "Enum"}}
	{{end}}

	{{define "EnumHelpers"}}
	{{AssertType $ "Enum"}}

	{{range $_, $e := $.Entries}}
	func (i {{$.Name}}) Is{{$e.Name}}() bool { return i == {{$.Name}}{{$e.Name}} }
	{{end}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the name of the call type for a single command.
	-------------------------------------------------------------------------------
	*/}}
	{{define "CallName"}}
	{{AssertType $ "Function"}}

	{{print "call" $.Name}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the name of the result type for a single command.
	-------------------------------------------------------------------------------
	*/}}
	{{define "ResultName"}}
	{{AssertType $ "Function"}}

	{{print "result" $.Name}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the call structure for a single command.
	-------------------------------------------------------------------------------
	*/}}
	{{define "Call"}}
	{{AssertType $ "Function"}}
	{{end}}

	{{define "CallExtra"}}
	{{AssertType $ "Function"}}

	// Call {{$.Name}}
	type {{Macro "CallName" $}} struct {
	binary.Generate
	{{range $i, $p := $.CallParameters}}
	{{$p.Name}} {{Macro "Type" (TypeOf $p)}}
	{{end}}
	}
	{{end}}

	{{define "CallHelpers"}}
	{{AssertType $ "Function"}}

	func (c {{Macro "CallName" $}}) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "{{$.Name}}(§
	{{range $i, $p := $.CallParameters}}{{if $i}}, {{end}}{{$p.Name}}: %v{{end}})",
	{{range $i, $p := $.CallParameters}}c.{{$p.Name}},{{end}}
	)
	}
	{{end}}

	{{/*
	-------------------------------------------------------------------------------
	Emits the result structure for a single command.
	-------------------------------------------------------------------------------
	*/}}
	{{define "Result"}}
	{{AssertType $ "Function"}}
	{{end}}

	{{define "ResultExtra"}}
	{{AssertType $ "Function"}}

	// Result {{$.Name}}
	type {{Macro "ResultName" $}} struct {
	binary.Generate
	{{if not (IsVoid $.Return.Type)}}
	value {{Macro "Type" $.Return.Type}}
	{{end}}
	}
	{{end}}

	{{define "ResultHelpers"}}
	{{AssertType $ "Function"}}

	func (r {{Macro "ResultName" $}}) Format(f fmt.State, c rune) {
	{{if not (IsVoid $.Return.Type)}}
	fmt.Fprintf(f, "res: %#v", r.value)
	{{else}}
	fmt.Fprintf(f, "void")
	{{end}}
	}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the RPC client implementation
	-------------------------------------------------------------------------------
	*/}}
	{{define "Client"}}
	{{AssertType $ "API"}}

	{{template "GeneratedHeader"}}
	package {{Global "OutputDir"}};

	import (
	"io"

	"android.googlesource.com/platform/tools/gpu/log"
	"android.googlesource.com/platform/tools/gpu/rpc"
	)

	type client struct {
	rpc.Client
	}

	func CreateClient(r io.Reader, w io.Writer, mtu int) RPC {
	return client{rpc.NewClient(r, w, mtu)}
	}

	// Client compliance
	{{range $_, $c := $.Functions}}
	{{if not (IsVoid $c.Return.Type)}}
	func (c client) {{$c.Name}}(l log.Logger, {{Macro "Parameters" $c}}) (res {{Macro "Type" $c.Return.Type}}, err error) {
	var val interface{}
	if val, err = c.Send(&{{Macro "CallName" $c}}{ {{Macro "Arguments" $c}} }); err == nil {
	res = val.(*{{Macro "ResultName" $c}}).value
	} else {
	l.Errorf("RPC {{$c.Name}} failed with error: %v", err)
	}
	return
	}
	{{else}}
	func (c client) {{$c.Name}}(l log.Logger, {{Macro "Parameters" $c}}) error {
	_, err := c.Send(&{{Macro "CallName" $c}}{ {{Macro "Arguments" $c}} })
	return err
	}
	{{end}}
	¶
	{{end}}
	{{end}}


	{{/*
	-------------------------------------------------------------------------------
	Emits the RPC server implementation
	-------------------------------------------------------------------------------
	*/}}
	{{define "Server"}}
	{{AssertType $ "API"}}

	{{template "GeneratedHeader"}}
	package {{Global "OutputDir"}};

	import (
	"fmt"
	"io"
	"runtime/debug"

	"android.googlesource.com/platform/tools/gpu/log"
	"android.googlesource.com/platform/tools/gpu/rpc"
	)

	func BindServer(r io.Reader, w io.Writer, mtu int, l log.Logger, server RPC) {
	rpc.Serve(l, r, w, mtu, func(in interface{}) (res binary.Object) {
	l := l.Fork().Enter(fmt.Sprintf("%v", in))
	defer func() {
	if err := recover(); err == nil {
	l.Infof("↪ %v", res)
	} else {
	msg := fmt.Sprintf("Panic: %v\n%v", err, string(debug.Stack()))
	l.Errorf(msg)
	res = rpc.NewError(msg)
	}
	}()

	switch call := in.(type) {
	{{range $i, $c := $.Functions}}
	case *{{Macro "CallName" $c}}:
	{{if not (IsVoid $c.Return.Type)}}
	if res, err := server.{{$c.Name}}(l{{range $p := $c.CallParameters}}, call.{{$p.Name}}{{end}}); err == nil {
	return &{{Macro "ResultName" $c}}{ value:res }
	} else {
	return rpc.NewError(err.Error())
	}
	{{else}}
	if err := server.{{$c.Name}}(l{{range $p := $c.CallParameters}}, call.{{$p.Name}}{{end}}); err == nil {
	return &{{Macro "ResultName" $c}}{}
	} else {
	return rpc.NewError(err.Error())
	}
	{{end}}
	{{end}}
	default:
	return rpc.NewError("Unexpected RPC function: %T", call)
	}
	})
	}
	{{end}}