pothtonswer/discordmuffin
1
0
Fork 1
Code Issues 2 Pull requests 1 Projects 2 Releases Packages Wiki Activity Actions

Finish converting large switch statement into a map of functions.

Browse source
This commit is contained in:
Chris Rhodes 2016-02-14 18:48:37 -08:00
parent 8ffaa85b0b
commit 6fa99712ef
6 changed files with 220 additions and 353 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
discord.go
View file

@ -144,6 +144,11 @@ func (s *Session) AddHandler(handler interface{}) {
eventType := handlerType.In(1) eventType := handlerType.In(1)
// Support handlers of type interface{}, this is a special handler, which is triggered on every event.
if eventType.Kind() == reflect.Interface {
eventType = nil
}
handlers := s.Handlers[eventType] handlers := s.Handlers[eventType]
if handlers == nil { if handlers == nil {
handlers = []interface{}{} handlers = []interface{}{}
@ -153,39 +158,39 @@ func (s *Session) AddHandler(handler interface{}) {
s.Handlers[eventType] = handlers s.Handlers[eventType] = handlers
} }
func (s *Session) Handle(event interface{}) (handled bool) { func (s *Session) handle(event interface{}) {
s.RLock() s.RLock()
defer s.RUnlock() defer s.RUnlock()
eventType := reflect.TypeOf(event) if handlers, ok := s.Handlers[reflect.TypeOf(event)]; ok {
handlers, ok := s.Handlers[eventType]
if !ok {
return
}
for _, handler := range handlers { for _, handler := range handlers {
reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(s), reflect.ValueOf(event)}) reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(s), reflect.ValueOf(event)})
handled = true }
} }
return if handlers, ok := s.Handlers[nil]; ok {
for _, handler := range handlers {
reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(s), reflect.ValueOf(event)})
}
}
} }
// initialize adds all internal handlers and state tracking handlers. // initialize adds all internal handlers and state tracking handlers.
func (s *Session) initialize() { func (s *Session) initialize() {
s.Lock() s.Lock()
defer s.Unlock()
s.Handlers = map[interface{}][]interface{}{} s.Handlers = map[interface{}][]interface{}{}
s.Unlock()
s.AddHandler(s.onEvent)
s.AddHandler(s.onReady) s.AddHandler(s.onReady)
s.AddHandler(s.onVoiceServerUpdate) s.AddHandler(s.onVoiceServerUpdate)
s.AddHandler(s.onVoiceStateUpdate) s.AddHandler(s.onVoiceStateUpdate)
s.AddHandler(s.State.onInterface)
}
s.AddHandler(s.State.onReady) // onEvent handles events that are unhandled or errored while unmarshalling
s.AddHandler(s.State.onMessageCreate) func (s *Session) onEvent(se *Session, e *Event) {
s.AddHandler(s.State.onMessageUpdate) printEvent(e)
s.AddHandler(s.State.onMessageDelete)
} }
// onReady handles the ready event. // onReady handles the ready event.

100
events.go Normal file
View file

@ -0,0 +1,100 @@
package discordgo
// Connect is an empty struct for an event.
type Connect struct{}
// Disconnect is an empty struct for an event.
type Disconnect struct{}
// MessageCreate is a wrapper struct for an event.
type MessageCreate struct {
*Message
}
// MessageUpdate is a wrapper struct for an event.
type MessageUpdate struct {
*Message
}
// MessageDelete is a wrapper struct for an event.
type MessageDelete struct {
*Message
}
// ChannelCreate is a wrapper struct for an event.
type ChannelCreate struct {
*Channel
}
// ChannelUpdate is a wrapper struct for an event.
type ChannelUpdate struct {
*Channel
}
// ChannelDelete is a wrapper struct for an event.
type ChannelDelete struct {
*Channel
}
// GuildCreate is a wrapper struct for an event.
type GuildCreate struct {
*Guild
}
// GuildUpdate is a wrapper struct for an event.
type GuildUpdate struct {
*Guild
}
// GuildDelete is a wrapper struct for an event.
type GuildDelete struct {
*Guild
}
// GuildBanAdd is a wrapper struct for an event.
type GuildBanAdd struct {
*GuildBan
}
// GuildBanRemove is a wrapper struct for an event.
type GuildBanRemove struct {
*GuildBan
}
// GuildMemberAdd is a wrapper struct for an event.
type GuildMemberAdd struct {
*Member
}
// GuildMemberUpdate is a wrapper struct for an event.
type GuildMemberUpdate struct {
*Member
}
// GuildMemberRemove is a wrapper struct for an event.
type GuildMemberRemove struct {
*Member
}
// GuildRoleCreate is a wrapper struct for an event.
type GuildRoleCreate struct {
*GuildRole
}
// GuildRoleUpdate is a wrapper struct for an event.
type GuildRoleUpdate struct {
*GuildRole
}
// VoiceStateUpdate is a wrapper struct for an event.
type VoiceStateUpdate struct {
*VoiceState
}
// UserUpdate is a wrapper struct for an event.
type UserUpdate struct {
*UserUpdate
}
// UserSettingsUpdate is a map for an event.
type UserSettingsUpdate map[string]interface{}

11
examples/api_basic/api_basic.go
View file

@ -23,9 +23,10 @@ func main() {
// Create a new Discord Session interface and set a handler for the // Create a new Discord Session interface and set a handler for the
// OnMessageCreate event that happens for every new message on any channel // OnMessageCreate event that happens for every new message on any channel
dg := discordgo.Session{ dg := discordgo.Session{}
OnMessageCreate: messageCreate,
} // Register messageCreate as a callback for the messageCreate events.
dg.AddHandler(messageCreate)
// Login to the Discord server and store the authentication token // Login to the Discord server and store the authentication token
err = dg.Login(os.Args[1], os.Args[2]) err = dg.Login(os.Args[1], os.Args[2])
@ -46,9 +47,9 @@ func main() {
return return
} }
// This function will be called (due to above assignment) every time a new // This function will be called (due to AddHandler above) every time a new
// message is created on any channel that the autenticated user has access to. // message is created on any channel that the autenticated user has access to.
func messageCreate(s *discordgo.Session, m *discordgo.Message) { func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
// Print message to stdout. // Print message to stdout.
fmt.Printf("%20s %20s %20s > %s\n", m.ChannelID, time.Now().Format(time.Stamp), m.Author.Username, m.Content) fmt.Printf("%20s %20s %20s > %s\n", m.ChannelID, time.Now().Format(time.Stamp), m.Author.Username, m.Content)

8
examples/new_basic/new_basic.go
View file

@ -28,8 +28,8 @@ func main() {
return return
} }
// Register messageCreate as a callback for the OnMessageCreate event. // Register messageCreate as a callback for the messageCreate events.
dg.OnMessageCreate = messageCreate dg.AddHandler(messageCreate)
// Open the websocket and begin listening. // Open the websocket and begin listening.
dg.Open() dg.Open()
@ -40,9 +40,9 @@ func main() {
return return
} }
// This function will be called (due to above assignment) every time a new // This function will be called (due to AddHandler above) every time a new
// message is created on any channel that the autenticated user has access to. // message is created on any channel that the autenticated user has access to.
func messageCreate(s *discordgo.Session, m *discordgo.Message) { func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
// Print message to stdout. // Print message to stdout.
fmt.Printf("%20s %20s %20s > %s\n", m.ChannelID, time.Now().Format(time.Stamp), m.Author.Username, m.Content) fmt.Printf("%20s %20s %20s > %s\n", m.ChannelID, time.Now().Format(time.Stamp), m.Author.Username, m.Content)

63
state.go
View file

@ -35,6 +35,7 @@ func (s *State) OnReady(r *Ready) error {
if s == nil { if s == nil {
return ErrNilState return ErrNilState
} }
s.Lock() s.Lock()
defer s.Unlock() defer s.Unlock()
@ -48,6 +49,7 @@ func (s *State) GuildAdd(guild *Guild) error {
if s == nil { if s == nil {
return ErrNilState return ErrNilState
} }
s.Lock() s.Lock()
defer s.Unlock() defer s.Unlock()
@ -73,6 +75,7 @@ func (s *State) GuildRemove(guild *Guild) error {
if s == nil { if s == nil {
return ErrNilState return ErrNilState
} }
s.Lock() s.Lock()
defer s.Unlock() defer s.Unlock()
@ -94,6 +97,7 @@ func (s *State) Guild(guildID string) (*Guild, error) {
if s == nil { if s == nil {
return nil, ErrNilState return nil, ErrNilState
} }
s.RLock() s.RLock()
defer s.RUnlock() defer s.RUnlock()
@ -294,6 +298,7 @@ func (s *State) PrivateChannel(channelID string) (*Channel, error) {
if s == nil { if s == nil {
return nil, ErrNilState return nil, ErrNilState
} }
s.RLock() s.RLock()
defer s.RUnlock() defer s.RUnlock()
@ -429,6 +434,7 @@ func (s *State) MessageRemove(message *Message) error {
if s == nil { if s == nil {
return ErrNilState return ErrNilState
} }
c, err := s.Channel(message.ChannelID) c, err := s.Channel(message.ChannelID)
if err != nil { if err != nil {
return err return err
@ -452,6 +458,7 @@ func (s *State) Message(channelID, messageID string) (*Message, error) {
if s == nil { if s == nil {
return nil, ErrNilState return nil, ErrNilState
} }
c, err := s.Channel(channelID) c, err := s.Channel(channelID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -469,30 +476,40 @@ func (s *State) Message(channelID, messageID string) (*Message, error) {
return nil, errors.New("Message not found.") return nil, errors.New("Message not found.")
} }
// onReady handles the ready event. // onInterface handles all events related to states.
func (s *State) onReady(se *Session, r *Ready) { func (s *State) onInterface(se *Session, i interface{}) {
if se.StateEnabled { if s == nil || !se.StateEnabled {
s.OnReady(r) return
}
} }
// onMessageCreate handles the messageCreate event. switch t := i.(type) {
func (s *State) onMessageCreate(se *Session, m *MessageCreate) { case *Ready:
if se.StateEnabled { s.OnReady(t)
s.MessageAdd(m.Message) case *GuildCreate:
} s.GuildAdd(t.Guild)
} case *GuildUpdate:
s.GuildAdd(t.Guild)
// onMessageUpdate handles the messageUpdate event. case *GuildDelete:
func (s *State) onMessageUpdate(se *Session, m *MessageUpdate) { s.GuildRemove(t.Guild)
if se.StateEnabled { case *GuildMemberAdd:
s.MessageAdd(m.Message) s.MemberAdd(t.Member)
} case *GuildMemberUpdate:
} s.MemberAdd(t.Member)
case *GuildMemberRemove:
// onMessageDelete handles the messageDelete event. s.MemberRemove(t.Member)
func (s *State) onMessageDelete(se *Session, m *MessageDelete) { case *GuildEmojisUpdate:
if se.StateEnabled { s.EmojisAdd(t.GuildID, t.Emojis)
s.MessageRemove(m.Message) case *ChannelCreate:
s.ChannelAdd(t.Channel)
case *ChannelUpdate:
s.ChannelAdd(t.Channel)
case *ChannelDelete:
s.ChannelRemove(t.Channel)
case *MessageCreate:
s.MessageAdd(t.Message)
case *MessageUpdate:
s.MessageAdd(t.Message)
case *MessageDelete:
s.MessageRemove(t.Message)
} }
} }

346
wsapi.go
View file

@ -18,6 +18,7 @@ import (
"fmt" "fmt"
"io" "io"
"net/http" "net/http"
"reflect"
"runtime" "runtime"
"time" "time"
@ -86,7 +87,7 @@ func (s *Session) Open() (err error) {
s.Unlock() s.Unlock()
s.Handle(&Connect{}) s.handle(&Connect{})
return return
} }
@ -110,7 +111,7 @@ func (s *Session) Close() (err error) {
s.Unlock() s.Unlock()
s.Handle(&Disconnect{}) s.handle(&Disconnect{})
return return
} }
@ -243,6 +244,38 @@ func (s *Session) UpdateStatus(idle int, game string) (err error) {
return return
} }
// eventToInterface is a mapping of Discord WSAPI events to their
// DiscordGo event container.
var eventToInterface = map[string]interface{}{
"CHANNEL_CREATE": ChannelCreate{},
"CHANNEL_UPDATE": ChannelUpdate{},
"CHANNEL_DELETE": ChannelDelete{},
"GUILD_CREATE": GuildCreate{},
"GUILD_UPDATE": GuildUpdate{},
"GUILD_DELETE": GuildDelete{},
"GUILD_BAN_ADD": GuildBanAdd{},
"GUILD_BAN_REMOVE": GuildBanRemove{},
"GUILD_MEMBER_ADD": GuildMemberAdd{},
"GUILD_MEMBER_UPDATE": GuildMemberUpdate{},
"GUILD_MEMBER_REMOVE": GuildMemberRemove{},
"GUILD_ROLE_CREATE": GuildRoleCreate{},
"GUILD_ROLE_UPDATE": GuildRoleUpdate{},
"GUILD_ROLE_DELETE": GuildRoleDelete{},
"GUILD_INTEGRATIONS_UPDATE": GuildIntegrationsUpdate{},
"GUILD_EMOJIS_UPDATE": GuildEmojisUpdate{},
"MESSAGE_ACK": MessageAck{},
"MESSAGE_CREATE": MessageCreate{},
"MESSAGE_UPDATE": MessageUpdate{},
"MESSAGE_DELETE": MessageDelete{},
"PRESENCE_UPDATE": PresenceUpdate{},
"READY": Ready{},
"USER_UPDATE": UserUpdate{},
"USER_SETTINGS_UPDATE": UserSettingsUpdate{},
"TYPING_START": TypingStart{},
"VOICE_SERVER_UPDATE": VoiceServerUpdate{},
"VOICE_STATE_UPDATE": VoiceStateUpdate{},
}
// Front line handler for all Websocket Events. Determines the // Front line handler for all Websocket Events. Determines the
// event type and passes the message along to the next handler. // event type and passes the message along to the next handler.
@ -289,312 +322,23 @@ func (s *Session) event(messageType int, message []byte) {
printEvent(e) printEvent(e)
} }
var i interface{} i := eventToInterface[e.Type]
if i != nil {
// TODO(iopred): Figure out a clean way to do this with a map, simply // Create a new instance of the event type.
// creating a map[string]interface{} will not work, as that will reuse i = reflect.New(reflect.TypeOf(i)).Interface()
// the same instance for each event.
switch e.Type {
case "READY":
i = &Ready{}
case "MESSAGE_CREATE":
i = &MessageCreate{}
case "MESSAGE_UPDATE":
i = &MessageUpdate{}
case "MESSAGE_DELETE":
i = &MessageDelete{}
case "PRESENCE_UPDATE":
i = &PresenceUpdate{}
case "TYPING_START":
i = &TypingStart{}
case "VOICE_SERVER_UPDATE":
i = &VoiceServerUpdate{}
case "VOICE_STATE_UPDATE":
i = &VoiceStateUpdate{}
case "USER_UPDATE":
i = &UserUpdate{}
case "MESSAGE_ACK":
i = &MessageAck{}
case "GUILD_ROLE_CREATE":
i = &GuildRoleCreate{}
case "GUILD_ROLE_UPDATE":
i = &GuildRoleUpdate{}
case "GUILD_ROLE_DELETE":
i = &GuildRoleDelete{}
case "GUILD_INTEGRATIONS_UPDATE":
i = &GuildIntegrationsUpdate{}
case "GUILD_BAN_ADD":
i = &GuildBanAdd{}
case "GUILD_BAN_REMOVE":
i = &GuildBanRemove{}
}
// case "CHANNEL_CREATE":
// if !s.StateEnabled && s.OnChannelCreate == nil {
// break
// }
// var st *Channel
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.ChannelAdd(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnChannelCreate != nil {
// s.OnChannelCreate(s, st)
// }
// }
// if s.OnChannelCreate != nil {
// return
// }
// case "CHANNEL_UPDATE":
// if !s.StateEnabled && s.OnChannelUpdate == nil {
// break
// }
// var st *Channel
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.ChannelAdd(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnChannelUpdate != nil {
// s.OnChannelUpdate(s, st)
// }
// }
// if s.OnChannelUpdate != nil {
// return
// }
// case "CHANNEL_DELETE":
// if !s.StateEnabled && s.OnChannelDelete == nil {
// break
// }
// var st *Channel
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.ChannelRemove(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnChannelDelete != nil {
// s.OnChannelDelete(s, st)
// }
// }
// if s.OnChannelDelete != nil {
// return
// }
// case "GUILD_CREATE":
// if !s.StateEnabled && s.OnGuildCreate == nil {
// break
// }
// var st *Guild
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.GuildAdd(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnGuildCreate != nil {
// s.OnGuildCreate(s, st)
// }
// }
// if s.OnGuildCreate != nil {
// return
// }
// case "GUILD_UPDATE":
// if !s.StateEnabled && s.OnGuildUpdate == nil {
// break
// }
// var st *Guild
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.GuildAdd(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnGuildCreate != nil {
// s.OnGuildUpdate(s, st)
// }
// }
// if s.OnGuildUpdate != nil {
// return
// }
// case "GUILD_DELETE":
// if !s.StateEnabled && s.OnGuildDelete == nil {
// break
// }
// var st *Guild
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.GuildRemove(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnGuildDelete != nil {
// s.OnGuildDelete(s, st)
// }
// }
// if s.OnGuildDelete != nil {
// return
// }
// case "GUILD_MEMBER_ADD":
// if !s.StateEnabled && s.OnGuildMemberAdd == nil {
// break
// }
// var st *Member
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.MemberAdd(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnGuildMemberAdd != nil {
// s.OnGuildMemberAdd(s, st)
// }
// }
// if s.OnGuildMemberAdd != nil {
// return
// }
// case "GUILD_MEMBER_REMOVE":
// if !s.StateEnabled && s.OnGuildMemberRemove == nil {
// break
// }
// var st *Member
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.MemberRemove(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnGuildMemberRemove != nil {
// s.OnGuildMemberRemove(s, st)
// }
// }
// if s.OnGuildMemberRemove != nil {
// return
// }
// case "GUILD_MEMBER_UPDATE":
// if !s.StateEnabled && s.OnGuildMemberUpdate == nil {
// break
// }
// var st *Member
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.MemberAdd(st)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnGuildMemberUpdate != nil {
// s.OnGuildMemberUpdate(s, st)
// }
// }
// if s.OnGuildMemberUpdate != nil {
// return
// }
// case "GUILD_ROLE_CREATE":
// if s.OnGuildRoleCreate != nil {
// var st *GuildRole
// if err = unmarshalEvent(e, &st); err == nil {
// s.OnGuildRoleCreate(s, st)
// }
// return
// }
// case "GUILD_ROLE_UPDATE":
// if s.OnGuildRoleUpdate != nil {
// var st *GuildRole
// if err = unmarshalEvent(e, &st); err == nil {
// s.OnGuildRoleUpdate(s, st)
// }
// return
// }
// case "GUILD_ROLE_DELETE":
// if s.OnGuildRoleDelete != nil {
// var st *GuildRoleDelete
// if err = unmarshalEvent(e, &st); err == nil {
// s.OnGuildRoleDelete(s, st)
// }
// return
// }
// case "GUILD_INTEGRATIONS_UPDATE":
// if s.OnGuildIntegrationsUpdate != nil {
// var st *GuildIntegrationsUpdate
// if err = unmarshalEvent(e, &st); err == nil {
// s.OnGuildIntegrationsUpdate(s, st)
// }
// return
// }
// case "GUILD_BAN_ADD":
// if s.OnGuildBanAdd != nil {
// var st *GuildBan
// if err = unmarshalEvent(e, &st); err == nil {
// s.OnGuildBanAdd(s, st)
// }
// return
// }
// case "GUILD_BAN_REMOVE":
// if s.OnGuildBanRemove != nil {
// var st *GuildBan
// if err = unmarshalEvent(e, &st); err == nil {
// s.OnGuildBanRemove(s, st)
// }
// return
// }
// case "GUILD_EMOJIS_UPDATE":
// if !s.StateEnabled && s.OnGuildEmojisUpdate == nil {
// break
// }
// var st *GuildEmojisUpdate
// if err = unmarshalEvent(e, &st); err == nil {
// if s.StateEnabled {
// err := s.State.EmojisAdd(st.GuildID, st.Emojis)
// if err != nil {
// fmt.Println("error :", err)
// }
// }
// if s.OnGuildEmojisUpdate != nil {
// s.OnGuildEmojisUpdate(s, st)
// }
// }
// if s.OnGuildEmojisUpdate != nil {
// return
// }
// case "USER_SETTINGS_UPDATE":
// if s.OnUserSettingsUpdate != nil {
// var st map[string]interface{}
// if err = unmarshalEvent(e, &st); err == nil {
// s.OnUserSettingsUpdate(s, st)
// }
// return
// }
// default:
// fmt.Println("Unknown Event.")
// printEvent(e)
// }
// Attempt to unmarshal our event. // Attempt to unmarshal our event.
// If there is an error (eg. we don't know how to handle it) we should handle the event itself. // If there is an error we should handle the event itself.
if err = unmarshal(e.RawData, i); err != nil { if err = unmarshal(e.RawData, i); err != nil {
fmt.Println("Unable to unmarshal event data.") fmt.Println("Unable to unmarshal event data.")
printEvent(e) i = e
}
} else {
fmt.Println("Unknown event.")
i = e i = e
} }
if !s.Handle(i) { s.handle(i)
if i != e {
// If there was not a handler for the struct, handle the event, as long as it wasn't the
// event we were trying to handle.
s.Handle(e)
}
}
return return
} }