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

package rpc

import (
	"android.googlesource.com/platform/tools/gpu/framework/binary"
	"android.googlesource.com/platform/tools/gpu/framework/binary/registry"
	"android.googlesource.com/platform/tools/gpu/framework/id"
)

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

// force use the id package, because our imports handling is wrong
var _ id.ID

const (
	ixǁErrDecodingCall = iota
	ixǁErrInvalidHeader
	ixǁErrPanic
	ixǁErrUnknownFunction
	ixǁError
)

var entities [5]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*ErrDecodingCall)(nil))
	Namespace.AddClassOf((*ErrInvalidHeader)(nil))
	Namespace.AddClassOf((*ErrPanic)(nil))
	Namespace.AddClassOf((*ErrUnknownFunction)(nil))
	Namespace.AddClassOf((*Error)(nil))
}

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

func (*ErrDecodingCall) Class() binary.Class {
	return (*binaryClassErrDecodingCall)(nil)
}
func doEncodeErrDecodingCall(e binary.Writer, o *ErrDecodingCall) {
	e.String(o.Reason)
}
func doDecodeErrDecodingCall(d binary.Reader, o *ErrDecodingCall) {
	o.Reason = string(d.String())
}
func (*binaryClassErrDecodingCall) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrDecodingCall(e, obj.(*ErrDecodingCall))
}
func (*binaryClassErrDecodingCall) New() binary.Object {
	return &ErrDecodingCall{}
}
func (*binaryClassErrDecodingCall) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrDecodingCall(d, obj.(*ErrDecodingCall))
}
func (o *ErrDecodingCall) WriteSimple(w binary.Writer) {
	doEncodeErrDecodingCall(w, o)
}
func (o *ErrDecodingCall) ReadSimple(r binary.Reader) {
	doDecodeErrDecodingCall(r, o)
}
func (c *binaryClassErrDecodingCall) Schema() *binary.Entity {
	return &entities[ixǁErrDecodingCall]
}

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

func (*ErrInvalidHeader) Class() binary.Class {
	return (*binaryClassErrInvalidHeader)(nil)
}
func doEncodeErrInvalidHeader(e binary.Writer, o *ErrInvalidHeader) {
	e.Data(o.Header[:4])
}
func doDecodeErrInvalidHeader(d binary.Reader, o *ErrInvalidHeader) {
	d.Data(o.Header[:4])
}
func (*binaryClassErrInvalidHeader) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrInvalidHeader(e, obj.(*ErrInvalidHeader))
}
func (*binaryClassErrInvalidHeader) New() binary.Object {
	return &ErrInvalidHeader{}
}
func (*binaryClassErrInvalidHeader) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrInvalidHeader(d, obj.(*ErrInvalidHeader))
}
func (o *ErrInvalidHeader) WriteSimple(w binary.Writer) {
	doEncodeErrInvalidHeader(w, o)
}
func (o *ErrInvalidHeader) ReadSimple(r binary.Reader) {
	doDecodeErrInvalidHeader(r, o)
}
func (c *binaryClassErrInvalidHeader) Schema() *binary.Entity {
	return &entities[ixǁErrInvalidHeader]
}

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

func (*ErrPanic) Class() binary.Class {
	return (*binaryClassErrPanic)(nil)
}
func doEncodeErrPanic(e binary.Writer, o *ErrPanic) {
	e.String(o.Msg)
}
func doDecodeErrPanic(d binary.Reader, o *ErrPanic) {
	o.Msg = string(d.String())
}
func (*binaryClassErrPanic) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrPanic(e, obj.(*ErrPanic))
}
func (*binaryClassErrPanic) New() binary.Object {
	return &ErrPanic{}
}
func (*binaryClassErrPanic) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrPanic(d, obj.(*ErrPanic))
}
func (o *ErrPanic) WriteSimple(w binary.Writer) {
	doEncodeErrPanic(w, o)
}
func (o *ErrPanic) ReadSimple(r binary.Reader) {
	doDecodeErrPanic(r, o)
}
func (c *binaryClassErrPanic) Schema() *binary.Entity {
	return &entities[ixǁErrPanic]
}

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

func (*ErrUnknownFunction) Class() binary.Class {
	return (*binaryClassErrUnknownFunction)(nil)
}
func doEncodeErrUnknownFunction(e binary.Writer, o *ErrUnknownFunction) {
	e.String(o.Function)
}
func doDecodeErrUnknownFunction(d binary.Reader, o *ErrUnknownFunction) {
	o.Function = string(d.String())
}
func (*binaryClassErrUnknownFunction) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrUnknownFunction(e, obj.(*ErrUnknownFunction))
}
func (*binaryClassErrUnknownFunction) New() binary.Object {
	return &ErrUnknownFunction{}
}
func (*binaryClassErrUnknownFunction) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrUnknownFunction(d, obj.(*ErrUnknownFunction))
}
func (o *ErrUnknownFunction) WriteSimple(w binary.Writer) {
	doEncodeErrUnknownFunction(w, o)
}
func (o *ErrUnknownFunction) ReadSimple(r binary.Reader) {
	doDecodeErrUnknownFunction(r, o)
}
func (c *binaryClassErrUnknownFunction) Schema() *binary.Entity {
	return &entities[ixǁErrUnknownFunction]
}

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

func (*Error) Class() binary.Class {
	return (*binaryClassError)(nil)
}
func doEncodeError(e binary.Writer, o *Error) {
	e.String(o.Msg)
}
func doDecodeError(d binary.Reader, o *Error) {
	o.Msg = string(d.String())
}
func (*binaryClassError) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeError(e, obj.(*Error))
}
func (*binaryClassError) New() binary.Object {
	return &Error{}
}
func (*binaryClassError) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeError(d, obj.(*Error))
}
func (o *Error) WriteSimple(w binary.Writer) {
	doEncodeError(w, o)
}
func (o *Error) ReadSimple(r binary.Reader) {
	doDecodeError(r, o)
}
func (c *binaryClassError) Schema() *binary.Entity {
	return &entities[ixǁError]
}