Merge "Change the way to support custom gob encoder and decoder." into main (45416899) · Commits · e / os / android_build_soong

android/compliance_metadata.go

+15 −16

Original line number	Diff line number	Diff line
		@@ -17,7 +17,6 @@ package android
		import (
		"bytes"
		"encoding/csv"
		"encoding/gob"
		"fmt"
		"slices"
		"strconv"
		@@ -126,32 +125,32 @@ type ComplianceMetadataInfo struct {
		properties map[string]string
		}

		type complianceMetadataInfoGob struct {
		Properties map[string]string
		}

		func NewComplianceMetadataInfo() *ComplianceMetadataInfo {
		return &ComplianceMetadataInfo{
		properties: map[string]string{},
		}
		}

		func (c *ComplianceMetadataInfo) GobEncode() ([]byte, error) {
		w := new(bytes.Buffer)
		encoder := gob.NewEncoder(w)
		err := encoder.Encode(c.properties)
		if err != nil {
		return nil, err
		func (m ComplianceMetadataInfo) ToGob() complianceMetadataInfoGob {
		return &complianceMetadataInfoGob{
		Properties: m.properties,
		}
		}

		return w.Bytes(), nil
		func (m ComplianceMetadataInfo) FromGob(data complianceMetadataInfoGob) {
		m.properties = data.Properties
		}

		func (c *ComplianceMetadataInfo) GobDecode(data []byte) error {
		r := bytes.NewBuffer(data)
		decoder := gob.NewDecoder(r)
		err := decoder.Decode(&c.properties)
		if err != nil {
		return err
		func (c *ComplianceMetadataInfo) GobEncode() ([]byte, error) {
		return blueprint.CustomGobEncode[complianceMetadataInfoGob](c)
		}

		return nil
		func (c *ComplianceMetadataInfo) GobDecode(data []byte) error {
		return blueprint.CustomGobDecode[complianceMetadataInfoGob](data, c)
		}

		func (c *ComplianceMetadataInfo) SetStringValue(propertyName string, value string) {

android/depset_generic.go

+29 −20

Original line number	Diff line number	Diff line
		@@ -15,10 +15,9 @@
		package android

		import (
		"bytes"
		"encoding/gob"
		"errors"
		"fmt"

		"github.com/google/blueprint"
		)

		// DepSet is designed to be conceptually compatible with Bazel's depsets:
		@@ -68,28 +67,38 @@ type DepSet[T depSettableType] struct {
		transitive []*DepSet[T]
		}

		func (d *DepSet[T]) GobEncode() ([]byte, error) {
		w := new(bytes.Buffer)
		encoder := gob.NewEncoder(w)
		err := errors.Join(encoder.Encode(d.preorder), encoder.Encode(d.reverse),
		encoder.Encode(d.order), encoder.Encode(d.direct), encoder.Encode(d.transitive))
		if err != nil {
		return nil, err
		type depSetGob[T depSettableType] struct {
		Preorder bool
		Reverse bool
		Order DepSetOrder
		Direct []T
		Transitive []*DepSet[T]
		}

		return w.Bytes(), nil
		func (d DepSet[T]) ToGob() depSetGob[T] {
		return &depSetGob[T]{
		Preorder: d.preorder,
		Reverse: d.reverse,
		Order: d.order,
		Direct: d.direct,
		Transitive: d.transitive,
		}
		}

		func (d *DepSet[T]) GobDecode(data []byte) error {
		r := bytes.NewBuffer(data)
		decoder := gob.NewDecoder(r)
		err := errors.Join(decoder.Decode(&d.preorder), decoder.Decode(&d.reverse),
		decoder.Decode(&d.order), decoder.Decode(&d.direct), decoder.Decode(&d.transitive))
		if err != nil {
		return err
		func (d DepSet[T]) FromGob(data depSetGob[T]) {
		d.preorder = data.Preorder
		d.reverse = data.Reverse
		d.order = data.Order
		d.direct = data.Direct
		d.transitive = data.Transitive
		}

		return nil
		func (d *DepSet[T]) GobEncode() ([]byte, error) {
		return blueprint.CustomGobEncode[depSetGob[T]](d)
		}

		func (d *DepSet[T]) GobDecode(data []byte) error {
		return blueprint.CustomGobDecode[depSetGob[T]](data, d)
		}

		// NewDepSet returns an immutable DepSet with the given order, direct and transitive contents.

android/init.go

+5 −0

Original line number	Diff line number	Diff line
		@@ -17,7 +17,12 @@ package android
		import "encoding/gob"

		func init() {
		gob.Register(extraFilesZip{})
		gob.Register(InstallPath{})
		gob.Register(ModuleGenPath{})
		gob.Register(ModuleOutPath{})
		gob.Register(OutputPath{})
		gob.Register(PhonyPath{})
		gob.Register(SourcePath{})
		gob.Register(unstableInfo{})
		}

android/module.go

+51 −40

Original line number	Diff line number	Diff line
		@@ -15,9 +15,6 @@
		package android

		import (
		"bytes"
		"encoding/gob"
		"errors"
		"fmt"
		"net/url"
		"path/filepath"
		@@ -2130,36 +2127,47 @@ type katiInstall struct {
		orderOnlyDeps Paths
		executable bool
		extraFiles *extraFilesZip

		absFrom string
		}

		func (p *katiInstall) GobEncode() ([]byte, error) {
		w := new(bytes.Buffer)
		encoder := gob.NewEncoder(w)
		err := errors.Join(encoder.Encode(p.from), encoder.Encode(p.to),
		encoder.Encode(p.implicitDeps), encoder.Encode(p.orderOnlyDeps),
		encoder.Encode(p.executable), encoder.Encode(p.extraFiles),
		encoder.Encode(p.absFrom))
		if err != nil {
		return nil, err
		type katiInstallGob struct {
		From Path
		To InstallPath
		ImplicitDeps Paths
		OrderOnlyDeps Paths
		Executable bool
		ExtraFiles *extraFilesZip
		AbsFrom string
		}

		return w.Bytes(), nil
		func (k katiInstall) ToGob() katiInstallGob {
		return &katiInstallGob{
		From: k.from,
		To: k.to,
		ImplicitDeps: k.implicitDeps,
		OrderOnlyDeps: k.orderOnlyDeps,
		Executable: k.executable,
		ExtraFiles: k.extraFiles,
		AbsFrom: k.absFrom,
		}
		}

		func (p *katiInstall) GobDecode(data []byte) error {
		r := bytes.NewBuffer(data)
		decoder := gob.NewDecoder(r)
		err := errors.Join(decoder.Decode(&p.from), decoder.Decode(&p.to),
		decoder.Decode(&p.implicitDeps), decoder.Decode(&p.orderOnlyDeps),
		decoder.Decode(&p.executable), decoder.Decode(&p.extraFiles),
		decoder.Decode(&p.absFrom))
		if err != nil {
		return err
		func (k katiInstall) FromGob(data katiInstallGob) {
		k.from = data.From
		k.to = data.To
		k.implicitDeps = data.ImplicitDeps
		k.orderOnlyDeps = data.OrderOnlyDeps
		k.executable = data.Executable
		k.extraFiles = data.ExtraFiles
		k.absFrom = data.AbsFrom
		}

		return nil
		func (k *katiInstall) GobEncode() ([]byte, error) {
		return blueprint.CustomGobEncode[katiInstallGob](k)
		}

		func (k *katiInstall) GobDecode(data []byte) error {
		return blueprint.CustomGobDecode[katiInstallGob](data, k)
		}

		type extraFilesZip struct {
		@@ -2167,26 +2175,29 @@ type extraFilesZip struct {
		dir InstallPath
		}

		func (p *extraFilesZip) GobEncode() ([]byte, error) {
		w := new(bytes.Buffer)
		encoder := gob.NewEncoder(w)
		err := errors.Join(encoder.Encode(p.zip), encoder.Encode(p.dir))
		if err != nil {
		return nil, err
		type extraFilesZipGob struct {
		Zip Path
		Dir InstallPath
		}

		return w.Bytes(), nil
		func (e extraFilesZip) ToGob() extraFilesZipGob {
		return &extraFilesZipGob{
		Zip: e.zip,
		Dir: e.dir,
		}
		}

		func (p *extraFilesZip) GobDecode(data []byte) error {
		r := bytes.NewBuffer(data)
		decoder := gob.NewDecoder(r)
		err := errors.Join(decoder.Decode(&p.zip), decoder.Decode(&p.dir))
		if err != nil {
		return err
		func (e extraFilesZip) FromGob(data extraFilesZipGob) {
		e.zip = data.Zip
		e.dir = data.Dir
		}

		return nil
		func (e *extraFilesZip) GobEncode() ([]byte, error) {
		return blueprint.CustomGobEncode[extraFilesZipGob](e)
		}

		func (e *extraFilesZip) GobDecode(data []byte) error {
		return blueprint.CustomGobDecode[extraFilesZipGob](data, e)
		}

		type katiInstalls []katiInstall

android/packaging.go

+42 −26

Original line number	Diff line number	Diff line
		@@ -15,9 +15,6 @@
		package android

		import (
		"bytes"
		"encoding/gob"
		"errors"
		"fmt"
		"path/filepath"
		"sort"
		@@ -67,34 +64,53 @@ type PackagingSpec struct {
		owner string
		}

		func (p *PackagingSpec) GobEncode() ([]byte, error) {
		w := new(bytes.Buffer)
		encoder := gob.NewEncoder(w)
		err := errors.Join(encoder.Encode(p.relPathInPackage), encoder.Encode(p.srcPath),
		encoder.Encode(p.symlinkTarget), encoder.Encode(p.executable),
		encoder.Encode(p.effectiveLicenseFiles), encoder.Encode(p.partition),
		encoder.Encode(p.skipInstall), encoder.Encode(p.aconfigPaths),
		encoder.Encode(p.archType))
		if err != nil {
		return nil, err
		type packagingSpecGob struct {
		RelPathInPackage string
		SrcPath Path
		SymlinkTarget string
		Executable bool
		Partition string
		SkipInstall bool
		AconfigPaths *Paths
		ArchType ArchType
		Overrides *[]string
		Owner string
		}

		func (p PackagingSpec) ToGob() packagingSpecGob {
		return &packagingSpecGob{
		RelPathInPackage: p.relPathInPackage,
		SrcPath: p.srcPath,
		SymlinkTarget: p.symlinkTarget,
		Executable: p.executable,
		Partition: p.partition,
		SkipInstall: p.skipInstall,
		AconfigPaths: p.aconfigPaths,
		ArchType: p.archType,
		Overrides: p.overrides,
		Owner: p.owner,
		}
		}

		func (p PackagingSpec) FromGob(data packagingSpecGob) {
		p.relPathInPackage = data.RelPathInPackage
		p.srcPath = data.SrcPath
		p.symlinkTarget = data.SymlinkTarget
		p.executable = data.Executable
		p.partition = data.Partition
		p.skipInstall = data.SkipInstall
		p.aconfigPaths = data.AconfigPaths
		p.archType = data.ArchType
		p.overrides = data.Overrides
		p.owner = data.Owner
		}

		return w.Bytes(), nil
		func (p *PackagingSpec) GobEncode() ([]byte, error) {
		return blueprint.CustomGobEncode[packagingSpecGob](p)
		}

		func (p *PackagingSpec) GobDecode(data []byte) error {
		r := bytes.NewBuffer(data)
		decoder := gob.NewDecoder(r)
		err := errors.Join(decoder.Decode(&p.relPathInPackage), decoder.Decode(&p.srcPath),
		decoder.Decode(&p.symlinkTarget), decoder.Decode(&p.executable),
		decoder.Decode(&p.effectiveLicenseFiles), decoder.Decode(&p.partition),
		decoder.Decode(&p.skipInstall), decoder.Decode(&p.aconfigPaths),
		decoder.Decode(&p.archType))
		if err != nil {
		return err
		}

		return nil
		return blueprint.CustomGobDecode[packagingSpecGob](data, p)
		}

		func (p PackagingSpec) Equals(other PackagingSpec) bool {