From 5b511a200ef62e9078aee856b5f9c14a6e26e3b7 Mon Sep 17 00:00:00 2001 From: Paul Duffin Date: Wed, 15 Jan 2020 14:23:52 +0000 Subject: [PATCH] Allow an arbitrary tag to be associated with a bp property This is preparation for enhancing the versioning tranformer to support applying per property transformations. Specifically, to allow properties to reference other libraries within the sdk. Bug: 142940300 Test: m nothing Change-Id: I99cdff4b407763ed395ff358d8110a63c6cf5589 --- android/sdk.go | 7 +++++- sdk/bp.go | 62 ++++++++++++++++++++++++++++++++++---------------- sdk/update.go | 2 +- 3 files changed, 49 insertions(+), 22 deletions(-) diff --git a/android/sdk.go b/android/sdk.go index 9e6ad161a..006b3a01e 100644 --- a/android/sdk.go +++ b/android/sdk.go @@ -182,6 +182,8 @@ type SnapshotBuilder interface { AddPrebuiltModule(member SdkMember, moduleType string) BpModule } +type BpPropertyTag interface{} + // A set of properties for use in a .bp file. type BpPropertySet interface { // Add a property, the value can be one of the following types: @@ -190,9 +192,12 @@ type BpPropertySet interface { // * bool // * BpPropertySet // - // It is an error is multiples properties with the same name are added. + // It is an error if multiple properties with the same name are added. AddProperty(name string, value interface{}) + // Add a property with an associated tag + AddPropertyWithTag(name string, value interface{}, tag BpPropertyTag) + // Add a property set with the specified name and return so that additional // properties can be added. AddPropertySet(name string) BpPropertySet diff --git a/sdk/bp.go b/sdk/bp.go index e0e06f305..6936daf94 100644 --- a/sdk/bp.go +++ b/sdk/bp.go @@ -22,6 +22,7 @@ import ( type bpPropertySet struct { properties map[string]interface{} + tags map[string]android.BpPropertyTag order []string } @@ -29,6 +30,7 @@ var _ android.BpPropertySet = (*bpPropertySet)(nil) func (s *bpPropertySet) init() { s.properties = make(map[string]interface{}) + s.tags = make(map[string]android.BpPropertyTag) } func (s *bpPropertySet) AddProperty(name string, value interface{}) { @@ -40,6 +42,11 @@ func (s *bpPropertySet) AddProperty(name string, value interface{}) { s.order = append(s.order, name) } +func (s *bpPropertySet) AddPropertyWithTag(name string, value interface{}, tag android.BpPropertyTag) { + s.AddProperty(name, value) + s.tags[name] = tag +} + func (s *bpPropertySet) AddPropertySet(name string) android.BpPropertySet { set := &bpPropertySet{} set.init() @@ -51,15 +58,21 @@ func (s *bpPropertySet) getValue(name string) interface{} { return s.properties[name] } +func (s *bpPropertySet) getTag(name string) interface{} { + return s.tags[name] +} + func (s *bpPropertySet) transform(transformer bpPropertyTransformer) { var newOrder []string for _, name := range s.order { value := s.properties[name] + tag := s.tags[name] var newValue interface{} + var newTag android.BpPropertyTag if propertySet, ok := value.(*bpPropertySet); ok { - newValue = transformer.transformPropertySet(name, propertySet) + newValue, newTag = transformer.transformPropertySet(name, propertySet, tag) } else { - newValue = transformer.transformProperty(name, value) + newValue, newTag = transformer.transformProperty(name, value, tag) } if newValue == nil { @@ -68,6 +81,7 @@ func (s *bpPropertySet) transform(transformer bpPropertyTransformer) { } else { // Update the property in the map and add the name to the new order list. s.properties[name] = newValue + s.tags[name] = newTag newOrder = append(newOrder, name) } } @@ -79,6 +93,7 @@ func (s *bpPropertySet) setProperty(name string, value interface{}) { s.AddProperty(name, value) } else { s.properties[name] = value + s.tags[name] = nil } } @@ -113,20 +128,20 @@ type bpModule struct { var _ android.BpModule = (*bpModule)(nil) type bpPropertyTransformer interface { - // Transform the property set, returning the new property set to insert back into the + // Transform the property set, returning the new property set/tag to insert back into the // parent property set (or module if this is the top level property set). // // This will be called before transforming the properties in the supplied set. // // The name will be "" for the top level property set. // - // Returning nil will cause the property set to be removed. - transformPropertySet(name string, propertySet *bpPropertySet) *bpPropertySet + // Returning (nil, ...) will cause the property set to be removed. + transformPropertySet(name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) - // Transform a property, return the new value to insert back into the property set. + // Transform a property, return the new value/tag to insert back into the property set. // - // Returning nil will cause the property to be removed. - transformProperty(name string, value interface{}) interface{} + // Returning (nil, ...) will cause the property to be removed. + transformProperty(name string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag) } // Interface for transforming bpModule objects. @@ -150,12 +165,12 @@ func (t identityTransformation) transformModule(module *bpModule) *bpModule { return module } -func (t identityTransformation) transformPropertySet(name string, propertySet *bpPropertySet) *bpPropertySet { - return propertySet +func (t identityTransformation) transformPropertySet(name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) { + return propertySet, tag } -func (t identityTransformation) transformProperty(name string, value interface{}) interface{} { - return value +func (t identityTransformation) transformProperty(name string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag) { + return value, tag } func (m *bpModule) deepCopy() *bpModule { @@ -165,7 +180,7 @@ func (m *bpModule) deepCopy() *bpModule { func (m *bpModule) transform(transformer bpTransformer) *bpModule { transformedModule := transformer.transformModule(m) // Copy the contents of the returned property set into the module and then transform that. - transformedModule.bpPropertySet = transformer.transformPropertySet("", transformedModule.bpPropertySet) + transformedModule.bpPropertySet, _ = transformer.transformPropertySet("", transformedModule.bpPropertySet, nil) transformedModule.bpPropertySet.transform(transformer) return transformedModule } @@ -179,29 +194,36 @@ func (t deepCopyTransformation) transformModule(module *bpModule) *bpModule { return &moduleCopy } -func (t deepCopyTransformation) transformPropertySet(name string, propertySet *bpPropertySet) *bpPropertySet { +func (t deepCopyTransformation) transformPropertySet(name string, propertySet *bpPropertySet, tag android.BpPropertyTag) (*bpPropertySet, android.BpPropertyTag) { // Create a shallow copy of the properties map. Any mutable property values will be copied by the // transformer. propertiesCopy := make(map[string]interface{}) - for p, v := range propertySet.properties { - propertiesCopy[p] = v + for propertyName, value := range propertySet.properties { + propertiesCopy[propertyName] = value + } + + // Ditto for tags map. + tagsCopy := make(map[string]android.BpPropertyTag) + for propertyName, propertyTag := range propertySet.tags { + tagsCopy[propertyName] = propertyTag } // Create a new property set. return &bpPropertySet{ properties: propertiesCopy, + tags: tagsCopy, order: append([]string(nil), propertySet.order...), - } + }, tag } -func (t deepCopyTransformation) transformProperty(name string, value interface{}) interface{} { +func (t deepCopyTransformation) transformProperty(name string, value interface{}, tag android.BpPropertyTag) (interface{}, android.BpPropertyTag) { // Copy string slice, otherwise return value. if values, ok := value.([]string); ok { valuesCopy := make([]string, len(values)) copy(valuesCopy, values) - return valuesCopy + return valuesCopy, tag } - return value + return value, tag } var deepCopyTransformer bpTransformer = deepCopyTransformation{} diff --git a/sdk/update.go b/sdk/update.go index 56ce1fc5d..0d2e4e44e 100644 --- a/sdk/update.go +++ b/sdk/update.go @@ -314,7 +314,7 @@ func generateBpContents(contents *generatedContents, bpFile *bpFile) { func outputPropertySet(contents *generatedContents, set *bpPropertySet) { contents.Indent() for _, name := range set.order { - value := set.properties[name] + value := set.getValue(name) reflectedValue := reflect.ValueOf(value) t := reflectedValue.Type()