push getters info shared internal funcs

container_getters.go

@@ -6,105 +6,18 @@ import (
 
 // GetFromContainer Retrieves an instance from the given container based on type and key (panics if no valid implementations)
 func GetFromContainer[T any](con *Container, ctx context.Context, key ...KeyStringer) (T, context.Context) {
-	pointerTypeName := getPointerTypeName[T]()
-	typeID := getTypeID(pointerTypeName, key...)
-	lastRegisteredResolver := con.getLastRegisteredResolver(typeID)
-	if lastRegisteredResolver == nil { //not found, T is an alias
-
-		con.lock.RLock()
-		implementations, implExists := con.aliases[pointerTypeName]
-		con.lock.RUnlock()
-
-		if !implExists {
-			panic(noValidImplementation[T]())
-		}
-		count := len(implementations)
-		if count == 0 {
-			panic(noValidImplementation[T]())
-		}
-		for i := count - 1; i >= 0; i-- {
-			impl := implementations[i]
-			typeID = getTypeID(impl, key...)
-			lastRegisteredResolver = con.getLastRegisteredResolver(typeID)
-			if lastRegisteredResolver != nil {
-				break
-			}
-		}
-	}
-	if lastRegisteredResolver == nil {
-		panic(noValidImplementation[T]())
-	}
-	concrete, ctx := lastRegisteredResolver.resolveService(con, ctx)
-	return concrete.value.(T), ctx
+	return getFromContainer[T](con, ctx, key...)
 }
 
 // GetListFromContainer Retrieves a list of instances from the given container based on type and key
 func GetListFromContainer[T any](con *Container, ctx context.Context, key ...KeyStringer) ([]T, context.Context) {
-	inputPointerTypeName := getPointerTypeName[T]()
-
-	con.lock.RLock()
-	pointerTypeNames, implExists := con.aliases[inputPointerTypeName]
-	con.lock.RUnlock()
-
-	if implExists {
-		pointerTypeNames = append(pointerTypeNames, inputPointerTypeName)
-	} else {
-		pointerTypeNames = []pointerTypeName{inputPointerTypeName}
-	}
-
-	servicesArray := []T{}
-
-	for i := 0; i < len(pointerTypeNames); i++ {
-		pointerTypeName := pointerTypeNames[i]
-		// generate type identifier
-		typeID := getTypeID(pointerTypeName, key...)
-
-		// try to get service resolver from container
-		con.lock.RLock()
-		resolvers, resolverExists := con.resolvers[typeID]
-		con.lock.RUnlock()
-
-		if !resolverExists {
-			continue
-		}
-
-		for index := 0; index < len(resolvers); index++ {
-			resolver := resolvers[index]
-			if resolver.isPlaceHolder() && !resolver.isScopedValueResolved(ctx) {
-				//the resolver is a placeHolder and the placeHolder's value has not been provided
-				//don't panic, just skip (don't add anything to the list)
-				continue
-			}
-			con, newCtx := resolver.resolveService(con, ctx)
-			servicesArray = append(servicesArray, con.value.(T))
-			ctx = newCtx
-		}
-	}
-
-	return servicesArray, ctx
+	return getListFromContainer[T](con, ctx, key...)
 }
 
 // GetResolvedSingletonsFromContainer retrieves a list of Singleton instances that implement the [TInterface] from the given container.
 // See [GetResolvedSingletons] for more information.
 func GetResolvedSingletonsFromContainer[TInterface any](con *Container) []TInterface {
-	con.lock.RLock()
-	defer con.lock.RUnlock()
-
-	list := []*concrete{}
-
-	//filtering
-	for _, resolvers := range con.resolvers {
-		for _, resolver := range resolvers {
-			con, isInvokedSingleton := resolver.getInvokedSingleton()
-			if isInvokedSingleton {
-				if _, ok := con.value.(TInterface); ok {
-					list = append(list, con)
-				}
-			}
-		}
-	}
-
-	return sortAndSelect[TInterface](list)
+	return getResolvedSingletonsFromContainer[TInterface](con)
 }
 
 // TODO separate to a file
@@ -121,7 +34,7 @@ func GetResolvedSingletonsFromContainer[TInterface any](con *Container) []TInter
 //		   disposable.Dispose()
 //		 }
 func GetResolvedSingletons[TInterface any]() []TInterface {
-	return GetResolvedSingletonsFromContainer[TInterface](DefaultContainer)
+	return getResolvedSingletonsFromContainer[TInterface](DefaultContainer)
 }
 
 // TODO separate to a file

default_container_getters.go

@@ -6,10 +6,10 @@ import (
 
 // Get Retrieves an instance based on type and key (panics if no valid implementations)
 func Get[T any](ctx context.Context, key ...KeyStringer) (T, context.Context) {
-	return GetFromContainer[T](DefaultContainer, ctx, key...)
+	return getFromContainer[T](DefaultContainer, ctx, key...)
 }
 
 // GetList Retrieves a list of instances based on type and key
 func GetList[T any](ctx context.Context, key ...KeyStringer) ([]T, context.Context) {
-	return GetListFromContainer[T](DefaultContainer, ctx, key...)
+	return getListFromContainer[T](DefaultContainer, ctx, key...)
 }

internal_getters.go

@@ -1,6 +1,9 @@
 package ore
 
-import "sort"
+import (
+	"context"
+	"sort"
+)
 
 func (this *Container) getLastRegisteredResolver(typeID typeID) serviceResolver {
 	// try to get service resolver from container
@@ -39,3 +42,102 @@ func sortAndSelect[TInterface any](list []*concrete) []TInterface {
 	}
 	return result
 }
+
+func getFromContainer[T any](con *Container, ctx context.Context, key ...KeyStringer) (T, context.Context) {
+	pointerTypeName := getPointerTypeName[T]()
+	typeID := getTypeID(pointerTypeName, key...)
+	lastRegisteredResolver := con.getLastRegisteredResolver(typeID)
+	if lastRegisteredResolver == nil { //not found, T is an alias
+
+		con.lock.RLock()
+		implementations, implExists := con.aliases[pointerTypeName]
+		con.lock.RUnlock()
+
+		if !implExists {
+			panic(noValidImplementation[T]())
+		}
+		count := len(implementations)
+		if count == 0 {
+			panic(noValidImplementation[T]())
+		}
+		for i := count - 1; i >= 0; i-- {
+			impl := implementations[i]
+			typeID = getTypeID(impl, key...)
+			lastRegisteredResolver = con.getLastRegisteredResolver(typeID)
+			if lastRegisteredResolver != nil {
+				break
+			}
+		}
+	}
+	if lastRegisteredResolver == nil {
+		panic(noValidImplementation[T]())
+	}
+	concrete, ctx := lastRegisteredResolver.resolveService(con, ctx)
+	return concrete.value.(T), ctx
+}
+
+func getListFromContainer[T any](con *Container, ctx context.Context, key ...KeyStringer) ([]T, context.Context) {
+	inputPointerTypeName := getPointerTypeName[T]()
+
+	con.lock.RLock()
+	pointerTypeNames, implExists := con.aliases[inputPointerTypeName]
+	con.lock.RUnlock()
+
+	if implExists {
+		pointerTypeNames = append(pointerTypeNames, inputPointerTypeName)
+	} else {
+		pointerTypeNames = []pointerTypeName{inputPointerTypeName}
+	}
+
+	servicesArray := []T{}
+
+	for i := 0; i < len(pointerTypeNames); i++ {
+		pointerTypeName := pointerTypeNames[i]
+		// generate type identifier
+		typeID := getTypeID(pointerTypeName, key...)
+
+		// try to get service resolver from container
+		con.lock.RLock()
+		resolvers, resolverExists := con.resolvers[typeID]
+		con.lock.RUnlock()
+
+		if !resolverExists {
+			continue
+		}
+
+		for index := 0; index < len(resolvers); index++ {
+			resolver := resolvers[index]
+			if resolver.isPlaceHolder() && !resolver.isScopedValueResolved(ctx) {
+				//the resolver is a placeHolder and the placeHolder's value has not been provided
+				//don't panic, just skip (don't add anything to the list)
+				continue
+			}
+			con, newCtx := resolver.resolveService(con, ctx)
+			servicesArray = append(servicesArray, con.value.(T))
+			ctx = newCtx
+		}
+	}
+
+	return servicesArray, ctx
+}
+
+func getResolvedSingletonsFromContainer[TInterface any](con *Container) []TInterface {
+	con.lock.RLock()
+	defer con.lock.RUnlock()
+
+	list := []*concrete{}
+
+	//filtering
+	for _, resolvers := range con.resolvers {
+		for _, resolver := range resolvers {
+			con, isInvokedSingleton := resolver.getInvokedSingleton()
+			if isInvokedSingleton {
+				if _, ok := con.value.(TInterface); ok {
+					list = append(list, con)
+				}
+			}
+		}
+	}
+
+	return sortAndSelect[TInterface](list)
+}