Replaced linked list with map

Much better performance, simpler code

Author: AndrewBurian

README.md

@@ -5,7 +5,7 @@ Swiss Army Knife for SSE in Golang
 So you want to publish events to client that connect to your server?
 ```go
 func main() {
-	stream := &eventsource.Stream{}
+	stream := eventsource.NewStream()
 
 	go func(s *eventsource.Stream) {
 		for {
@@ -35,8 +35,8 @@ stream.Broadcast(tornadoWarningEvent)
 You can also just create multiple `Stream` objects much to the same effect, then only use `Broadcast`. Streams are cheap and run no background routines, so this is a valid pattern.
 
 ```go
-weatherStream := &eventstream.Stream{}
-lotteryStream := &eventstream.Stream{}
+weatherStream := eventstream.NewStream()
+lotteryStream := eventstream.NewStream()
 
 weatherStream.Register(clientPlanningHikes)
 lotteryStream.Register(soonToBePoorClient)
@@ -49,7 +49,7 @@ lotteryStream.Broadcast(everyoneLosesEvent)
 
 Use `TopicHandler` to create another handler for that stream that will subscribe clients to topics as well as broadcasts.
 ```go
-stream := &eventsource.Stream{}
+stream := eventsource.NewStream()
 catsHandler := stream.TopicHandler([]string{"cat"})
 
 http.ListenAndServe(":8080", catsHandler)
@@ -62,7 +62,7 @@ Use the stream's `Register`, `Subscribe`, `Remove`, `Unsubscribe`, and `CloseTop
 Register a callback for the `Stream` to envoke everytime a new client connects with `Stream.ClientConnectHook`. It'll give you a handle to the resulting Client and the http request that created it, letting you do whatever you please.
 
 ```go
-stream := &eventsource.Stream{}
+stream := eventsource.NewStream()
 stream.ClientConnectHook(func(r *http.Requset, c *eventsource.Client){
   fmt.Println("Recieved connection from", r.Host)
   fmt.Println("Hate that guy")

stream.go

@@ -19,7 +19,7 @@ connections and disconnectinos.
 A quick example of a simple sever that broadcasts a "tick" event every second
 
 	func main() {
-		stream := &eventsource.Stream{}
+		stream := eventsource.NewStream()
 		go func(s *eventsource.Stream) {
 			for {
 				time.Sleep(time.Second)
@@ -33,7 +33,6 @@ A quick example of a simple sever that broadcasts a "tick" event every second
 package eventsource
 
 import (
-	"container/list"
 	"net/http"
 	"sync"
 )
@@ -43,52 +42,49 @@ import (
 // A stream also implements an http.Handler to easily register incoming
 // http requests as new clients.
 type Stream struct {
-	clients           list.List
+	clients           map[*Client]topicList
 	listLock          sync.RWMutex
 	shutdownWait      sync.WaitGroup
 	clientConnectHook func(*http.Request, *Client)
 }
 
-type registeredClient struct {
-	c      *Client
-	topics map[string]bool
+type topicList map[string]bool
+
+// NewStream creates a new stream object
+func NewStream() *Stream {
+	return &Stream{
+		clients: make(map[*Client]topicList),
+	}
 }
 
 // Register adds a client to the stream to receive all broadcast
 // messages. Has no effect if the client is already registered.
 func (s *Stream) Register(c *Client) {
 
 	// see if the client has been registered
-	if cli := s.getClient(c); cli != nil {
+	if _, found := s.clients[c]; found {
 		return
 	}
 
 	// append new client
-	s.addClient(c)
+	s.clients[c] = make(topicList)
 }
 
 // Remove will remove a client from this stream, but not shut the client down.
 func (s *Stream) Remove(c *Client) {
 	s.listLock.Lock()
 	defer s.listLock.Unlock()
 
-	for element := s.clients.Front(); element != nil; element = element.Next() {
-		if regCli := element.Value.(*registeredClient); regCli.c == c {
-			// client found
-			s.clients.Remove(element)
-			return
-		}
-	}
+	delete(s.clients, c)
 }
 
 // Broadcast sends the event to all clients registered on this stream.
 func (s *Stream) Broadcast(e *Event) {
 	s.listLock.RLock()
 	defer s.listLock.RUnlock()
 
-	for element := s.clients.Front(); element != nil; element = element.Next() {
-		cli := element.Value.(*registeredClient)
-		cli.c.Send(e)
+	for cli := range s.clients {
+		cli.Send(e)
 	}
 }
 
@@ -97,35 +93,35 @@ func (s *Stream) Broadcast(e *Event) {
 // client.
 func (s *Stream) Subscribe(topic string, c *Client) {
 	// see if the client is registered
-	cli := s.getClient(c)
+	topics, found := s.clients[c]
 
 	// register if not
-	if cli == nil {
-		cli = s.addClient(c)
+	if !found {
+		topics = make(topicList)
+		s.clients[c] = topics
 	}
 
-	cli.topics[topic] = true
+	topics[topic] = true
 }
 
 // Unsubscribe removes clients from the topic, but not from broadcasts.
 func (s *Stream) Unsubscribe(topic string, c *Client) {
 
-	cli := s.getClient(c)
-	if cli == nil {
+	topics, found := s.clients[c]
+	if !found {
 		return
 	}
-	cli.topics[topic] = false
+	topics[topic] = false
 }
 
 // Publish sends the event to clients that have subscribed to the given topic.
 func (s *Stream) Publish(topic string, e *Event) {
 	s.listLock.RLock()
 	defer s.listLock.RUnlock()
 
-	for element := s.clients.Front(); element != nil; element = element.Next() {
-		cli := element.Value.(*registeredClient)
-		if cli.topics[topic] {
-			cli.c.Send(e)
+	for cli, topics := range s.clients {
+		if topics[topic] {
+			cli.Send(e)
 		}
 	}
 }
@@ -135,12 +131,9 @@ func (s *Stream) Shutdown() {
 	s.listLock.Lock()
 	defer s.listLock.Unlock()
 
-	for element := s.clients.Front(); element != nil; {
-		cli := element.Value.(*registeredClient)
-		cli.c.Shutdown()
-		next := element.Next()
-		s.clients.Remove(element)
-		element = next
+	for client := range s.clients {
+		client.Shutdown()
+		delete(s.clients, client)
 	}
 }
 
@@ -223,32 +216,3 @@ func (s *Stream) ClientConnectHook(fn func(*http.Request, *Client)) {
 func checkRequest(r *http.Request) bool {
 	return r.Header.Get("Accept") == "text/event-stream"
 }
-
-func (s *Stream) getClient(c *Client) *registeredClient {
-	s.listLock.RLock()
-	defer s.listLock.RUnlock()
-
-	for element := s.clients.Front(); element != nil; element = element.Next() {
-		if regCli := element.Value.(*registeredClient); regCli.c == c {
-			// client found
-			return regCli
-		}
-	}
-
-	// not found
-	return nil
-}
-
-func (s *Stream) addClient(c *Client) *registeredClient {
-
-	cli := &registeredClient{
-		c:      c,
-		topics: make(map[string]bool),
-	}
-
-	s.listLock.Lock()
-	s.clients.PushBack(cli)
-	s.listLock.Unlock()
-
-	return cli
-}