[chore][pkg/stanza] Allow trie to store a value (open-telemetry#28592)

This PR enhances the internal `trie` struct (which is not yet in use
anywhere in the codebase) such that a node may contain any value.

The motivation for this is that I believe we may soon be able to migrate
`knownFiles` and `previousPollFiles` to tries, which will prove out the
functionality of the trie and also should improve efficiency of the
package overall.

pkg/stanza/fileconsumer/internal/trie/trie.go

@@ -12,93 +12,74 @@
 
 package trie // import "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/stanza/fileconsumer/internal/trie"
 
-type Trie struct {
- isEnd bool
- children map[byte]*Trie
+type Trie[T any] struct {
+ value *T
+ children map[byte]*Trie[T]
 }
 
 // NewTrie allocates and returns a new *Trie.
-func NewTrie() *Trie {
- return &Trie{}
+func NewTrie[T any]() *Trie[T] {
+ return &Trie[T]{children: make(map[byte]*Trie[T])}
 }
 
-func (trie *Trie) HasKey(key []byte) bool {
+func (trie *Trie[T]) Get(key []byte) T {
  node := trie
- isEnd := false
- for _, r := range key {
- node = node.children[r]
+ var value T
+ for _, b := range key {
+ node = node.children[b]
  if node == nil {
- return isEnd
+ return value // end of trie
  }
- // We have reached end of the current path and all the previous characters have matched
- // Return if current node is leaf and it is not root
- if node.isLeaf() && node != trie {
- return true
+ if node.value != nil {
+ value = *node.value
  }
- // check for any ending node in our current path
- isEnd = isEnd || node.isEnd
  }
- return isEnd
+ return value // end of fingerprint
 }
 
-// Put inserts the key into the trie
-func (trie *Trie) Put(key []byte) {
+// TODO []byte, T value parameters
+// Put inserts a value into the trie
+func (trie *Trie[T]) Put(key []byte, v T) {
  node := trie
- for _, r := range key {
- child, ok := node.children[r]
+ for _, b := range key {
+ _, ok := node.children[b]
  if !ok {
- if node.children == nil {
- node.children = map[byte]*Trie{}
- }
- child = NewTrie()
- node.children[r] = child
+ node.children[b] = NewTrie[T]()
  }
- node = child
+ node = node.children[b]
  }
- node.isEnd = true
+ node.value = &v
 }
 
-// Delete removes keys from the Trie. Returns true if node was found for the given key.
-// If the node or any of its ancestors
-// becomes childless as a result, it is removed from the trie.
-func (trie *Trie) Delete(key []byte) bool {
- var path []*Trie // record ancestors to check later
+// Delete removes a value from the Trie. Returns true if the value was found.
+// Any empty nodes which become childless as a result are removed from the trie.
+func (trie *Trie[T]) Delete(key []byte) bool {
+ var path []*Trie[T] // record ancestors to check later
  node := trie
  for _, b := range key {
- path = append(path, node)
  node = node.children[b]
  if node == nil {
- // node does not exist
  return false
  }
+ path = append(path, node)
  }
 
- // someonce called Delete() on the node which is not end of current path
- if !node.isEnd {
+ if node.value == nil {
  return false
  }
- node.isEnd = false
- // if leaf, remove it from its parent's children map. Repeat for ancestor path.
- if node.isLeaf() {
- // iterate backwards over path
- for i := len(path) - 1; i >= 0; i-- {
- parent := path[i]
- b := key[i]
- delete(parent.children, b)
- if !parent.isLeaf() {
- // parent has other children, stop
- break
- }
- parent.children = nil
- if parent.isEnd {
- // Parent has a value, stop
- break
- }
+
+ // Remove the value
+ node.value = nil
+
+ // Iterate back up the path and remove empty nodes
+ for i := len(path) - 1; i >= 0; i-- {
+ node := path[i]
+ b := key[i]
+ delete(node.children, b)
+ if len(node.children) > 0 || node.value != nil {
+ break // node has other children or a value, leave it
  }
  }
- return true // node (internal or not) existed and its value was nil'd
-}
 
-func (trie *Trie) isLeaf() bool {
- return len(trie.children) == 0
+ return true
 }