Merge pull request #25 from ythadhani/merge_overlapping_slices

allow optional merge of overlapping slices

Author: ythadhani

ygot/struct_validation_map.go

@@ -15,10 +15,10 @@
 // Package ygot contains helper methods for dealing with structs that represent
 // a YANG schema. Particularly, it takes structs that represent a YANG schema -
 // generated by ygen:
-//	- Provides helper functions which simplify their usage such as functions
-//	  to return pointers to a type.
-//	- Renders structs to other output formats such as JSON, or gNMI
-//	  notifications.
+//   - Provides helper functions which simplify their usage such as functions
+//     to return pointers to a type.
+//   - Renders structs to other output formats such as JSON, or gNMI
+//     notifications.
 package ygot
 
 import (
@@ -554,6 +554,17 @@ type MergeOverwriteExistingFields struct{}
 // IsMergeOpt marks MergeStructOpt as a MergeOpt.
 func (*MergeOverwriteExistingFields) IsMergeOpt() {}
 
+// MergeOverlappingSlices is a MergeOpt that allows control of the merge behaviour
+// of MergeStructs and MergeStructInto functions.
+//
+// When used, slices (YANG leaf-lists) with overlapping elements will be merged
+// such that only those elements of the source are appended to the destination
+// that are not already present.
+type MergeOverlappingSlices struct{}
+
+// IsMergeOpt marks MergeStructOpt as a MergeOpt.
+func (*MergeOverlappingSlices) IsMergeOpt() {}
+
 // MergeStructs takes two input ValidatedGoStructs and merges their contents,
 // returning a new ValidatedGoStruct. If the input structs a and b are of
 // different types, an error is returned.
@@ -620,6 +631,18 @@ func fieldOverwriteEnabled(opts []MergeOpt) bool {
 	return false
 }
 
+// mergeOverlappigSlicesEnabled returns true if MergeOverlappingSlices
+// is present in the slice of MergeOpt.
+func mergeOverlappigSlicesEnabled(opts []MergeOpt) bool {
+	for _, o := range opts {
+		switch o.(type) {
+		case *MergeOverlappingSlices:
+			return true
+		}
+	}
+	return false
+}
+
 // copyStruct copies the fields of srcVal into the dstVal struct in-place.
 func copyStruct(dstVal, srcVal reflect.Value, opts ...MergeOpt) error {
 	if srcVal.Type() != dstVal.Type() {
@@ -870,32 +893,51 @@ func copySliceField(dstField, srcField reflect.Value, opts ...MergeOpt) error {
 		return nil
 	}
 
+	dstFieldUnqiue := map[interface{}]struct{}{}
 	if _, ok := srcField.Interface().([]Annotation); !ok {
 		if reflect.DeepEqual(srcField.Interface(), dstField.Interface()) {
 			return nil
 		}
-
-		unique, err := uniqueSlices(dstField, srcField)
+		_, err := validateSlices(dstField, srcField)
 		if err != nil {
-			return fmt.Errorf("error checking src and dst for uniqueness, got: %v", err)
+			return fmt.Errorf("error validating src and dst, got: %v", err)
 		}
-
-		if !unique {
-			// YANG lists and leaf-lists must be unique.
-			return fmt.Errorf("source and destination lists must be unique, got src: %v, dst: %v", srcField, dstField)
+		if !mergeOverlappigSlicesEnabled(opts) {
+			unique, err := uniqueSlices(dstField, srcField)
+			if err != nil {
+				return fmt.Errorf("error checking src and dst for uniqueness, got: %v", err)
+			}
+			if !unique {
+				// YANG lists and leaf-lists must be unique.
+				return fmt.Errorf("source and destination lists must be unique, got src: %v, dst: %v", srcField, dstField)
+			}
+		} else {
+			for i := 0; i < dstField.Len(); i++ {
+				dstFieldUnqiue[dstField.Index(i).Interface()] = struct{}{}
+			}
 		}
 	}
 
 	if !util.IsTypeStructPtr(srcField.Type().Elem()) {
 		for i := 0; i < srcField.Len(); i++ {
 			v := srcField.Index(i)
+			if mergeOverlappigSlicesEnabled(opts) {
+				if _, present := dstFieldUnqiue[v.Interface()]; present {
+					continue
+				}
+			}
 			dstField.Set(reflect.Append(dstField, v))
 		}
 		return nil
 	}
 
 	for i := 0; i < srcField.Len(); i++ {
 		v := srcField.Index(i)
+		if mergeOverlappigSlicesEnabled(opts) {
+			if _, present := dstFieldUnqiue[v.Interface()]; present {
+				continue
+			}
+		}
 		d := reflect.New(v.Type().Elem())
 		if err := copyStruct(d.Elem(), v.Elem(), opts...); err != nil {
 			return err
@@ -909,14 +951,6 @@ func copySliceField(dstField, srcField reflect.Value, opts ...MergeOpt) error {
 // whether a and b are disjoint. It returns true if the slices have unique
 // members, and false if not.
 func uniqueSlices(a, b reflect.Value) (bool, error) {
-	if !util.IsValueSlice(a) || !util.IsValueSlice(b) {
-		return false, fmt.Errorf("a and b must both be slices, got a: %v, b: %v", a.Type().Kind(), b.Type().Kind())
-	}
-
-	if a.Type().Elem() != b.Type().Elem() {
-		return false, fmt.Errorf("a and b do not contain the same type, got a: %v, b: %v", a.Type().Elem().Kind(), b.Type().Elem().Kind())
-	}
-
 	for i := 0; i < a.Len(); i++ {
 		for j := 0; j < b.Len(); j++ {
 			if reflect.DeepEqual(a.Index(i).Interface(), b.Index(j).Interface()) {
@@ -926,3 +960,13 @@ func uniqueSlices(a, b reflect.Value) (bool, error) {
 	}
 	return true, nil
 }
+
+func validateSlices(a, b reflect.Value) (bool, error) {
+	if !util.IsValueSlice(a) || !util.IsValueSlice(b) {
+		return false, fmt.Errorf("a and b must both be slices, got a: %v, b: %v", a.Type().Kind(), b.Type().Kind())
+	}
+	if a.Type().Elem() != b.Type().Elem() {
+		return false, fmt.Errorf("a and b do not contain the same type, got a: %v, b: %v", a.Type().Elem().Kind(), b.Type().Elem().Kind())
+	}
+	return true, nil
+}

ygot/struct_validation_map_test.go

@@ -2756,16 +2756,6 @@ func TestUniqueSlices(t *testing.T) {
 		inA:        reflect.ValueOf([]int{1, 2, 3}),
 		inB:        reflect.ValueOf([]int{4, 5, 6}),
 		wantUnique: true,
-	}, {
-		name:             "error: mismatched types",
-		inA:              reflect.ValueOf([]string{"american-dream"}),
-		inB:              reflect.ValueOf([]int{42}),
-		wantErrSubstring: "a and b do not contain the same type",
-	}, {
-		name:             "error: not slices",
-		inA:              reflect.ValueOf("beer-geek-breakfast"),
-		inB:              reflect.ValueOf([]string{"beer-mile"}),
-		wantErrSubstring: "a and b must both be slices",
 	}, {
 		name:       "not unique, strings",
 		inA:        reflect.ValueOf([]string{"beobrew-ipa", "berliner-weisse"}),
@@ -2811,3 +2801,44 @@ func TestUniqueSlices(t *testing.T) {
 		})
 	}
 }
+
+func TestValidateSlices(t *testing.T) {
+	type stringPtrStruct struct {
+		Foo *string
+	}
+
+	type sliceStruct struct {
+		Bar []string
+	}
+
+	tests := []struct {
+		name             string
+		inA              reflect.Value
+		inB              reflect.Value
+		wantValid        bool
+		wantErrSubstring string
+	}{{
+		name:             "error: mismatched types",
+		inA:              reflect.ValueOf([]string{"american-dream"}),
+		inB:              reflect.ValueOf([]int{42}),
+		wantErrSubstring: "a and b do not contain the same type",
+	}, {
+		name:             "error: not slices",
+		inA:              reflect.ValueOf("beer-geek-breakfast"),
+		inB:              reflect.ValueOf([]string{"beer-mile"}),
+		wantErrSubstring: "a and b must both be slices",
+	}}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := validateSlices(tt.inA, tt.inB)
+			if diff := errdiff.Substring(err, tt.wantErrSubstring); diff != "" {
+				t.Fatalf("%s: validateSlices(%v, %v): did not get expected error, %s", tt.name, tt.inA, tt.inB, diff)
+			}
+
+			if want := tt.wantValid; got != want {
+				t.Fatalf("%s: validateSlices(%v, %v): did not get expected status, got: %v, want: %v", tt.name, tt.inA, tt.inB, got, want)
+			}
+		})
+	}
+}