Finalized resolver

providers/xmlprovider/models.go

@@ -0,0 +1,29 @@
+package xmlprovider
+
+import "fmt"
+
+type XMLItem interface {
+	fmt.Stringer
+	Keys() []string
+	Name() string
+}
+
+type ILibrary interface {
+	Parse(meta ParseMeta) error
+}
+
+type ResolvingMap[T XMLItem] map[string][]Resolved[T]
+
+type ReferenceResolver[T XMLItem] interface {
+	References() ResolvingMap[T]
+}
+
+type Resolved[T XMLItem] struct {
+	Item       *T
+	Reference  string
+	Category   string
+	Cert       bool
+	Conjecture bool
+	Comment    string
+	MetaData   map[string]string
+}

providers/xmlprovider/resolver.go

@@ -7,30 +7,26 @@ import (
 	"sync"
 )
 
-type ReferenceResolver interface {
-	GetReferences() map[string][]string
-}
-
 type Resolver[T XMLItem] struct {
-	index map[string]map[string][]*T // Map[typeName][refID] -> []*T
-	mu    sync.Mutex                 // Synchronization for thread safety
+	index map[string]map[string][]Resolved[T] // Map[typeName][refID] -> []*T
+	mu    sync.Mutex                          // Synchronization for thread safety
 }
 
 func NewResolver[T XMLItem]() *Resolver[T] {
-	return &Resolver[T]{index: make(map[string]map[string][]*T)}
+	return &Resolver[T]{index: make(map[string]map[string][]Resolved[T])}
 }
 
-func (r *Resolver[T]) Add(typeName, refID string, item *T) {
+func (r *Resolver[T]) Add(typeName, refID string, item Resolved[T]) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
 	if _, exists := r.index[typeName]; !exists {
-		r.index[typeName] = make(map[string][]*T)
+		r.index[typeName] = make(map[string][]Resolved[T])
 	}
 	r.index[typeName][refID] = append(r.index[typeName][refID], item)
 }
 
-func (r *Resolver[T]) Get(typeName, refID string) ([]*T, error) {
+func (r *Resolver[T]) Get(typeName, refID string) ([]Resolved[T], error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 

providers/xmlprovider/xmlprovider.go

@@ -34,17 +34,6 @@ func (p ParseMeta) Failed(path string) bool {
 	return slices.Contains(p.FailedPaths, path)
 }
 
-type XMLItem interface {
-	fmt.Stringer
-	Keys() []string
-	Name() string
-}
-
-type ILibrary interface {
-	Parse(meta ParseMeta) error
-	Latest() *ParseMeta
-}
-
 // An XMLProvider is a struct that holds holds serialized XML data of a specific type. It combines multiple parses IF a succeeded parse can not serialize the data from a path.
 type XMLProvider[T XMLItem] struct {
 	// INFO: map is type map[string]*T
@@ -72,7 +61,8 @@ func NewXMLProvider[T XMLItem]() *XMLProvider[T] {
 func (p *XMLProvider[T]) Prepare() {
 	p.mu.Lock()
 	defer p.mu.Unlock()
-	p.Array = make([]T, 0)
+	// INFO: We take 1000 here as to not reallocate the memory as mutch.
+	p.Array = make([]T, 0, 1000)
 }
 
 func (p *XMLProvider[T]) Serialize(dataholder XMLRootElement[T], path string, latest ParseMeta) error {
@@ -94,13 +84,14 @@ func (p *XMLProvider[T]) Serialize(dataholder XMLRootElement[T], path string, la
 		}
 
 		// INFO: If the item has a GetReferences method, we add the references to the resolver.
-		// if refResolver, ok := any(item).(ReferenceResolver); ok {
-		// 	for name, ids := range refResolver.GetReferences() {
-		// 		for _, id := range ids {
-		// 			p.Resolver.Add(name, id, &item)
-		// 		}
-		// 	}
-		// }
+		if rr, ok := any(item).(ReferenceResolver[T]); ok {
+			for name, ids := range rr.References() {
+				for _, res := range ids {
+					res.Item = &item
+					p.Resolver.Add(name, res.Reference, res)
+				}
+			}
+		}
 	}
 
 	p.Array = append(p.Array, newItems...)
@@ -144,7 +135,7 @@ func (p *XMLProvider[T]) Cleanup(latest ParseMeta) {
 	}
 }
 
-func (p *XMLProvider[T]) ReverseLookup(item XMLItem) ([]*T, error) {
+func (p *XMLProvider[T]) ReverseLookup(item XMLItem) ([]Resolved[T], error) {
 	keys := item.Keys()
 
 	if len(keys) == 0 {
@@ -158,7 +149,7 @@ func (p *XMLProvider[T]) ReverseLookup(item XMLItem) ([]*T, error) {
 		}
 	}
 
-	return []*T{}, nil
+	return []Resolved[T]{}, nil
 }
 
 func (a *XMLProvider[T]) String() string {