rpc/rpc_binary_test.go

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

package rpc

import "android.googlesource.com/platform/tools/gpu/binary"

// Make sure schema init() runs first
import _ "android.googlesource.com/platform/tools/gpu/binary/schema"

const (
	ixǁdelay = iota
	ixǁerr
	ixǁrequest
	ixǁresponse
)

var test_entities [4]binary.Entity

func init() {
	Namespace.AddClassOf((*delay)(nil))
	Namespace.AddClassOf((*err)(nil))
	Namespace.AddClassOf((*request)(nil))
	Namespace.AddClassOf((*response)(nil))
}

type binaryClassdelay struct{}

func (*delay) Class() binary.Class {
	return (*binaryClassdelay)(nil)
}
func doEncodedelay(e binary.Writer, o *delay) {
	e.String(o.data)
}
func doDecodedelay(d binary.Reader, o *delay) {
	o.data = string(d.String())
}
func (*binaryClassdelay) Encode(e binary.Encoder, obj binary.Object) {
	doEncodedelay(e, obj.(*delay))
}
func (*binaryClassdelay) New() binary.Object {
	return &delay{}
}
func (*binaryClassdelay) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodedelay(d, obj.(*delay))
}
func (o *delay) WriteSimple(w binary.Writer) {
	doEncodedelay(w, o)
}
func (o *delay) ReadSimple(r binary.Reader) {
	doDecodedelay(r, o)
}
func (c *binaryClassdelay) Schema() *binary.Entity {
	return &test_entities[ixǁdelay]
}

var _ Err = (*err)(nil) // Interface compliance check.
type binaryClasserr struct{}

func (*err) Class() binary.Class {
	return (*binaryClasserr)(nil)
}
func doEncodeerr(e binary.Writer, o *err) {
	e.String(o.msg)
}
func doDecodeerr(d binary.Reader, o *err) {
	o.msg = string(d.String())
}
func (*binaryClasserr) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeerr(e, obj.(*err))
}
func (*binaryClasserr) New() binary.Object {
	return &err{}
}
func (*binaryClasserr) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeerr(d, obj.(*err))
}
func (o *err) WriteSimple(w binary.Writer) {
	doEncodeerr(w, o)
}
func (o *err) ReadSimple(r binary.Reader) {
	doDecodeerr(r, o)
}
func (c *binaryClasserr) Schema() *binary.Entity {
	return &test_entities[ixǁerr]
}

type binaryClassrequest struct{}

func (*request) Class() binary.Class {
	return (*binaryClassrequest)(nil)
}
func doEncoderequest(e binary.Writer, o *request) {
	e.String(o.data)
}
func doDecoderequest(d binary.Reader, o *request) {
	o.data = string(d.String())
}
func (*binaryClassrequest) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderequest(e, obj.(*request))
}
func (*binaryClassrequest) New() binary.Object {
	return &request{}
}
func (*binaryClassrequest) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderequest(d, obj.(*request))
}
func (o *request) WriteSimple(w binary.Writer) {
	doEncoderequest(w, o)
}
func (o *request) ReadSimple(r binary.Reader) {
	doDecoderequest(r, o)
}
func (c *binaryClassrequest) Schema() *binary.Entity {
	return &test_entities[ixǁrequest]
}

type binaryClassresponse struct{}

func (*response) Class() binary.Class {
	return (*binaryClassresponse)(nil)
}
func doEncoderesponse(e binary.Writer, o *response) {
	e.String(o.data)
}
func doDecoderesponse(d binary.Reader, o *response) {
	o.data = string(d.String())
}
func (*binaryClassresponse) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesponse(e, obj.(*response))
}
func (*binaryClassresponse) New() binary.Object {
	return &response{}
}
func (*binaryClassresponse) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesponse(d, obj.(*response))
}
func (o *response) WriteSimple(w binary.Writer) {
	doEncoderesponse(w, o)
}
func (o *response) ReadSimple(r binary.Reader) {
	doDecoderesponse(r, o)
}
func (c *binaryClassresponse) Schema() *binary.Entity {
	return &test_entities[ixǁresponse]
}