Add Actor model

Author: johnteee

actor.go

@@ -0,0 +1,97 @@
+package fpgo
+
+import (
+	"time"
+)
+
+// ActorDef Actor model inspired by Erlang/Akka
+type ActorDef struct {
+	isClosed bool
+	ch       *chan interface{}
+	effect   func(*ActorDef, interface{})
+
+	context map[string]interface{}
+
+	children map[time.Time]*ActorDef
+	parent   *ActorDef
+}
+
+var defaultActor *ActorDef
+
+// GetDefault Get Default Actor
+func (actorSelf *ActorDef) GetDefault() *ActorDef {
+	return defaultActor
+}
+
+// New New Actor instance
+func (actorSelf *ActorDef) New(effect func(*ActorDef, interface{})) *ActorDef {
+	ch := make(chan interface{})
+	return actorSelf.NewByOptions(effect, &ch, map[string]interface{}{})
+}
+
+// NewByOptions New Actor by its options
+func (actorSelf *ActorDef) NewByOptions(effect func(*ActorDef, interface{}), ioCh *chan interface{}, context map[string]interface{}) *ActorDef {
+	newOne := ActorDef{ch: ioCh, effect: effect, context: context, children: map[time.Time]*ActorDef{}}
+	go newOne.run()
+
+	return &newOne
+}
+
+// Send Send a message to the Actor
+func (actorSelf *ActorDef) Send(message interface{}) {
+	if actorSelf.isClosed {
+		return
+	}
+
+	*(actorSelf.ch) <- message
+}
+
+// Spawn Spawn a new Actor with parent(this actor)
+func (actorSelf *ActorDef) Spawn(effect func(*ActorDef, interface{})) *ActorDef {
+	newOne := Actor.New(effect)
+	if actorSelf.isClosed {
+		return newOne
+	}
+
+	newOne.parent = actorSelf
+	actorSelf.children[time.Now()] = newOne
+
+	return newOne
+}
+
+// GetChild Get a child Actor by ID
+func (actorSelf *ActorDef) GetChild(id time.Time) *ActorDef {
+	return actorSelf.children[id]
+}
+
+// GetParent Get its parent Actor
+func (actorSelf *ActorDef) GetParent() *ActorDef {
+	return actorSelf.parent
+}
+
+// Close Close the Actor
+func (actorSelf *ActorDef) Close() {
+	actorSelf.isClosed = true
+
+	close(*actorSelf.ch)
+}
+
+// IsClosed Check is Closed
+func (actorSelf *ActorDef) IsClosed() bool {
+	return actorSelf.isClosed
+}
+
+func (actorSelf *ActorDef) run() {
+	for message := range *actorSelf.ch {
+		actorSelf.effect(actorSelf, message)
+	}
+}
+
+// Actor Actor utils instance
+var Actor ActorDef
+
+func init() {
+	Actor = *Actor.New(func(_ *ActorDef, _ interface{}) {})
+	Actor.Close()
+	defaultActor = &Actor
+}

actor_test.go

@@ -0,0 +1,65 @@
+package fpgo
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestActorCommon(t *testing.T) {
+	var expectedInt int
+	var actual int
+	var resultChannel chan interface{}
+
+	actual = 0
+	expectedInt = 1400
+	// Testee
+	resultChannel = make(chan interface{}, 5)
+	cmdSpawn := "spawn"
+	cmdShutdown := "shutdown"
+	actorRoot := Actor.New(func(self *ActorDef, input interface{}) {
+		if input == cmdSpawn {
+			self.Spawn(func(self *ActorDef, input interface{}) {
+				if input == cmdShutdown {
+					self.Close()
+					return
+				}
+
+				val, _ := Maybe.Just(input).ToInt()
+				resultChannel <- val * 10
+			})
+			return
+		}
+		if input == cmdShutdown {
+			for _, child := range self.children {
+				child.Send(cmdShutdown)
+			}
+			self.Close()
+
+			close(resultChannel)
+			return
+		}
+
+		intVal, _ := Maybe.Just(input).ToInt()
+		if intVal > 0 {
+			for _, child := range self.children {
+				child.Send(intVal)
+			}
+		}
+	})
+	actorRoot.Send(cmdSpawn)
+	actorRoot.Send(10)
+	actorRoot.Send(cmdSpawn)
+	actorRoot.Send(20)
+	actorRoot.Send(cmdSpawn)
+	actorRoot.Send(30)
+
+	actorRoot.Send(cmdShutdown)
+
+	for val := range resultChannel {
+		intVal, _ := Maybe.Just(val).ToInt()
+		actual += intVal
+	}
+
+	assert.Equal(t, expectedInt, actual)
+}