support custom key

fix register interface

add factory

add IsShared

make exists

Author: attson

container.go

@@ -5,54 +5,66 @@ import (
 )
 
 type Container struct {
-	instances map[reflect.Type]any
-	registers map[reflect.Type]any
+	instances map[any]any
+	registers map[any]any
+	factories []Factory
 }
 
 var DefaultContainer = NewContainer()
 
 func NewContainer() *Container {
 	return &Container{
-		instances: make(map[reflect.Type]any),
-		registers: make(map[reflect.Type]any),
+		instances: make(map[any]any),
+		registers: make(map[any]any),
 	}
 }
 
+func (c *Container) AddFactory(factory Factory) {
+	c.factories = append(c.factories, factory)
+}
+
 func (c *Container) Register(key any, value any) {
-	c.registers[bindKey(key)] = value
+	c.registers[key] = value
 }
 
 func (c *Container) Make(key any) any {
-	if a, ok := c.registers[bindKey(key)]; ok {
+	if a, ok := c.instances[key]; ok {
+		return a
+	}
+
+	if a, ok := c.registers[key]; ok {
 		of := reflect.ValueOf(a)
 		if of.Kind() == reflect.Func {
 			return of.Call(nil)[0].Interface()
 		}
 	} else {
-		if of, ok := key.(reflect.Type); ok {
-			if of.Kind() == reflect.Ptr {
-				return reflect.New(of.Elem()).Interface()
-			} else {
-				return reflect.New(of).Elem().Interface()
+		for _, factory := range c.factories {
+			if factory.Resolvable(key) {
+				v := factory.Resolve(key)
+				if factory.IsShared(key) {
+					c.instances[key] = v
+				}
+
+				return v
 			}
-		} else {
-			return reflect.New(reflect.TypeOf(key)).Elem().Interface()
 		}
+
+		return DefaultFactoryInstance.Resolve(key)
 	}
 
 	return nil
 }
 
 func (c *Container) Set(key any, ins any) {
-	c.instances[bindKey(key)] = ins
+	c.instances[key] = ins
 }
 
 func (c *Container) Get(key any) any {
-	return c.instances[bindKey(key)]
+	return c.instances[key]
 }
 
 func (c *Container) Has(key any) bool {
-	_, ok := c.instances[bindKey(key)]
+	_, ok := c.instances[key]
 
 	return ok
 }
@@ -61,61 +73,71 @@ func (c *Container) RegisteredKeys() []string {
 	var keys []string
 
 	for k, _ := range c.registers {
-		keys = append(keys, k.String())
+		keys = append(keys, reflect.TypeOf(k).String())
 	}
 
 	return keys
 }
 
 func (c *Container) Clear() {
-	c.instances = make(map[reflect.Type]any)
-	c.registers = make(map[reflect.Type]any)
-}
-
-func bindKey(key any) reflect.Type {
-	var of reflect.Type
-
-	// if key is reflect.Type
-	if t, ok := key.(reflect.Type); ok {
-		of = t
-	} else {
-		of = reflect.TypeOf(key)
-	}
-
-	return of
+	c.instances = make(map[any]any)
+	c.registers = make(map[any]any)
 }
 
 func Set[T any](ins T) {
-	var t T
+	var t *T
 
-	DefaultContainer.Set(reflect.TypeOf(t), ins)
+	DefaultContainer.Set(reflect.TypeOf(t).Elem(), ins)
 }
 
 func Get[T any]() T {
-	var t T
-	return DefaultContainer.Get(reflect.TypeOf(t)).(T)
+	var t *T
+
+	return DefaultContainer.Get(reflect.TypeOf(t).Elem()).(T)
 }
 
 func Has[T any]() bool {
-	var t T
-	return DefaultContainer.Has(reflect.TypeOf(t))
+	var t *T
+
+	return DefaultContainer.Has(reflect.TypeOf(t).Elem())
 }
 
 func Make[T any]() T {
-	var t T
+	var t *T
 
-	return DefaultContainer.Make(reflect.TypeOf(t)).(T)
+	return DefaultContainer.Make(reflect.TypeOf(t).Elem()).(T)
 }
 
 func Register[T any](callback any) {
-	var t T
-	DefaultContainer.Register(reflect.TypeOf(t), callback)
+	var t *T
+
+	DefaultContainer.Register(reflect.TypeOf(t).Elem(), callback)
 }
 
 func RegisteredKeys() []string {
 	return DefaultContainer.RegisteredKeys()
 }
 
+func RegisterK(key string, callback any) {
+	DefaultContainer.Register(key, callback)
+}
+
+func SetK(key string, ins any) {
+	DefaultContainer.Set(key, ins)
+}
+
+func MakeK[T any](key string) T {
+	return DefaultContainer.Make(key).(T)
+}
+
+func GetK[T any](key string) T {
+	return DefaultContainer.Get(key).(T)
+}
+
 func Clear() {
 	DefaultContainer.Clear()
 }
+
+func AddFactory(factory Factory) {
+	DefaultContainer.AddFactory(factory)
+}

container_test.go

@@ -2,7 +2,7 @@ package container
 
 import (
 	"fmt"
-	"strings"
+	"golang.org/x/exp/slices"
 	"testing"
 )
 
@@ -18,6 +18,10 @@ type I interface {
 	Key() string
 }
 
+type II interface {
+	Key() string
+}
+
 func testSetup() {
 	Clear()
 }
@@ -146,7 +150,7 @@ func TestNotRegister(t *testing.T) {
 	defer func() {
 		if err := recover(); err != nil {
 			e := fmt.Sprintf("%s", err)
-			if e != "reflect: New(nil)" {
+			if e != "interface conversion: interface is nil, not container.I" {
 				t.Error("test fail: " + e)
 			}
 		}
@@ -227,10 +231,66 @@ func TestRegisteredKeys(t *testing.T) {
 			Name: "test_interface",
 		}
 	})
+	keys := DefaultContainer.RegisteredKeys()
+
+	for _, s := range []string{"*container.Test", "container.Test", "*container.I"} {
+		if !slices.Contains(keys, s) {
+			t.Error("keys is not contain: " + s)
+		}
+	}
+}
+
+func TestRegisterWithKey(t *testing.T) {
+	testSetup()
+
+	SetK("test1", Test{
+		Name: "set1",
+	})
+	k := GetK[Test]("test1")
+	if k.Name != "set1" {
+		t.Error("test fail")
+	}
 
-	strings.Join(DefaultContainer.RegisteredKeys(), ",")
+	RegisterK("test2", func() any {
+		return Test{
+			Name: "test_struct",
+		}
+	})
 
-	if strings.Join(DefaultContainer.RegisteredKeys(), ",") != "*container.Test,container.Test,*container.I" {
-		t.Error("keys is not equal")
+	v1 := MakeK[Test]("test2")
+	if v1.Name != "test_struct" {
+		t.Error("test fail")
+	}
+}
+
+func TestRegisterInterfaces(t *testing.T) {
+	Set[I](Test{
+		Name: "set1",
+	})
+
+	Set[II](Test{
+		Name: "set2",
+	})
+
+	v1 := Get[I]()
+	if v1.Key() != "set1" {
+		t.Error("test fail")
+	}
+
+	v2 := Get[II]()
+	if v2.Key() != "set2" {
+		t.Error("test fail")
+	}
+}
+
+func TestMakeRegistered(t *testing.T) {
+	testSetup()
+	Set[I](Test{
+		Name: "set1",
+	})
+
+	v1 := Make[I]()
+	if v1.Key() != "set1" {
+		t.Error("test fail")
 	}
 }

factory.go

@@ -0,0 +1,42 @@
+package container
+
+import "reflect"
+
+type Factory interface {
+	Resolvable(key any) bool
+	Resolve(key any) any
+	IsShared(key any) bool
+}
+
+var DefaultFactoryInstance = DefaultFactory{}
+
+type DefaultFactory struct {
+}
+
+func (d DefaultFactory) Resolvable(key any) bool {
+	return true
+}
+
+func (d DefaultFactory) IsShared(key any) bool {
+	return false
+}
+
+func (d DefaultFactory) Resolve(key any) any {
+	var typ reflect.Type
+
+	if of, ok := key.(reflect.Type); ok {
+		typ = of
+	} else {
+		typ = reflect.TypeOf(key)
+	}
+
+	if typ == nil {
+		return nil
+	}
+
+	if typ.Kind() == reflect.Ptr {
+		return reflect.New(typ.Elem()).Interface()
+	} else {
+		return reflect.New(typ).Elem().Interface()
+	}
+}

go.mod

@@ -1,3 +1,5 @@
 module github.com/attson/container
 
 go 1.19
+
+require golang.org/x/exp v0.0.0-20231006140011-7918f672742d

go.sum

@@ -0,0 +1,2 @@
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=