mirror of https://github.com/ergochat/ergo.git
125 lines
2.9 KiB
Go
125 lines
2.9 KiB
Go
// Copyright (c) 2017 Daniel Oaks <daniel@danieloaks.net>
|
|
// released under the MIT license
|
|
|
|
package caps
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/ergochat/ergo/irc/utils"
|
|
)
|
|
|
|
// Set holds a set of enabled capabilities.
|
|
type Set [bitsetLen]uint32
|
|
|
|
// Values holds capability values.
|
|
type Values map[Capability]string
|
|
|
|
// NewSet returns a new Set, with the given capabilities enabled.
|
|
func NewSet(capabs ...Capability) *Set {
|
|
var newSet Set
|
|
newSet.Enable(capabs...)
|
|
return &newSet
|
|
}
|
|
|
|
// NewCompleteSet returns a new Set, with all defined capabilities enabled.
|
|
func NewCompleteSet() *Set {
|
|
var newSet Set
|
|
asSlice := newSet[:]
|
|
for i := 0; i < numCapabs; i += 1 {
|
|
utils.BitsetSet(asSlice, uint(i), true)
|
|
}
|
|
return &newSet
|
|
}
|
|
|
|
// Enable enables the given capabilities.
|
|
func (s *Set) Enable(capabs ...Capability) {
|
|
asSlice := s[:]
|
|
for _, capab := range capabs {
|
|
utils.BitsetSet(asSlice, uint(capab), true)
|
|
}
|
|
}
|
|
|
|
// Disable disables the given capabilities.
|
|
func (s *Set) Disable(capabs ...Capability) {
|
|
asSlice := s[:]
|
|
for _, capab := range capabs {
|
|
utils.BitsetSet(asSlice, uint(capab), false)
|
|
}
|
|
}
|
|
|
|
// Add adds the given capabilities to this set.
|
|
// this is just a wrapper to allow more clear use.
|
|
func (s *Set) Add(capabs ...Capability) {
|
|
s.Enable(capabs...)
|
|
}
|
|
|
|
// Remove removes the given capabilities from this set.
|
|
// this is just a wrapper to allow more clear use.
|
|
func (s *Set) Remove(capabs ...Capability) {
|
|
s.Disable(capabs...)
|
|
}
|
|
|
|
// Has returns true if this set has the given capability.
|
|
func (s *Set) Has(capab Capability) bool {
|
|
return utils.BitsetGet(s[:], uint(capab))
|
|
}
|
|
|
|
// HasAll returns true if the set has all the given capabilities.
|
|
func (s *Set) HasAll(capabs ...Capability) bool {
|
|
for _, capab := range capabs {
|
|
if !s.Has(capab) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Union adds all the capabilities of another set to this set.
|
|
func (s *Set) Union(other *Set) {
|
|
utils.BitsetUnion(s[:], other[:])
|
|
}
|
|
|
|
// Subtract removes all the capabilities of another set from this set.
|
|
func (s *Set) Subtract(other *Set) {
|
|
utils.BitsetSubtract(s[:], other[:])
|
|
}
|
|
|
|
// Empty returns whether the set is empty.
|
|
func (s *Set) Empty() bool {
|
|
return utils.BitsetEmpty(s[:])
|
|
}
|
|
|
|
const defaultMaxPayloadLength = 450
|
|
|
|
// Strings returns all of our enabled capabilities as a slice of strings.
|
|
func (s *Set) Strings(version Version, values Values, maxLen int) (result []string) {
|
|
if maxLen == 0 {
|
|
maxLen = defaultMaxPayloadLength
|
|
}
|
|
var t utils.TokenLineBuilder
|
|
t.Initialize(maxLen, " ")
|
|
|
|
var capab Capability
|
|
asSlice := s[:]
|
|
for capab = 0; capab < numCapabs; capab++ {
|
|
// skip any capabilities that are not enabled
|
|
if !utils.BitsetGet(asSlice, uint(capab)) {
|
|
continue
|
|
}
|
|
capString := capab.Name()
|
|
if version >= Cap302 {
|
|
val, exists := values[capab]
|
|
if exists {
|
|
capString = fmt.Sprintf("%s=%s", capString, val)
|
|
}
|
|
}
|
|
t.Add(capString)
|
|
}
|
|
|
|
result = t.Lines()
|
|
if result == nil {
|
|
result = []string{""}
|
|
}
|
|
return
|
|
}
|