update

Author: steiler

pkg/tree/entry.go

@@ -127,9 +127,7 @@ type Entry interface {
 	//    - remainsToExists() returns true, because they remain to exist even though implicitly.
 	//    - shouldDelete() returns false, because no explicit delete should be issued for them.
 	canDelete() bool
-	// getChildren returns all the child Entries of the Entry in a map indexed by there name.
-	// FYI: leaf values are not considered children
-	getChildren() map[string]Entry
+	GetChilds(DescendMethod) EntryMap
 	FilterChilds(keys map[string]string) ([]Entry, error)
 	// ToJson returns the Tree contained structure as JSON
 	// use e.g. json.MarshalIndent() on the returned struct
@@ -160,6 +158,7 @@ type Entry interface {
 }
 
 type EntryVisitor interface {
+	Config() *EntryVisitorConfig
 	Visit(ctx context.Context, e Entry) error
 	Up()
 }
@@ -178,3 +177,25 @@ type LeafVariantEntries interface {
 	AddExplicitDeleteEntry(owner string, priority int32) *LeafEntry
 	GetByOwner(owner string) *LeafEntry
 }
+
+type EntryVisitorConfig struct {
+	descendMethod DescendMethod
+}
+
+func NewEntryVisitorConfig() *EntryVisitorConfig {
+	return &EntryVisitorConfig{
+		descendMethod: DescendMethodActiveChilds,
+	}
+}
+
+func (e *EntryVisitorConfig) SetDescendingMethod(d DescendMethod) *EntryVisitorConfig {
+	e.descendMethod = d
+	return e
+}
+
+type DescendMethod int
+
+const (
+	DescendMethodAll DescendMethod = iota
+	DescendMethodActiveChilds
+)

pkg/tree/entry_map.go

@@ -0,0 +1,3 @@
+package tree
+
+type EntryMap map[string]Entry

pkg/tree/json.go

@@ -41,7 +41,7 @@ func (s *sharedEntryAttributes) toJsonInternal(onlyNewOrUpdated bool, ietf bool)
 		// ancestor is a list with keys.
 		result := map[string]any{}
 
-		for key, c := range s.filterActiveChoiceCaseChilds() {
+		for key, c := range s.GetChilds(DescendMethodActiveChilds) {
 			ancest, _ := s.GetFirstAncestorWithSchema()
 			prefixedKey := jsonGetIetfPrefixConditional(key, c, ancest, ietf)
 			// recurse the call
@@ -101,7 +101,7 @@ func (s *sharedEntryAttributes) toJsonInternal(onlyNewOrUpdated bool, ietf bool)
 		default:
 			// otherwise this is a map
 			result := map[string]any{}
-			for key, c := range s.filterActiveChoiceCaseChilds() {
+			for key, c := range s.GetChilds(DescendMethodActiveChilds) {
 				prefixedKey := jsonGetIetfPrefixConditional(key, c, s, ietf)
 				js, err := c.toJsonInternal(onlyNewOrUpdated, ietf)
 				if err != nil {

pkg/tree/sharedEntryAttributes.go

@@ -172,15 +172,15 @@ func (s *sharedEntryAttributes) GetDeviations(ch chan<- *types.DeviationEntry, a
 	// if s is a presence container but has active childs, it should not be treated as a presence
 	// container, hence the leafvariants should not be processed. For presence container with
 	// childs the TypedValue.empty_val in the presence container is irrelevant.
-	if s.schema.GetContainer().GetIsPresence() && len(s.filterActiveChoiceCaseChilds()) > 0 {
+	if s.schema.GetContainer().GetIsPresence() && len(s.GetChilds(DescendMethodActiveChilds)) > 0 {
 		return
 	}
 
 	// calculate Deviation on the LeafVariants
 	s.leafVariants.GetDeviations(ch, activeCase)
 
 	// get all active childs
-	activeChilds := s.filterActiveChoiceCaseChilds()
+	activeChilds := s.GetChilds(DescendMethodActiveChilds)
 
 	// iterate through all childs
 	for cName, c := range s.getChildren() {
@@ -332,7 +332,7 @@ func (s *sharedEntryAttributes) GetListChilds() ([]Entry, error) {
 	for level := 0; level < len(keys); level++ {
 		for _, e := range actualEntries {
 			// add all children
-			for _, c := range e.getChildren() {
+			for _, c := range e.GetChilds(DescendMethodAll) {
 				newEntries = append(newEntries, c)
 			}
 		}
@@ -369,7 +369,7 @@ func (s *sharedEntryAttributes) FilterChilds(keys map[string]string) ([]Entry, e
 			// therefor we need to go through the processEntries List
 			// and collect all the matching childs
 			for _, entry := range processEntries {
-				childs := entry.getChildren()
+				childs := entry.GetChilds(DescendMethodAll)
 				matchEntry, childExists := childs[keyVal]
 				// so if such child, that matches the given filter value exists, we append it to the results
 				if childExists {
@@ -380,7 +380,7 @@ func (s *sharedEntryAttributes) FilterChilds(keys map[string]string) ([]Entry, e
 			// this is basically the wildcard case, so go through all childs and add them
 			result = []Entry{}
 			for _, entry := range processEntries {
-				childs := entry.getChildren()
+				childs := entry.GetChilds(DescendMethodAll)
 				for _, v := range childs {
 					// hence we add all the existing childs to the result list
 					result = append(result, v)
@@ -430,7 +430,7 @@ func (s *sharedEntryAttributes) Walk(ctx context.Context, v EntryVisitor) error
 	}
 
 	// trigger the execution on all childs
-	for _, c := range s.childs.GetAll() {
+	for _, c := range s.GetChilds(v.Config().descendMethod) {
 		err := c.Walk(ctx, v)
 		if err != nil {
 			return err
@@ -533,7 +533,7 @@ func (s *sharedEntryAttributes) canDelete() bool {
 	}
 
 	// handle containers
-	for _, c := range s.filterActiveChoiceCaseChilds() {
+	for _, c := range s.GetChilds(DescendMethodActiveChilds) {
 		canDelete := c.canDelete()
 		if !canDelete {
 			s.cacheCanDelete = utils.BoolPtr(false)
@@ -560,7 +560,7 @@ func (s *sharedEntryAttributes) shouldDelete() bool {
 	// but a real delete should only be added if there is at least one shouldDelete() == true
 	shouldDelete := false
 
-	activeChilds := s.filterActiveChoiceCaseChilds()
+	activeChilds := s.GetChilds(DescendMethodActiveChilds)
 	// if we have no active childs, we can and should delete.
 	if len(s.choicesResolvers) > 0 && len(activeChilds) == 0 {
 		canDelete = true
@@ -607,7 +607,7 @@ func (s *sharedEntryAttributes) remainsToExist() bool {
 
 	// handle containers
 	childsRemain := false
-	for _, c := range s.filterActiveChoiceCaseChilds() {
+	for _, c := range s.GetChilds(DescendMethodActiveChilds) {
 		childsRemain = c.remainsToExist()
 		if childsRemain {
 			break
@@ -757,7 +757,7 @@ func (s *sharedEntryAttributes) NavigateSdcpbPath(ctx context.Context, pathElems
 		}
 		return entry.NavigateSdcpbPath(ctx, pathElems[1:], false)
 	default:
-		e, exists := s.filterActiveChoiceCaseChilds()[pathElems[0].Name]
+		e, exists := s.GetChilds(DescendMethodActiveChilds)[pathElems[0].Name]
 		if !exists {
 			pth := &sdcpb.Path{Elem: pathElems}
 			e, err = s.tryLoadingDefault(ctx, utils.ToStrings(pth, false, false))
@@ -830,7 +830,7 @@ func (s *sharedEntryAttributes) Navigate(ctx context.Context, path []string, isR
 		}
 		return parent.Navigate(ctx, path[1:], false, dotdotSkipKeys)
 	default:
-		e, exists := s.filterActiveChoiceCaseChilds()[path[0]]
+		e, exists := s.GetChilds(DescendMethodActiveChilds)[path[0]]
 		if !exists {
 			e, err = s.tryLoadingDefault(ctx, append(s.Path(), path...))
 			if err != nil {
@@ -885,7 +885,7 @@ func (s *sharedEntryAttributes) GetHighestPrecedence(result LeafVariantSlice, on
 	}
 
 	// continue with childs. Childs are part of choices, process only the "active" (highes precedence) childs
-	for _, c := range s.filterActiveChoiceCaseChilds() {
+	for _, c := range s.GetChilds(DescendMethodActiveChilds) {
 		result = c.GetHighestPrecedence(result, onlyNewOrUpdated, includeDefaults)
 	}
 	return result
@@ -950,7 +950,7 @@ func (s *sharedEntryAttributes) Validate(ctx context.Context, resultChan chan<-
 	// recurse the call to the child elements
 	wg := sync.WaitGroup{}
 	defer wg.Wait()
-	for _, c := range s.filterActiveChoiceCaseChilds() {
+	for _, c := range s.GetChilds(DescendMethodActiveChilds) {
 		wg.Add(1)
 		valFunc := func(x Entry) {
 			x.Validate(ctx, resultChan, statChan, vCfg)
@@ -1182,7 +1182,7 @@ func (s *sharedEntryAttributes) ImportConfig(ctx context.Context, t importer.Imp
 					return err
 				}
 				// if the child does not exist, create it
-				if keyChild, exists = actualEntry.getChildren()[keyElemValue]; !exists {
+				if keyChild, exists = actualEntry.GetChilds(DescendMethodAll)[keyElemValue]; !exists {
 					keyChild, err = newEntry(ctx, actualEntry, keyElemValue, s.treeContext)
 					if err != nil {
 						return err
@@ -1335,7 +1335,7 @@ func (s *sharedEntryAttributes) validateMandatoryWithKeys(ctx context.Context, l
 		// iterate over the attributes make sure any of these exists
 		for _, attr := range attributes {
 			// first check if the mandatory value is set via the intent, e.g. part of the tree already
-			v, existsInTree = s.filterActiveChoiceCaseChilds()[attr]
+			v, existsInTree = s.GetChilds(DescendMethodActiveChilds)[attr]
 			// if exists and remains to Exist
 			if existsInTree && v.remainsToExist() {
 				// set success to true and break the loop
@@ -1358,7 +1358,7 @@ func (s *sharedEntryAttributes) validateMandatoryWithKeys(ctx context.Context, l
 		return
 	}
 
-	for _, c := range s.filterActiveChoiceCaseChilds() {
+	for _, c := range s.GetChilds(DescendMethodActiveChilds) {
 		c.validateMandatoryWithKeys(ctx, level-1, attributes, choiceName, resultChan)
 	}
 }
@@ -1411,7 +1411,7 @@ func (s *sharedEntryAttributes) FinishInsertionPhase(ctx context.Context) error
 
 	// recurse the call to all (active) entries within the tree.
 	// Thereby already using the choiceCaseResolver via filterActiveChoiceCaseChilds()
-	for _, child := range s.filterActiveChoiceCaseChilds() {
+	for _, child := range s.GetChilds(DescendMethodActiveChilds) {
 		err = child.FinishInsertionPhase(ctx)
 		if err != nil {
 			return err
@@ -1473,31 +1473,59 @@ func (s *sharedEntryAttributes) populateChoiceCaseResolvers(_ context.Context) e
 	return nil
 }
 
-// filterActiveChoiceCaseChilds returns the list of child elements. In case the Entry is
-// a container with a / multiple choices, the list of childs is filtered to only return the
-// cases that have the highest precedence.
-func (s *sharedEntryAttributes) filterActiveChoiceCaseChilds() map[string]Entry {
+func (s *sharedEntryAttributes) GetChilds(d DescendMethod) EntryMap {
 	if s.schema == nil {
 		return s.childs.GetAll()
 	}
 
-	skipAttributesList := s.choicesResolvers.GetSkipElements()
-	// if there are no items that should be skipped, take a shortcut
-	// and simply return all childs straight away
-	if len(skipAttributesList) == 0 {
+	switch d {
+	case DescendMethodAll:
 		return s.childs.GetAll()
-	}
-	result := map[string]Entry{}
-	// optimization option: sort the slices and forward in parallel, lifts extra burden that the contains call holds.
-	for childName, child := range s.childs.GetAll() {
-		if slices.Contains(skipAttributesList, childName) {
-			continue
+	case DescendMethodActiveChilds:
+		skipAttributesList := s.choicesResolvers.GetSkipElements()
+		// if there are no items that should be skipped, take a shortcut
+		// and simply return all childs straight away
+		if len(skipAttributesList) == 0 {
+			return s.childs.GetAll()
+		}
+		result := map[string]Entry{}
+		// optimization option: sort the slices and forward in parallel, lifts extra burden that the contains call holds.
+		for childName, child := range s.childs.GetAll() {
+			if slices.Contains(skipAttributesList, childName) {
+				continue
+			}
+			result[childName] = child
 		}
-		result[childName] = child
+		return result
 	}
-	return result
+	return nil
 }
 
+// // filterActiveChoiceCaseChilds returns the list of child elements. In case the Entry is
+// // a container with a / multiple choices, the list of childs is filtered to only return the
+// // cases that have the highest precedence.
+// func (s *sharedEntryAttributes) filterActiveChoiceCaseChilds() map[string]Entry {
+// 	if s.schema == nil {
+// 		return s.childs.GetAll()
+// 	}
+
+// 	skipAttributesList := s.choicesResolvers.GetSkipElements()
+// 	// if there are no items that should be skipped, take a shortcut
+// 	// and simply return all childs straight away
+// 	if len(skipAttributesList) == 0 {
+// 		return s.childs.GetAll()
+// 	}
+// 	result := map[string]Entry{}
+// 	// optimization option: sort the slices and forward in parallel, lifts extra burden that the contains call holds.
+// 	for childName, child := range s.childs.GetAll() {
+// 		if slices.Contains(skipAttributesList, childName) {
+// 			continue
+// 		}
+// 		result[childName] = child
+// 	}
+// 	return result
+// }
+
 // StringIndent returns the sharedEntryAttributes in its string representation
 // The string is intented according to the nesting level in the yang model
 func (s *sharedEntryAttributes) StringIndent(result []string) []string {

pkg/tree/sharedEntryAttributes_test.go

@@ -391,7 +391,7 @@ func Test_sharedEntryAttributes_GetListChilds(t *testing.T) {
 			for _, elem := range got {
 				elemNames = append(elemNames, elem.PathName())
 				elemChilds[elem.PathName()] = []string{}
-				for k := range elem.getChildren() {
+				for k := range elem.GetChilds(DescendMethodAll) {
 					elemChilds[elem.PathName()] = append(elemChilds[elem.PathName()], k)
 				}
 			}

pkg/tree/sorter.go

@@ -6,11 +6,11 @@ func getListEntrySortFunc(parent Entry) func(a, b Entry) int {
 		keys := parent.GetSchemaKeys()
 		var cmpResult int
 		for _, v := range keys {
-			achild, exists := a.getChildren()[v]
+			achild, exists := a.GetChilds(DescendMethodAll)[v]
 			if !exists {
 				return 0
 			}
-			bchild, exists := b.getChildren()[v]
+			bchild, exists := b.GetChilds(DescendMethodAll)[v]
 			if !exists {
 				return 0
 			}

pkg/tree/types/update_insert_flags.go

@@ -63,6 +63,9 @@ func (f *UpdateInsertFlags) GetNewFlag() bool {
 }
 
 func (f *UpdateInsertFlags) Apply(le LeafEntry) *UpdateInsertFlags {
+	if f.explicitDelete {
+		le.MarkExpliciteDelete()
+	}
 	if f.delete {
 		le.MarkDelete(f.onlyIntended)
 		return f
@@ -71,9 +74,6 @@ func (f *UpdateInsertFlags) Apply(le LeafEntry) *UpdateInsertFlags {
 		le.MarkNew()
 		return f
 	}
-	if f.explicitDelete {
-		le.MarkExpliciteDelete()
-	}
 	return f
 }
 

pkg/tree/visitor_explicit_delete.go

@@ -35,10 +35,15 @@ func (edv *ExplicitDeleteVisitor) Visit(ctx context.Context, e Entry) error {
 	edv.relatedLeafVariants = append(edv.relatedLeafVariants, le)
 	return nil
 }
+
 func (edv *ExplicitDeleteVisitor) Up() {
 	// noop
 }
 
+func (o *ExplicitDeleteVisitor) Config() *EntryVisitorConfig {
+	return NewEntryVisitorConfig().SetDescendingMethod(DescendMethodAll)
+}
+
 // GetExplicitDeleteCreationCount returns the amount of all the explicitDelete LeafVariants that where created.
 func (edv *ExplicitDeleteVisitor) GetExplicitDeleteCreationCount() int {
 	return len(edv.relatedLeafVariants)