irc/modes.go

283 lines
6.8 KiB
Go
Raw Normal View History

package irc
import (
"fmt"
"sync"
)
// UserMode - RFC 1459 Section 4.2.3.2 and RFC 2812 Section 3.1.5
type UserMode rune
const (
UserModeAway UserMode = 'a'
UserModeInvisible UserMode = 'i'
UserModeWallOps UserMode = 'w'
UserModeRestricted UserMode = 'r'
UserModeOperator UserMode = 'o'
UserModeLocalOperator UserMode = 'O'
UserModeServerNotice UserMode = 's' //obsolete
)
// UserModes contains the supported User UserMode types
var UserModes = map[UserMode]interface{}{
UserModeAway: nil,
UserModeInvisible: nil,
UserModeWallOps: nil,
UserModeRestricted: nil,
UserModeOperator: nil,
UserModeLocalOperator: nil,
UserModeServerNotice: nil,
}
// UserModeSet provides means for storing and checking UserModes
type UserModeSet struct {
userModes map[UserMode]interface{}
mutex sync.RWMutex
}
// NewUserModeSet creates and returns a new UserModeSet
func NewUserModeSet() *UserModeSet {
u := UserModeSet{}
u.userModes = map[UserMode]interface{}{}
return &u
}
// AddMode adds a mode to the UserModeSet
func (u *UserModeSet) AddMode(mode UserMode) {
u.mutex.Lock()
defer u.mutex.Unlock()
u.userModes[mode] = nil
}
// RemoveMode removes a mode from the UserModeSet
func (u *UserModeSet) RemoveMode(mode UserMode) {
u.mutex.Lock()
defer u.mutex.Unlock()
delete(u.userModes, mode)
}
// HasMode detects if a UserMode is contained in the UserModeSet
func (u *UserModeSet) HasMode(mode UserMode) bool {
u.mutex.RLock()
defer u.mutex.RUnlock()
_, found := u.userModes[mode]
return found
}
// String formats the UserModeString to be returned for MODE queries
func (u *UserModeSet) String() string {
s := ""
if len(u.userModes) > 0 {
s = "+"
}
for m := range u.userModes {
s += string(m)
}
return s
}
// ModeModifier - RFC 1459 Section 4.2.3 and RFC 2812 Section 3.1.5
type ModeModifier rune
const (
ModeModifierAdd ModeModifier = '+'
ModeModifierRemove ModeModifier = '-'
)
// ChannelMode - RFC 1459 Section 4.2.3.1 and RFC 2812 Section 3.2.3 and RFC 2811 Section 4
type ChannelMode rune
const (
ChannelModeCreator ChannelMode = 'O'
ChannelModeOperator ChannelMode = 'o'
ChannelModeVoice ChannelMode = 'v'
ChannelModeAnonymous ChannelMode = 'a'
ChannelModeInviteOnly ChannelMode = 'i'
ChannelModeModerated ChannelMode = 'm'
ChannelModeNoOutsideMessages ChannelMode = 'n'
ChannelModeQuiet ChannelMode = 'q'
ChannelModePrivate ChannelMode = 'p'
ChannelModeSecret ChannelMode = 's'
ChannelModeReOp ChannelMode = 'r'
ChannelModeTopic ChannelMode = 't'
ChannelModeKey ChannelMode = 'k'
ChannelModeLimit ChannelMode = 'l'
ChannelModeBan ChannelMode = 'b'
ChannelModeExceptionMask ChannelMode = 'e'
ChannelModeInvitationMask ChannelMode = 'I'
)
// ChannelModeSet represents a set of active ChannelModes
type ChannelModeSet struct {
modes map[ChannelMode]interface{}
mutex sync.RWMutex
}
// NewChannelModeSet creates and returns a new ChannelModeSet
func NewChannelModeSet() *ChannelModeSet {
c := ChannelModeSet{}
c.modes = map[ChannelMode]interface{}{}
return &c
}
// Copy creates and returns a deep copy of a ChannelModeSet
func (c *ChannelModeSet) Copy() *ChannelModeSet {
tmp := NewChannelModeSet()
for k, v := range c.modes {
tmp.modes[k] = v
}
return tmp
}
// AddMode adds a ChannelMode as active
func (c *ChannelModeSet) AddMode(mode ChannelMode) {
c.mutex.Lock()
defer c.mutex.Unlock()
c.modes[mode] = nil
}
// AddModeWithValue adds a ChannelMode as active with a value
func (c *ChannelModeSet) AddModeWithValue(mode ChannelMode, value interface{}) {
c.mutex.Lock()
defer c.mutex.Unlock()
c.modes[mode] = value
}
// RemoveMode removes the given mode from the active set
func (c *ChannelModeSet) RemoveMode(mode ChannelMode) {
c.mutex.Lock()
defer c.mutex.Unlock()
delete(c.modes, mode)
}
// HasMode determines if the ChannelModeSet contains the given ChannelMode
func (c *ChannelModeSet) HasMode(mode ChannelMode) bool {
c.mutex.RLock()
defer c.mutex.RUnlock()
_, found := c.modes[mode]
return found
}
// GetMode determines if the ChannelModeSet contains the given ChannelMode
func (c *ChannelModeSet) GetMode(mode ChannelMode) interface{} {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.modes[mode]
}
// String returns the ChannelModeSet formatted for the MODE queries
func (c *ChannelModeSet) String() string {
s := "+"
params := []interface{}{}
for m, param := range c.modes {
switch m {
case ChannelModeKey, ChannelModeLimit, ChannelModeModerated, ChannelModeAnonymous, ChannelModeInviteOnly, ChannelModePrivate, ChannelModeSecret, ChannelModeTopic:
default:
continue
}
s += string(m)
params = append(params, param)
}
for _, param := range params {
if param != nil {
s += fmt.Sprintf(" %v", param)
}
}
return s
}
// AddBanMask sets the channel ban mask
func (c *ChannelModeSet) AddBanMask(mask string) {
masks := c.GetBanMasks()
masks[mask] = nil
c.AddModeWithValue(ChannelModeBan, masks)
}
// GetBanMasks gets the ban masks for the channel
func (c *ChannelModeSet) GetBanMasks() map[string]interface{} {
val := c.GetMode(ChannelModeBan)
if val == nil {
return make(map[string]interface{}, 0)
}
return val.(map[string]interface{})
}
// AddExceptionMask sets the channel exception mask
func (c *ChannelModeSet) AddExceptionMask(mask string) {
masks := c.GetExceptionMasks()
masks[mask] = nil
c.AddModeWithValue(ChannelModeExceptionMask, masks)
}
// GetExceptionMasks gets the exception masks for the channel
func (c *ChannelModeSet) GetExceptionMasks() map[string]interface{} {
val := c.GetMode(ChannelModeExceptionMask)
if val == nil {
return make(map[string]interface{}, 0)
}
return val.(map[string]interface{})
}
// AddInvitationMask sets the channel invitation mask
func (c *ChannelModeSet) AddInvitationMask(mask string) {
masks := c.GetInvitationMasks()
masks[mask] = nil
c.AddModeWithValue(ChannelModeInvitationMask, masks)
}
// GetInvitationMasks gets the invitation masks for the channel
func (c *ChannelModeSet) GetInvitationMasks() map[string]interface{} {
val := c.GetMode(ChannelModeInvitationMask)
if val == nil {
return make(map[string]interface{}, 0)
}
return val.(map[string]interface{})
}
// SetLimit sets the channel member limit
func (c *ChannelModeSet) SetLimit(limit int) {
c.AddModeWithValue(ChannelModeLimit, limit)
}
// GetLimit gets the member limit for the channel
func (c *ChannelModeSet) GetLimit() int {
val := c.GetMode(ChannelModeLimit)
if val == nil {
return 0
}
return val.(int)
}
// SetKey sets the channel key
func (c *ChannelModeSet) SetKey(key string) {
c.AddModeWithValue(ChannelModeKey, key)
}
// GetKey gets the key if stored in the ChannelModeSet
func (c *ChannelModeSet) GetKey() string {
val := c.GetMode(ChannelModeKey)
if val == nil {
return ""
}
return val.(string)
}