Merge pull request #15 from MattSScott/server-agent-hashmap

agent array in server changed to hashmap [SERVER]

pkg/main/BaseServer/baseServer.go

@@ -4,17 +4,26 @@ import (
 	"fmt"
 
 	baseagent "github.com/MattSScott/basePlatformSOMAS/pkg/main/BaseAgent"
+	"github.com/google/uuid"
 )
 
 type BaseServer[T baseagent.IAgent[T]] struct {
 	numTurns int
-	agents   []T
+	agents   map[uuid.UUID]T
 }
 
-func (bs *BaseServer[T]) GetAgents() []T {
+func (bs *BaseServer[T]) GetAgents() map[uuid.UUID]T {
 	return bs.agents
 }
 
+func (bs *BaseServer[T]) AddAgent(agentToAdd T) {
+	bs.agents[agentToAdd.GetID()] = agentToAdd
+}
+
+func (bs *BaseServer[T]) RemoveAgent(agentToAdd T) {
+	delete(bs.agents, agentToAdd.GetID())
+}
+
 func (bs *BaseServer[T]) GetNumTurns() int {
 	return bs.numTurns
 }
@@ -57,9 +66,24 @@ func MakeAgentGeneratorCountPair[T baseagent.IAgent[T]](generatorFunction AgentG
 	}
 }
 
+func (bs *BaseServer[T]) GenerateAgentArrayFromMap() []T {
+
+	agentMapToArray := make([]T, len(bs.agents))
+
+	i := 0
+	for _, ag := range bs.agents {
+		agentMapToArray[i] = ag
+		i++
+	}
+	return agentMapToArray
+}
+
 func (bs *BaseServer[T]) RunMessagingSession() {
+
+	agentArray := bs.GenerateAgentArrayFromMap()
+
 	for _, agent := range bs.agents {
-		allMessages := agent.GetAllMessages(bs.agents)
+		allMessages := agent.GetAllMessages(agentArray)
 		for _, msg := range allMessages {
 			recipients := msg.GetRecipients()
 			for _, recip := range recipients {
@@ -74,33 +98,19 @@ func (bs *BaseServer[T]) RunMessagingSession() {
 
 func (bs *BaseServer[T]) initialiseAgents(m []AgentGeneratorCountPair[T]) {
 
-	agents := make([]T, getNumAgents(m))
-	agentCount := 0
-
 	for _, pair := range m {
 		for i := 0; i < pair.count; i++ {
-			agents[agentCount] = pair.generator()
-			agentCount++
+			agent := pair.generator()
+			bs.AddAgent(agent)
 		}
 	}
 
-	bs.agents = agents
-}
-
-func getNumAgents[T baseagent.IAgent[T]](pairs []AgentGeneratorCountPair[T]) int {
-
-	numAgents := 0
-
-	for _, pair := range pairs {
-		numAgents += pair.count
-	}
-
-	return numAgents
 }
 
 // generate a server instance based on a mapping function and number of iterations
 func CreateServer[T baseagent.IAgent[T]](mapper []AgentGeneratorCountPair[T], iterations int) *BaseServer[T] {
 	serv := &BaseServer[T]{
+		agents:   make(map[uuid.UUID]T),
 		numTurns: iterations,
 	}
 	serv.initialiseAgents(mapper)

pkg/main/BaseServer/baseServer_test.go

@@ -5,6 +5,7 @@ import (
 
 	baseagent "github.com/MattSScott/basePlatformSOMAS/pkg/main/BaseAgent"
 	baseserver "github.com/MattSScott/basePlatformSOMAS/pkg/main/BaseServer"
+	"github.com/MattSScott/basePlatformSOMAS/pkg/main/messaging"
 )
 
 type ITestBaseAgent interface {
@@ -72,6 +73,46 @@ func CreateTestServer(mapper []baseserver.AgentGeneratorCountPair[ITestBaseAgent
 	}
 }
 
+func TestAddAgent(t *testing.T) {
+
+	baseServer := baseserver.CreateServer[ITestBaseAgent]([]baseserver.AgentGeneratorCountPair[ITestBaseAgent]{}, 1)
+
+	agent1 := baseagent.NewAgent[ITestBaseAgent]()
+
+	baseServer.AddAgent(agent1)
+
+	if len(baseServer.GetAgents()) != 1 {
+		t.Error("Agent not correctly added to map")
+	}
+}
+
+func TestRemoveAgent(t *testing.T) {
+
+	baseServer := baseserver.CreateServer[ITestBaseAgent]([]baseserver.AgentGeneratorCountPair[ITestBaseAgent]{}, 1)
+
+	agent1 := baseagent.NewAgent[ITestBaseAgent]()
+
+	baseServer.AddAgent(agent1)
+	baseServer.RemoveAgent(agent1)
+
+	if len(baseServer.GetAgents()) != 0 {
+		t.Error("Agent not correctly removed from map")
+	}
+}
+
+func TestFullAgentHashmap(t *testing.T) {
+	baseServer := baseserver.CreateServer[ITestBaseAgent]([]baseserver.AgentGeneratorCountPair[ITestBaseAgent]{}, 1)
+	for i := 0; i < 5; i++ {
+		baseServer.AddAgent(baseagent.NewAgent[ITestBaseAgent]())
+	}
+
+	for id, agent := range baseServer.GetAgents() {
+		if agent.GetID() != id {
+			t.Error("Server agent hashmap key doesn't match object")
+		}
+	}
+}
+
 func TestServerGameLoop(t *testing.T) {
 	m := make([]baseserver.AgentGeneratorCountPair[ITestBaseAgent], 1)
 	m[0] = baseserver.MakeAgentGeneratorCountPair[ITestBaseAgent](NewTestBaseAgent, 3)
@@ -89,3 +130,52 @@ func TestServerGameLoop(t *testing.T) {
 	}
 
 }
+
+func TestServerStartsCorrectly(t *testing.T) {
+	generator := baseserver.MakeAgentGeneratorCountPair[ITestBaseAgent](NewTestBaseAgent, 3)
+
+	baseServer := baseserver.CreateServer([]baseserver.AgentGeneratorCountPair[ITestBaseAgent]{generator}, 1)
+
+	baseServer.Start()
+}
+
+func TestAgentMapConvertsToArray(t *testing.T) {
+	generator := baseserver.MakeAgentGeneratorCountPair[ITestBaseAgent](NewTestBaseAgent, 3)
+
+	baseServer := baseserver.CreateServer([]baseserver.AgentGeneratorCountPair[ITestBaseAgent]{generator}, 1)
+
+	if len(baseServer.GenerateAgentArrayFromMap()) != 3 {
+		t.Error("Agents not correctly mapped to array")
+	}
+}
+
+func (tba *TestBaseAgent) GetAllMessages(others []ITestBaseAgent) []messaging.IMessage[ITestBaseAgent] {
+	msg := messaging.CreateMessage[ITestBaseAgent](tba, others)
+
+	return []messaging.IMessage[ITestBaseAgent]{msg}
+}
+
+func TestMessagingSession(t *testing.T) {
+	generator := baseserver.MakeAgentGeneratorCountPair[ITestBaseAgent](NewTestBaseAgent, 3)
+
+	baseServer := baseserver.CreateServer([]baseserver.AgentGeneratorCountPair[ITestBaseAgent]{generator}, 1)
+
+	agentArray := baseServer.GenerateAgentArrayFromMap()
+
+	agent1 := agentArray[0]
+
+	messages := agent1.GetAllMessages(agentArray)
+
+	for _, msg := range messages {
+		if len(msg.GetRecipients()) != 3 {
+			t.Error("Incorrect number of message recipients")
+		}
+		for _, recip := range msg.GetRecipients() {
+			if recip.GetID() == agent1.GetID() {
+				continue
+			}
+			msg.InvokeMessageHandler(recip)
+		}
+	}
+
+}

pkg/main/BaseServer/serverInterface.go

@@ -1,14 +1,28 @@
 package baseserver
 
-import baseagent "github.com/MattSScott/basePlatformSOMAS/pkg/main/BaseAgent"
+import (
+	baseagent "github.com/MattSScott/basePlatformSOMAS/pkg/main/BaseAgent"
+	"github.com/google/uuid"
+)
+
+type IAgentOperations[T baseagent.IAgent[T]] interface {
+	// gives access to the agents in the simulator
+	GetAgents() map[uuid.UUID]T
+	// adds an agent to the server
+	AddAgent(agentToAdd T)
+	// removes an agent from the server
+	RemoveAgent(agentToRemove T)
+	// translate the agent map into an array of agents
+	GenerateAgentArrayFromMap() []T
+}
 
 type IServer[T baseagent.IAgent[T]] interface {
 	// the set of functions defining how a 'game loop' should run
 	RunGameLoop()
 	// begins simulator
 	Start()
-	// gives access to the agents in the simulator
-	GetAgents() []T
+	// gives operations for adding/removing agents from the simulator
+	IAgentOperations[T]
 	// gives access to number of iteration in simulator
 	GetNumTurns() int
 }

pkg/testing/testServer/server_test.go

@@ -65,7 +65,7 @@ func TestServerMessagePassing(t *testing.T) {
 	floors := 3
 	ts := testserver.New(m, floors)
 
-	agents := ts.GetAgents()
+	agents := ts.GenerateAgentArrayFromMap()
 
 	a1 := agents[0]
 	a2 := agents[1]