android/paths_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() {
	OptionalPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OptionalPath) })
	PathsGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Paths) })
	basePathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(basePath) })
	SourcePathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SourcePath) })
	OutputPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OutputPath) })
	toolDepPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(toolDepPath) })
	ModuleOutPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleOutPath) })
	ModuleGenPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleGenPath) })
	ModuleObjPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleObjPath) })
	ModuleResPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleResPath) })
	InstallPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(InstallPath) })
	PhonyPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PhonyPath) })
	testPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testPath) })
	DataPathGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DataPath) })
}

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

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

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

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

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

	return err
}

var OptionalPathGobRegId int16

func (r OptionalPath) GetTypeId() int16 {
	return OptionalPathGobRegId
}

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

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

func (r *Paths) 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) = make([]Path, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if val5, err := gobtools.DecodeInterface(ctx, buf); err != nil {
				return err
			} else if val5 == nil {
				(*r)[val3] = nil
			} else {
				(*r)[val3] = val5.(Path)
			}
		}
	}

	return err
}

var PathsGobRegId int16

func (r Paths) GetTypeId() int16 {
	return PathsGobRegId
}

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

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

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

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

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

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

	return err
}

var basePathGobRegId int16

func (r basePath) GetTypeId() int16 {
	return basePathGobRegId
}

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

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

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

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

	return err
}

var SourcePathGobRegId int16

func (r SourcePath) GetTypeId() int16 {
	return SourcePathGobRegId
}

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

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

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

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

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

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

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

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

	return err
}

var OutputPathGobRegId int16

func (r OutputPath) GetTypeId() int16 {
	return OutputPathGobRegId
}

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

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

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

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

	return err
}

var toolDepPathGobRegId int16

func (r toolDepPath) GetTypeId() int16 {
	return toolDepPathGobRegId
}

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

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

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

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

	return err
}

var ModuleOutPathGobRegId int16

func (r ModuleOutPath) GetTypeId() int16 {
	return ModuleOutPathGobRegId
}

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

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

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

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

	return err
}

var ModuleGenPathGobRegId int16

func (r ModuleGenPath) GetTypeId() int16 {
	return ModuleGenPathGobRegId
}

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

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

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

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

	return err
}

var ModuleObjPathGobRegId int16

func (r ModuleObjPath) GetTypeId() int16 {
	return ModuleObjPathGobRegId
}

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

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

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

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

	return err
}

var ModuleResPathGobRegId int16

func (r ModuleResPath) GetTypeId() int16 {
	return ModuleResPathGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return err
}

var InstallPathGobRegId int16

func (r InstallPath) GetTypeId() int16 {
	return InstallPathGobRegId
}

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

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

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

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

	return err
}

var PhonyPathGobRegId int16

func (r PhonyPath) GetTypeId() int16 {
	return PhonyPathGobRegId
}

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

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

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

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

	return err
}

var testPathGobRegId int16

func (r testPath) GetTypeId() int16 {
	return testPathGobRegId
}

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

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

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

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

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

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

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

	return err
}

var DataPathGobRegId int16

func (r DataPath) GetTypeId() int16 {
	return DataPathGobRegId
}