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

package cc

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

func init() {
	SharedLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SharedLibraryInfo) })
	SharedStubLibraryGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SharedStubLibrary) })
	SharedLibraryStubsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SharedLibraryStubsInfo) })
	StaticLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(StaticLibraryInfo) })
	HeaderLibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(HeaderLibraryInfo) })
	FlagExporterInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FlagExporterInfo) })
	ImplementationDepInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ImplementationDepInfo) })
}

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

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

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

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

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

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

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

func (r *SharedLibraryInfo) 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.SharedLibrary = nil
	} else {
		r.SharedLibrary = val2.(android.Path)
	}

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

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

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

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

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

	return err
}

var SharedLibraryInfoGobRegId int16

func (r SharedLibraryInfo) GetTypeId() int16 {
	return SharedLibraryInfoGobRegId
}

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

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

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

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

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

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

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

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

	return err
}

var SharedStubLibraryGobRegId int16

func (r SharedStubLibrary) GetTypeId() int16 {
	return SharedStubLibraryGobRegId
}

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

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

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

func (r *SharedLibraryStubsInfo) 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.SharedStubLibraries = make([]SharedStubLibrary, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = r.SharedStubLibraries[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

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

	return err
}

var SharedLibraryStubsInfoGobRegId int16

func (r SharedLibraryStubsInfo) GetTypeId() int16 {
	return SharedLibraryStubsInfoGobRegId
}

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

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

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

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

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

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

func (r *StaticLibraryInfo) 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.StaticLibrary = nil
	} else {
		r.StaticLibrary = val2.(android.Path)
	}

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

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

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

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

	return err
}

var StaticLibraryInfoGobRegId int16

func (r StaticLibraryInfo) GetTypeId() int16 {
	return StaticLibraryInfoGobRegId
}

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

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

	return err
}

var HeaderLibraryInfoGobRegId int16

func (r HeaderLibraryInfo) GetTypeId() int16 {
	return HeaderLibraryInfoGobRegId
}

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

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

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

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

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

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

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

func (r *FlagExporterInfo) 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.IncludeDirs = make([]android.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.IncludeDirs[val4] = nil
			} else {
				r.IncludeDirs[val4] = val6.(android.Path)
			}
		}
	}

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

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

	var val19 int32
	err = gobtools.DecodeSimple[int32](buf, &val19)
	if err != nil {
		return err
	}
	if val19 != -1 {
		r.Deps = make([]android.Path, val19)
		for val20 := 0; val20 < int(val19); val20++ {
			if val22, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val22 == nil {
				r.Deps[val20] = nil
			} else {
				r.Deps[val20] = val22.(android.Path)
			}
		}
	}

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

	var val29 int32
	err = gobtools.DecodeSimple[int32](buf, &val29)
	if err != nil {
		return err
	}
	if val29 != -1 {
		r.GeneratedHeaders = make([]android.Path, val29)
		for val30 := 0; val30 < int(val29); val30++ {
			if val32, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val32 == nil {
				r.GeneratedHeaders[val30] = nil
			} else {
				r.GeneratedHeaders[val30] = val32.(android.Path)
			}
		}
	}

	return err
}

var FlagExporterInfoGobRegId int16

func (r FlagExporterInfo) GetTypeId() int16 {
	return FlagExporterInfoGobRegId
}

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

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

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

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

	return err
}

var ImplementationDepInfoGobRegId int16

func (r ImplementationDepInfo) GetTypeId() int16 {
	return ImplementationDepInfoGobRegId
}