// Code generated by go run gob_gen.go; DO NOT EDIT.

package android

import (
	"bytes"
	"github.com/google/blueprint/gobtools"
)

func init() {
	AconfigDeclarationsProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AconfigDeclarationsProviderData) })
	AconfigReleaseDeclarationsProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AconfigReleaseDeclarationsProviderData) })
	ModeInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModeInfo) })
	CodegenInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CodegenInfo) })
	aconfigPropagatingDeclarationsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(aconfigPropagatingDeclarationsInfo) })
}

func (r AconfigDeclarationsProviderData) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.Package); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.Container); err != nil {
		return err
	}

	if err = gobtools.EncodeSimple(buf, r.Exportable); err != nil {
		return err
	}

	if err = gobtools.EncodeInterface(ctx, buf, r.IntermediateCacheOutputPath); err != nil {
		return err
	}

	if err = gobtools.EncodeInterface(ctx, buf, r.IntermediateDumpOutputPath); err != nil {
		return err
	}
	return err
}

func (r *AconfigDeclarationsProviderData) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.Package)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.Container)
	if err != nil {
		return err
	}

	err = gobtools.DecodeSimple[bool](buf, &r.Exportable)
	if err != nil {
		return err
	}

	if val5, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val5 == nil {
		r.IntermediateCacheOutputPath = nil
	} else {
		r.IntermediateCacheOutputPath = val5.(WritablePath)
	}

	if val7, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val7 == nil {
		r.IntermediateDumpOutputPath = nil
	} else {
		r.IntermediateDumpOutputPath = val7.(WritablePath)
	}

	return err
}

var AconfigDeclarationsProviderDataGobRegId int16

func (r AconfigDeclarationsProviderData) GetTypeId() int16 {
	return AconfigDeclarationsProviderDataGobRegId
}

func (r AconfigReleaseDeclarationsProviderData) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.Data == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.Data))); err != nil {
			return err
		}
		for k, v := range r.Data {
			if err = gobtools.EncodeString(buf, k); err != nil {
				return err
			}
			if err = v.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}
	return err
}

func (r *AconfigReleaseDeclarationsProviderData) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val1 int32
	err = gobtools.DecodeSimple[int32](buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		r.Data = make(map[string]AconfigDeclarationsProviderData, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var k string
			var v AconfigDeclarationsProviderData
			err = gobtools.DecodeString(buf, &k)
			if err != nil {
				return err
			}
			if err = v.Decode(ctx, buf); err != nil {
				return err
			}
			r.Data[k] = v
		}
	}

	return err
}

var AconfigReleaseDeclarationsProviderDataGobRegId int16

func (r AconfigReleaseDeclarationsProviderData) GetTypeId() int16 {
	return AconfigReleaseDeclarationsProviderDataGobRegId
}

func (r ModeInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.Container); err != nil {
		return err
	}

	if err = gobtools.EncodeString(buf, r.Mode); err != nil {
		return err
	}
	return err
}

func (r *ModeInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.Container)
	if err != nil {
		return err
	}

	err = gobtools.DecodeString(buf, &r.Mode)
	if err != nil {
		return err
	}

	return err
}

var ModeInfoGobRegId int16

func (r ModeInfo) GetTypeId() int16 {
	return ModeInfoGobRegId
}

func (r CodegenInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.AconfigDeclarations == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.AconfigDeclarations))); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.AconfigDeclarations); val1++ {
			if err = gobtools.EncodeString(buf, r.AconfigDeclarations[val1]); err != nil {
				return err
			}
		}
	}

	if r.IntermediateCacheOutputPaths == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.IntermediateCacheOutputPaths))); err != nil {
			return err
		}
		for val2 := 0; val2 < len(r.IntermediateCacheOutputPaths); val2++ {
			if err = gobtools.EncodeInterface(ctx, buf, r.IntermediateCacheOutputPaths[val2]); err != nil {
				return err
			}
		}
	}

	if r.Srcjars == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.Srcjars))); err != nil {
			return err
		}
		for val3 := 0; val3 < len(r.Srcjars); val3++ {
			if err = gobtools.EncodeInterface(ctx, buf, r.Srcjars[val3]); err != nil {
				return err
			}
		}
	}

	if r.ModeInfos == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.ModeInfos))); err != nil {
			return err
		}
		for k, v := range r.ModeInfos {
			if err = gobtools.EncodeString(buf, k); err != nil {
				return err
			}
			if err = v.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}
	return err
}

func (r *CodegenInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val2 int32
	err = gobtools.DecodeSimple[int32](buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.AconfigDeclarations = make([]string, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeString(buf, &r.AconfigDeclarations[val3])
			if err != nil {
				return err
			}
		}
	}

	var val7 int32
	err = gobtools.DecodeSimple[int32](buf, &val7)
	if err != nil {
		return err
	}
	if val7 != -1 {
		r.IntermediateCacheOutputPaths = make([]Path, val7)
		for val8 := 0; val8 < int(val7); val8++ {
			if val10, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val10 == nil {
				r.IntermediateCacheOutputPaths[val8] = nil
			} else {
				r.IntermediateCacheOutputPaths[val8] = val10.(Path)
			}
		}
	}

	var val13 int32
	err = gobtools.DecodeSimple[int32](buf, &val13)
	if err != nil {
		return err
	}
	if val13 != -1 {
		r.Srcjars = make([]Path, val13)
		for val14 := 0; val14 < int(val13); val14++ {
			if val16, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val16 == nil {
				r.Srcjars[val14] = nil
			} else {
				r.Srcjars[val14] = val16.(Path)
			}
		}
	}

	var val17 int32
	err = gobtools.DecodeSimple[int32](buf, &val17)
	if err != nil {
		return err
	}
	if val17 != -1 {
		r.ModeInfos = make(map[string]ModeInfo, val17)
		for val18 := 0; val18 < int(val17); val18++ {
			var k string
			var v ModeInfo
			err = gobtools.DecodeString(buf, &k)
			if err != nil {
				return err
			}
			if err = v.Decode(ctx, buf); err != nil {
				return err
			}
			r.ModeInfos[k] = v
		}
	}

	return err
}

var CodegenInfoGobRegId int16

func (r CodegenInfo) GetTypeId() int16 {
	return CodegenInfoGobRegId
}

func (r aconfigPropagatingDeclarationsInfo) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.AconfigFiles == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.AconfigFiles))); err != nil {
			return err
		}
		for k, v := range r.AconfigFiles {
			if err = gobtools.EncodeString(buf, k); err != nil {
				return err
			}
			if v == nil {
				if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeSimple(buf, int32(len(v))); err != nil {
					return err
				}
				for val1 := 0; val1 < len(v); val1++ {
					if err = gobtools.EncodeInterface(ctx, buf, v[val1]); err != nil {
						return err
					}
				}
			}
		}
	}

	if r.ModeInfos == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.ModeInfos))); err != nil {
			return err
		}
		for k, v := range r.ModeInfos {
			if err = gobtools.EncodeString(buf, k); err != nil {
				return err
			}
			if err = v.Encode(ctx, buf); err != nil {
				return err
			}
		}
	}
	return err
}

func (r *aconfigPropagatingDeclarationsInfo) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val1 int32
	err = gobtools.DecodeSimple[int32](buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		r.AconfigFiles = make(map[string]Paths, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var k string
			var v Paths
			err = gobtools.DecodeString(buf, &k)
			if err != nil {
				return err
			}
			var val6 int32
			err = gobtools.DecodeSimple[int32](buf, &val6)
			if err != nil {
				return err
			}
			if val6 != -1 {
				v = make([]Path, val6)
				for val7 := 0; val7 < int(val6); val7++ {
					if val9, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val9 == nil {
						v[val7] = nil
					} else {
						v[val7] = val9.(Path)
					}
				}
			}
			r.AconfigFiles[k] = v
		}
	}

	var val10 int32
	err = gobtools.DecodeSimple[int32](buf, &val10)
	if err != nil {
		return err
	}
	if val10 != -1 {
		r.ModeInfos = make(map[string]ModeInfo, val10)
		for val11 := 0; val11 < int(val10); val11++ {
			var k string
			var v ModeInfo
			err = gobtools.DecodeString(buf, &k)
			if err != nil {
				return err
			}
			if err = v.Decode(ctx, buf); err != nil {
				return err
			}
			r.ModeInfos[k] = v
		}
	}

	return err
}

var aconfigPropagatingDeclarationsInfoGobRegId int16

func (r aconfigPropagatingDeclarationsInfo) GetTypeId() int16 {
	return aconfigPropagatingDeclarationsInfoGobRegId
}