android/module_gob_enc.go

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

package android

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

func init() {
	DistGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Dist) })
	InstallFilesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InstallFilesInfo) })
	ModuleBuildTargetsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleBuildTargetsInfo) })
	CommonModuleInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CommonModuleInfo) })
	ApiLevelOrPlatformGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ApiLevelOrPlatform) })
	HostToolProviderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HostToolProviderInfo) })
	katiInstallGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(katiInstall) })
	extraFilesZipGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(extraFilesZip) })
	OutputFilesInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OutputFilesInfo) })
}

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

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

	val2 := r.Dest == nil
	if err = gobtools.EncodeSimple(buf, val2); err != nil {
		return err
	}
	if !val2 {
		if err = gobtools.EncodeString(buf, (*r.Dest)); err != nil {
			return err
		}
	}

	val3 := r.Dir == nil
	if err = gobtools.EncodeSimple(buf, val3); err != nil {
		return err
	}
	if !val3 {
		if err = gobtools.EncodeString(buf, (*r.Dir)); err != nil {
			return err
		}
	}

	val4 := r.Suffix == nil
	if err = gobtools.EncodeSimple(buf, val4); err != nil {
		return err
	}
	if !val4 {
		if err = gobtools.EncodeString(buf, (*r.Suffix)); err != nil {
			return err
		}
	}

	val5 := r.Append_artifact_with_product == nil
	if err = gobtools.EncodeSimple(buf, val5); err != nil {
		return err
	}
	if !val5 {
		if err = gobtools.EncodeSimple(buf, (*r.Append_artifact_with_product)); err != nil {
			return err
		}
	}

	val6 := r.Prepend_artifact_with_product == nil
	if err = gobtools.EncodeSimple(buf, val6); err != nil {
		return err
	}
	if !val6 {
		if err = gobtools.EncodeSimple(buf, (*r.Prepend_artifact_with_product)); err != nil {
			return err
		}
	}

	val7 := r.Tag == nil
	if err = gobtools.EncodeSimple(buf, val7); err != nil {
		return err
	}
	if !val7 {
		if err = gobtools.EncodeString(buf, (*r.Tag)); err != nil {
			return err
		}
	}

	val8 := r.Only_on_java_coverage_builds == nil
	if err = gobtools.EncodeSimple(buf, val8); err != nil {
		return err
	}
	if !val8 {
		if err = gobtools.EncodeSimple(buf, (*r.Only_on_java_coverage_builds)); err != nil {
			return err
		}
	}
	return err
}

func (r *Dist) 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.Targets = make([]string, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			err = gobtools.DecodeString(buf, &r.Targets[val3])
			if err != nil {
				return err
			}
		}
	}

	var val6 bool
	if err = gobtools.DecodeSimple(buf, &val6); err != nil {
		return err
	}
	if !val6 {
		var val5 string
		err = gobtools.DecodeString(buf, &val5)
		if err != nil {
			return err
		}
		r.Dest = &val5
	}

	var val9 bool
	if err = gobtools.DecodeSimple(buf, &val9); err != nil {
		return err
	}
	if !val9 {
		var val8 string
		err = gobtools.DecodeString(buf, &val8)
		if err != nil {
			return err
		}
		r.Dir = &val8
	}

	var val12 bool
	if err = gobtools.DecodeSimple(buf, &val12); err != nil {
		return err
	}
	if !val12 {
		var val11 string
		err = gobtools.DecodeString(buf, &val11)
		if err != nil {
			return err
		}
		r.Suffix = &val11
	}

	var val15 bool
	if err = gobtools.DecodeSimple(buf, &val15); err != nil {
		return err
	}
	if !val15 {
		var val14 bool
		err = gobtools.DecodeSimple[bool](buf, &val14)
		if err != nil {
			return err
		}
		r.Append_artifact_with_product = &val14
	}

	var val18 bool
	if err = gobtools.DecodeSimple(buf, &val18); err != nil {
		return err
	}
	if !val18 {
		var val17 bool
		err = gobtools.DecodeSimple[bool](buf, &val17)
		if err != nil {
			return err
		}
		r.Prepend_artifact_with_product = &val17
	}

	var val21 bool
	if err = gobtools.DecodeSimple(buf, &val21); err != nil {
		return err
	}
	if !val21 {
		var val20 string
		err = gobtools.DecodeString(buf, &val20)
		if err != nil {
			return err
		}
		r.Tag = &val20
	}

	var val24 bool
	if err = gobtools.DecodeSimple(buf, &val24); err != nil {
		return err
	}
	if !val24 {
		var val23 bool
		err = gobtools.DecodeSimple[bool](buf, &val23)
		if err != nil {
			return err
		}
		r.Only_on_java_coverage_builds = &val23
	}

	return err
}

var DistGobRegId int16

func (r Dist) GetTypeId() int16 {
	return DistGobRegId
}

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

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

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

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

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

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

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

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

	if err = r.TransitivePackagingSpecs.Encode(ctx, buf); err != nil {
		return err
	}

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

	if err = r.TransitiveInstallFiles.Encode(ctx, buf); err != nil {
		return err
	}

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

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

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

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

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

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

	if r.DistFiles == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.DistFiles))); err != nil {
			return err
		}
		for k, v := range r.DistFiles {
			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 val13 := 0; val13 < len(v); val13++ {
					if err = gobtools.EncodeInterface(ctx, buf, v[val13]); err != nil {
						return err
					}
				}
			}
		}
	}
	return err
}

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

	var val3 int32
	err = gobtools.DecodeSimple[int32](buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.InstallFiles = make([]InstallPath, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if err = r.InstallFiles[val4].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

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

	var val14 int32
	err = gobtools.DecodeSimple[int32](buf, &val14)
	if err != nil {
		return err
	}
	if val14 != -1 {
		r.PackagingSpecs = make([]PackagingSpec, val14)
		for val15 := 0; val15 < int(val14); val15++ {
			if err = r.PackagingSpecs[val15].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val19 int32
	err = gobtools.DecodeSimple[int32](buf, &val19)
	if err != nil {
		return err
	}
	if val19 != -1 {
		r.KatiInstalls = make([]katiInstall, val19)
		for val20 := 0; val20 < int(val19); val20++ {
			if err = r.KatiInstalls[val20].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val24 int32
	err = gobtools.DecodeSimple[int32](buf, &val24)
	if err != nil {
		return err
	}
	if val24 != -1 {
		r.KatiSymlinks = make([]katiInstall, val24)
		for val25 := 0; val25 < int(val24); val25++ {
			if err = r.KatiSymlinks[val25].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val28 int32
	err = gobtools.DecodeSimple[int32](buf, &val28)
	if err != nil {
		return err
	}
	if val28 != -1 {
		r.TestData = make([]DataPath, val28)
		for val29 := 0; val29 < int(val28); val29++ {
			if err = r.TestData[val29].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if err = r.TransitivePackagingSpecs.Decode(ctx, buf); err != nil {
		return err
	}

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

	if err = r.TransitiveInstallFiles.Decode(ctx, buf); err != nil {
		return err
	}

	var val37 int32
	err = gobtools.DecodeSimple[int32](buf, &val37)
	if err != nil {
		return err
	}
	if val37 != -1 {
		r.KatiInitRcInstalls = make([]katiInstall, val37)
		for val38 := 0; val38 < int(val37); val38++ {
			if err = r.KatiInitRcInstalls[val38].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val42 int32
	err = gobtools.DecodeSimple[int32](buf, &val42)
	if err != nil {
		return err
	}
	if val42 != -1 {
		r.KatiVintfInstalls = make([]katiInstall, val42)
		for val43 := 0; val43 < int(val42); val43++ {
			if err = r.KatiVintfInstalls[val43].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

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

	var val59 int32
	err = gobtools.DecodeSimple[int32](buf, &val59)
	if err != nil {
		return err
	}
	if val59 != -1 {
		r.InstalledInitRcPaths = make([]InstallPath, val59)
		for val60 := 0; val60 < int(val59); val60++ {
			if err = r.InstalledInitRcPaths[val60].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val64 int32
	err = gobtools.DecodeSimple[int32](buf, &val64)
	if err != nil {
		return err
	}
	if val64 != -1 {
		r.InstalledVintfFragmentsPaths = make([]InstallPath, val64)
		for val65 := 0; val65 < int(val64); val65++ {
			if err = r.InstalledVintfFragmentsPaths[val65].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val68 int32
	err = gobtools.DecodeSimple[int32](buf, &val68)
	if err != nil {
		return err
	}
	if val68 != -1 {
		r.DistFiles = make(map[string]Paths, val68)
		for val69 := 0; val69 < int(val68); val69++ {
			var k string
			var v Paths
			err = gobtools.DecodeString(buf, &k)
			if err != nil {
				return err
			}
			var val73 int32
			err = gobtools.DecodeSimple[int32](buf, &val73)
			if err != nil {
				return err
			}
			if val73 != -1 {
				v = make([]Path, val73)
				for val74 := 0; val74 < int(val73); val74++ {
					if val76, err := gobtools.DecodeInterface(ctx, buf); err != nil {
						return err
					} else if val76 == nil {
						v[val74] = nil
					} else {
						v[val74] = val76.(Path)
					}
				}
			}
			r.DistFiles[k] = v
		}
	}

	return err
}

var InstallFilesInfoGobRegId int16

func (r InstallFilesInfo) GetTypeId() int16 {
	return InstallFilesInfoGobRegId
}

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

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

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

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

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

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

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

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

	if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val2 == nil {
		r.InstallTarget = nil
	} else {
		r.InstallTarget = val2.(Path)
	}

	if val4, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val4 == nil {
		r.OutputsTarget = nil
	} else {
		r.OutputsTarget = val4.(Path)
	}

	if val6, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val6 == nil {
		r.CheckbuildTarget = nil
	} else {
		r.CheckbuildTarget = val6.(Path)
	}

	if val8, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val8 == nil {
		r.ModulePhonyTarget = nil
	} else {
		r.ModulePhonyTarget = val8.(Path)
	}

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

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

	return err
}

var ModuleBuildTargetsInfoGobRegId int16

func (r ModuleBuildTargetsInfo) GetTypeId() int16 {
	return ModuleBuildTargetsInfoGobRegId
}

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

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

	if err = r.Target.Encode(ctx, buf); err != nil {
		return err
	}

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

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

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

	if err = r.MinSdkVersion.Encode(ctx, buf); err != nil {
		return err
	}

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

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

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

	if err = r.MinSdkVersionSupported.Encode(ctx, buf); err != nil {
		return err
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if err = r.ImageVariation.Encode(ctx, buf); err != nil {
		return err
	}

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

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

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

	if err = r.Target.Decode(ctx, buf); err != nil {
		return err
	}

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

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

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

	if err = r.MinSdkVersion.Decode(ctx, buf); err != nil {
		return err
	}

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

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

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

	if err = r.MinSdkVersionSupported.Decode(ctx, buf); err != nil {
		return err
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	var val46 int32
	err = gobtools.DecodeSimple[int32](buf, &val46)
	if err != nil {
		return err
	}
	if val46 != -1 {
		r.Dists = make([]Dist, val46)
		for val47 := 0; val47 < int(val46); val47++ {
			if err = r.Dists[val47].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

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

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

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

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

	if err = r.ImageVariation.Decode(ctx, buf); err != nil {
		return err
	}

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

	return err
}

var CommonModuleInfoGobRegId int16

func (r CommonModuleInfo) GetTypeId() int16 {
	return CommonModuleInfoGobRegId
}

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

	val1 := r.ApiLevel == nil
	if err = gobtools.EncodeSimple(buf, val1); err != nil {
		return err
	}
	if !val1 {
		if err = (*r.ApiLevel).Encode(ctx, buf); err != nil {
			return err
		}
	}

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

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

	var val2 bool
	if err = gobtools.DecodeSimple(buf, &val2); err != nil {
		return err
	}
	if !val2 {
		var val1 ApiLevel
		if err = val1.Decode(ctx, buf); err != nil {
			return err
		}
		r.ApiLevel = &val1
	}

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

	return err
}

var ApiLevelOrPlatformGobRegId int16

func (r ApiLevelOrPlatform) GetTypeId() int16 {
	return ApiLevelOrPlatformGobRegId
}

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

	if err = r.HostToolPath.Encode(ctx, buf); err != nil {
		return err
	}
	return err
}

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

	if err = r.HostToolPath.Decode(ctx, buf); err != nil {
		return err
	}

	return err
}

var HostToolProviderInfoGobRegId int16

func (r HostToolProviderInfo) GetTypeId() int16 {
	return HostToolProviderInfoGobRegId
}

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

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

	if err = r.to.Encode(ctx, buf); err != nil {
		return err
	}

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

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

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

	val3 := r.extraFiles == nil
	if err = gobtools.EncodeSimple(buf, val3); err != nil {
		return err
	}
	if !val3 {
		if err = (*r.extraFiles).Encode(ctx, buf); err != nil {
			return err
		}
	}

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

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

	if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val2 == nil {
		r.from = nil
	} else {
		r.from = val2.(Path)
	}

	if err = r.to.Decode(ctx, buf); err != nil {
		return err
	}

	var val6 int32
	err = gobtools.DecodeSimple[int32](buf, &val6)
	if err != nil {
		return err
	}
	if val6 != -1 {
		r.implicitDeps = 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 {
				r.implicitDeps[val7] = nil
			} else {
				r.implicitDeps[val7] = val9.(Path)
			}
		}
	}

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

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

	var val18 bool
	if err = gobtools.DecodeSimple(buf, &val18); err != nil {
		return err
	}
	if !val18 {
		var val17 extraFilesZip
		if err = val17.Decode(ctx, buf); err != nil {
			return err
		}
		r.extraFiles = &val17
	}

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

	return err
}

var katiInstallGobRegId int16

func (r katiInstall) GetTypeId() int16 {
	return katiInstallGobRegId
}

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

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

	if err = r.dir.Encode(ctx, buf); err != nil {
		return err
	}
	return err
}

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

	if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
		return err
	} else if val2 == nil {
		r.zip = nil
	} else {
		r.zip = val2.(Path)
	}

	if err = r.dir.Decode(ctx, buf); err != nil {
		return err
	}

	return err
}

var extraFilesZipGobRegId int16

func (r extraFilesZip) GetTypeId() int16 {
	return extraFilesZipGobRegId
}

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

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

	if r.TaggedOutputFiles == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.TaggedOutputFiles))); err != nil {
			return err
		}
		for k, v := range r.TaggedOutputFiles {
			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 val2 := 0; val2 < len(v); val2++ {
					if err = gobtools.EncodeInterface(ctx, buf, v[val2]); err != nil {
						return err
					}
				}
			}
		}
	}
	return err
}

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

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

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

	return err
}

var OutputFilesInfoGobRegId int16

func (r OutputFilesInfo) GetTypeId() int16 {
	return OutputFilesInfoGobRegId
}