Use struct{} (5446a6f8) · Commits · e / os / android_build

tools/compliance/conditionset.go

+13 −13

Original line number	Diff line number	Diff line
		@@ -28,8 +28,8 @@ func NewLicenseConditionSet(conditions ...LicenseCondition) *LicenseConditionSet
		// LicenseConditionSet describes a mutable set of immutable license conditions.
		type LicenseConditionSet struct {
		// conditions describes the set of license conditions i.e. (condition name, origin target) pairs
		// by mapping condition name -> origin target -> true.
		conditions map[string]map[*TargetNode]bool
		// by mapping condition name -> origin target -> struct{}{}.
		conditions map[string]map[*TargetNode]struct{}
		}

		// Add makes all `conditions` members of the set if they were not previously.
		@@ -39,9 +39,9 @@ func (cs *LicenseConditionSet) Add(conditions ...LicenseCondition) {
		}
		for _, lc := range conditions {
		if _, ok := cs.conditions[lc.name]; !ok {
		cs.conditions[lc.name] = make(map[*TargetNode]bool)
		cs.conditions[lc.name] = make(map[*TargetNode]struct{})
		}
		cs.conditions[lc.name][lc.origin] = true
		cs.conditions[lc.name][lc.origin] = struct{}{}
		}
		}

		@@ -55,7 +55,7 @@ func (cs LicenseConditionSet) AddSet(other LicenseConditionSet) {
		continue
		}
		if _, ok := cs.conditions[name]; !ok {
		cs.conditions[name] = make(map[*TargetNode]bool)
		cs.conditions[name] = make(map[*TargetNode]struct{})
		}
		for origin := range origins {
		cs.conditions[name][origin] = other.conditions[name][origin]
		@@ -69,9 +69,9 @@ func (cs LicenseConditionSet) ByName(names ...ConditionNames) LicenseCondition
		for _, cn := range names {
		for _, name := range cn {
		if origins, ok := cs.conditions[name]; ok {
		other.conditions[name] = make(map[*TargetNode]bool)
		other.conditions[name] = make(map[*TargetNode]struct{})
		for origin := range origins {
		other.conditions[name][origin] = true
		other.conditions[name][origin] = struct{}{}
		}
		}
		}
		@@ -111,8 +111,8 @@ func (cs LicenseConditionSet) ByOrigin(origin TargetNode) *LicenseConditionSet
		other := newLicenseConditionSet()
		for name, origins := range cs.conditions {
		if _, ok := origins[origin]; ok {
		other.conditions[name] = make(map[*TargetNode]bool)
		other.conditions[name][origin] = true
		other.conditions[name] = make(map[*TargetNode]struct{})
		other.conditions[name][origin] = struct{}{}
		}
		}
		return other
		@@ -172,7 +172,7 @@ func (cs *LicenseConditionSet) Count() int {
		func (cs LicenseConditionSet) Copy() LicenseConditionSet {
		other := newLicenseConditionSet()
		for name := range cs.conditions {
		other.conditions[name] = make(map[*TargetNode]bool)
		other.conditions[name] = make(map[*TargetNode]struct{})
		for origin := range cs.conditions[name] {
		other.conditions[name][origin] = cs.conditions[name][origin]
		}
		@@ -241,16 +241,16 @@ func (cs LicenseConditionSet) RemoveSet(other LicenseConditionSet) {

		// newLicenseConditionSet constructs a set of `conditions`.
		func newLicenseConditionSet() *LicenseConditionSet {
		return &LicenseConditionSet{make(map[string]map[*TargetNode]bool)}
		return &LicenseConditionSet{make(map[string]map[*TargetNode]struct{})}
		}

		// add changes the set to include each element of `conditions` originating at `origin`.
		func (cs LicenseConditionSet) add(origin TargetNode, conditions ...string) {
		for _, name := range conditions {
		if _, ok := cs.conditions[name]; !ok {
		cs.conditions[name] = make(map[*TargetNode]bool)
		cs.conditions[name] = make(map[*TargetNode]struct{})
		}
		cs.conditions[name][origin] = true
		cs.conditions[name][origin] = struct{}{}
		}
		}

tools/compliance/graph.go

+3 −3

Original line number	Diff line number	Diff line
		@@ -387,12 +387,12 @@ type InstallMap struct {
		// Annotations typically distinguish between static linkage versus dynamic
		// versus tools that are used at build time but are not linked in any way.
		type TargetEdgeAnnotations struct {
		annotations map[string]bool
		annotations map[string]struct{}
		}

		// newEdgeAnnotations creates a new instance of TargetEdgeAnnotations.
		func newEdgeAnnotations() TargetEdgeAnnotations {
		return TargetEdgeAnnotations{make(map[string]bool)}
		return TargetEdgeAnnotations{make(map[string]struct{})}
		}

		// HasAnnotation returns true if an annotation `ann` is in the set.
		@@ -439,7 +439,7 @@ func (ea TargetEdgeAnnotations) AsList() []string {

		// TargetNodeSet describes a set of distinct nodes in a license graph.
		type TargetNodeSet struct {
		nodes map[*TargetNode]bool
		nodes map[*TargetNode]struct{}
		}

		// Contains returns true when `target` is an element of the set.

tools/compliance/policy/resolve.go

+4 −4

Original line number	Diff line number	Diff line
		@@ -83,7 +83,7 @@ func ResolveTopDownConditions(lg LicenseGraph) ResolutionSet {
		rmap := make(map[*TargetNode]actionSet)

		// cmap contains the set of targets walked as pure aggregates. i.e. containers
		cmap := make(map[*TargetNode]bool)
		cmap := make(map[*TargetNode]struct{})

		var walk func(fnode TargetNode, cs LicenseConditionSet, treatAsAggregate bool)

		@@ -93,7 +93,7 @@ func ResolveTopDownConditions(lg LicenseGraph) ResolutionSet {
		}
		rmap[fnode].add(fnode, cs)
		if treatAsAggregate {
		cmap[fnode] = true
		cmap[fnode] = struct{}{}
		}
		// add conditions attached to `fnode`
		cs = cs.Copy()
		@@ -179,7 +179,7 @@ func resolveBottomUp(lg LicenseGraph, priors map[TargetNode]actionSet) *Resolu
		rs := newResolutionSet()

		// cmap contains an entry for every target that was previously walked as a pure aggregate only.
		cmap := make(map[string]bool)
		cmap := make(map[string]struct{})

		var walk func(f string, treatAsAggregate bool) actionSet

		@@ -205,7 +205,7 @@ func resolveBottomUp(lg LicenseGraph, priors map[TargetNode]actionSet) *Resolu
		delete(cmap, f)
		}
		if treatAsAggregate {
		cmap[f] = true
		cmap[f] = struct{}{}
		}

		// add all the conditions from all the dependencies

tools/compliance/policy/shipped.go

+2 −2

Original line number	Diff line number	Diff line
		@@ -24,7 +24,7 @@ func ShippedNodes(lg LicenseGraph) TargetNodeSet {
		return shipped
		}

		tset := make(map[*TargetNode]bool)
		tset := make(map[*TargetNode]struct{})

		WalkTopDown(lg, func(lg LicenseGraph, tn TargetNode, path TargetEdgePath) bool {
		if _, alreadyWalked := tset[tn]; alreadyWalked {
		@@ -35,7 +35,7 @@ func ShippedNodes(lg LicenseGraph) TargetNodeSet {
		return false
		}
		}
		tset[tn] = true
		tset[tn] = struct{}{}
		return true
		})

tools/compliance/readgraph.go

+1 −1

Original line number	Diff line number	Diff line
		@@ -191,7 +191,7 @@ func addDependencies(edges []dependencyEdge, target string, dependencies []*li
		// look up a common constant annotation string from a small map
		// instead of creating 1000's of copies of the same 3 strings.
		if ann, ok := RecognizedAnnotations[a]; ok {
		annotations.annotations[ann] = true
		annotations.annotations[ann] = struct{}{}
		}
		}
		edges = append(edges, &dependencyEdge{target, dependency, annotations})