Add Initializers

Initializers.go

@@ -0,0 +1,20 @@
+package service
+
+type Initializer struct {
+	fn    func(interface{})
+	order float32
+}
+
+type Initializers []Initializer
+
+func (slice Initializers) Len() int {
+	return len(slice)
+}
+
+func (slice Initializers) Less(i, j int) bool {
+	return slice[i].order < slice[j].order
+}
+
+func (slice Initializers) Swap(i, j int) {
+	slice[i], slice[j] = slice[j], slice[i]
+}

manager.go

@@ -1,15 +1,19 @@
 package service
 
-import "errors"
+import (
+	"errors"
+	"sort"
+)
 
 // Service Manager
 type Manager struct {
 	AllowOverride  bool
-	ShareByDefault bool
+	ShareByDefault bool //Whether or not to share by default
 
-	factories FactoriesMap
-	services  ServicesMap
-	shared    SharedMap
+	factories    FactoriesMap
+	services     ServicesMap
+	shared       SharedMap
+	initializers Initializers
 }
 
 //Check for exists service
@@ -47,7 +51,15 @@ func (sm *Manager) SetFacgtory(name string, fn func(*Manager) interface{}) error
 
 }
 
-//Retrieve a registered instance
+func (sm *Manager) addInitializer(fn func(interface{}), order float32) {
+	sm.initializers = append(sm.initializers, Initializer{
+		fn:    fn,
+		order: order,
+	})
+
+	sort.Sort(sm.initializers)
+}
+
 func (sm *Manager) Get(name string) (service interface{}, err error) {
 
 	if se, found := sm.services.Get(name); found {
@@ -62,6 +74,10 @@ func (sm *Manager) Get(name string) (service interface{}, err error) {
 		err = errors.New("unable to fetch or create an instance for " + name)
 		return
 	}
+	// apply initializers
+	for _, init := range sm.initializers {
+		init.fn(service)
+	}
 
 	if sm.shared.Get(name) == true {
 
@@ -78,5 +94,6 @@ func NewManager() *Manager {
 		shared:         SharedMap{items: make(map[string]bool)},
 		factories:      FactoriesMap{items: make(map[string]func(*Manager) interface{})},
 		services:       ServicesMap{items: make(map[string]interface{})},
+		initializers:   Initializers{},
 	}
 }

manager_test.go

@@ -1,15 +1,19 @@
 package service
 
 import (
-	"testing"
-
 	. "github.com/smartystreets/goconvey/convey"
+	"reflect"
+	"testing"
 )
 
 type MyStruct struct {
 	Name string
 }
 
+type YourStruct struct {
+	Name string
+}
+
 func TestService(t *testing.T) {
 	Convey("get service", t, func() {
 		serviceManager := NewManager()
@@ -125,6 +129,46 @@ func TestService(t *testing.T) {
 		So(location2, ShouldEqual, "")
 	})
 
+	Convey("Initializers", t, func() {
+		serviceManager := NewManager()
+		serviceManager.SetFacgtory("MyStruct", func(sm *Manager) interface{} {
+			return &MyStruct{
+				Name: "foo",
+			}
+		})
+
+		serviceManager.SetFacgtory("YourStruct", func(sm *Manager) interface{} {
+			return &YourStruct{
+				Name: "foo",
+			}
+		})
+
+		serviceManager.addInitializer(func(service interface{}) {
+			if reflect.TypeOf(service) == reflect.TypeOf(&YourStruct{}) {
+				yourStruct := service.(*YourStruct)
+				yourStruct.Name += " World"
+
+			}
+		}, 2)
+
+		serviceManager.addInitializer(func(service interface{}) {
+			if reflect.TypeOf(service) == reflect.TypeOf(&YourStruct{}) {
+				yourStruct := service.(*YourStruct)
+				yourStruct.Name = "Hello"
+
+			}
+		}, 1)
+
+		service, _ := serviceManager.Get("MyStruct")
+		myStruct := service.(*MyStruct)
+
+		service2, _ := serviceManager.Get("YourStruct")
+		yourStruct := service2.(*YourStruct)
+
+		So(myStruct.Name, ShouldEqual, "foo")
+		So(yourStruct.Name, ShouldEqual, "Hello World")
+	})
+
 }
 
 func TestFailService(t *testing.T) {