feat: support for diffing presence containers

Co-authored-by: Terje Lafton <[email protected]>

Author: JonasKs

gogen/gogen.go

@@ -838,6 +838,12 @@ func (t *{{ .ParentReceiver }}) To_{{ .Name }}(i interface{}) ({{ .Name }}, erro
 	{{- end -}}
 	]", i, i)
 }
+`)
+	// presenceMethodTemplate provides a template to output a method
+	// indicating this is a presence container
+	presenceMethodTemplate = mustMakeTemplate("presenceMethodTemplate", `
+// IsPresence returns nothing, but indicates that the receiver is a presence container. 
+func (t *{{ .StructName }}) IsPresence() {}
 `)
 )
 
@@ -1403,6 +1409,14 @@ func writeGoStruct(targetStruct *ygen.ParsedDirectory, goStructElements map[stri
 		errs = append(errs, err)
 	}
 
+	if goOpts.AddYangPresence {
+		if targetStruct.PresenceContainer {
+			if err := presenceMethodTemplate.Execute(&methodBuf, structDef); err != nil {
+				errs = append(errs, err)
+			}
+		}
+	}
+
 	return GoStructCodeSnippet{
 		StructName: structDef.StructName,
 		StructDef:  structBuf.String(),

ygen/directory.go

@@ -193,6 +193,16 @@ func getOrderedDirDetails(langMapper LangMapper, directory map[string]*Directory
 			}
 		default:
 			pd.Type = Container
+			if len(dir.Entry.Extra["presence"]) > 0 {
+				if v := dir.Entry.Extra["presence"][0].(*yang.Value); v != nil {
+					pd.PresenceContainer = true
+				} else {
+					return nil, fmt.Errorf(
+                        "unable to retrieve presence statement, expected non-nil *yang.Value, got %v",
+                        dir.Entry.Extra["presence"][0]
+					)
+				}
+			}
 		}
 
 		for i, entry := 0, dir.Entry; ; i++ {

ygen/ir.go

@@ -468,6 +468,8 @@ type ParsedDirectory struct {
 	//
 	// https://github.com/openconfig/public/blob/master/release/models/openconfig-extensions.yang#L154
 	CompressedTelemetryAtomic bool
+	// PresenceContainer indicates that this container is a YANG presence container
+    PresenceContainer bool
 }
 
 // OrderedFieldNames returns the YANG name of all fields belonging to the

ygot/diff.go

@@ -254,6 +254,8 @@ func findSetLeaves(s GoStruct, orderedMapAsLeaf bool, opts ...DiffOpt) (map[*pat
 			return
 		}
 
+		isYangPresence := util.IsYangPresence(ni.StructField)
+
 		var sp [][]string
 		if pathOpt != nil && pathOpt.PreferShadowPath {
 			// Try the shadow-path tag first to see if it exists.
@@ -314,7 +316,9 @@ func findSetLeaves(s GoStruct, orderedMapAsLeaf bool, opts ...DiffOpt) (map[*pat
 		// treating it as a leaf (since it is assumed to be
 		// telemetry-atomic in order to preserve ordering of entries).
 		if (!isOrderedMap || !orderedMapAsLeaf) && util.IsValueStructPtr(ni.FieldValue) {
-			return
+			if !isYangPresence {
+				return
+			}
 		}
 		if isOrderedMap && orderedMap.Len() == 0 {
 			return
@@ -334,9 +338,17 @@ func findSetLeaves(s GoStruct, orderedMapAsLeaf bool, opts ...DiffOpt) (map[*pat
 			}
 		}
 
-		outs := out.(map[*pathSpec]interface{})
-		outs[vp] = ival
-
+	    // If the current field is tagged as a presence container,
+	    // we set it's value to `nil` instead of returning earlier.
+	    // This is because empty presence containers has a meaning,
+	    // unlike a normal container.
+		if isYangPresence {
+			outs := out.(map[*pathSpec]interface{})
+			outs[vp] = nil
+		} else {
+			outs := out.(map[*pathSpec]interface{})
+			outs[vp] = ival
+		}
 		if isOrderedMap && orderedMapAsLeaf {
 			// We treat the ordered map as a leaf, so don't
 			// traverse any descendant elements.

ygot/render.go

@@ -918,6 +918,11 @@ func marshalStructOrOrderedList(s any, enc gnmipb.Encoding, cfg *RFC7951JSONConf
 	if reflect.ValueOf(s).IsNil() {
 		return nil, nil
 	}
+    // A presence container might not be empty, but we should still
+    // treat it as such
+	if _, ok := s.(PresenceContainer); ok {
+		return nil, nil
+	}
 
 	var (
 		j     any

ygot/types.go

@@ -19,6 +19,14 @@ import (
 	"reflect"
 )
 
+// PresenceContainer is an interface which can be implemented by Go structs that are
+// generated to represent a YANG presence container.
+type PresenceContainer interface {
+	// IsPresence is a marker method that indicates that the struct
+	// implements the PresenceContainer interface.
+	IsPresence()
+}
+
 // GoStruct is an interface which can be implemented by Go structs that are
 // generated to represent a YANG container or list member. It simply allows
 // handling code to ensure that it is interacting with a struct that will meet