100 lines
1.9 KiB
Go
100 lines
1.9 KiB
Go
package dal
|
|
|
|
import "sort"
|
|
|
|
type (
|
|
SensitivityLevel struct {
|
|
Handle string
|
|
ID uint64
|
|
Level int
|
|
}
|
|
SensitivityLevelSet []SensitivityLevel
|
|
|
|
sensitivityLevelIndex struct {
|
|
set SensitivityLevelSet
|
|
|
|
byHandle map[string]int
|
|
byID map[uint64]int
|
|
}
|
|
)
|
|
|
|
func SensitivityLevelIndex(levels ...SensitivityLevel) *sensitivityLevelIndex {
|
|
out := &sensitivityLevelIndex{
|
|
set: make(SensitivityLevelSet, len(levels)),
|
|
byHandle: make(map[string]int),
|
|
byID: make(map[uint64]int),
|
|
}
|
|
|
|
for i, l := range levels {
|
|
out.set[i] = l
|
|
out.byHandle[l.Handle] = i
|
|
out.byID[l.ID] = i
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
func (sli sensitivityLevelIndex) with(levels ...SensitivityLevel) *sensitivityLevelIndex {
|
|
slvls := append(sli.set, levels...)
|
|
sort.Sort(slvls)
|
|
|
|
return SensitivityLevelIndex(slvls...)
|
|
}
|
|
|
|
func (sli sensitivityLevelIndex) without(levels ...SensitivityLevel) *sensitivityLevelIndex {
|
|
nn := make(SensitivityLevelSet, 0, len(sli.set))
|
|
|
|
remIndex := SensitivityLevelIndex(levels...)
|
|
|
|
for _, existing := range sli.set {
|
|
if !remIndex.includes(existing.ID) {
|
|
nn = append(nn, existing)
|
|
}
|
|
}
|
|
|
|
sort.Sort(nn)
|
|
|
|
return SensitivityLevelIndex(nn...)
|
|
}
|
|
|
|
func (sli sensitivityLevelIndex) includes(l uint64) (ok bool) {
|
|
if l == 0 {
|
|
return true
|
|
}
|
|
|
|
if sli.byID == nil {
|
|
return false
|
|
}
|
|
|
|
_, ok = sli.byID[l]
|
|
return
|
|
}
|
|
|
|
func (sli sensitivityLevelIndex) isSubset(a, b uint64) (ok bool) {
|
|
// Edgecases
|
|
// If A is zero theneverything is possible
|
|
if a == 0 {
|
|
return true
|
|
}
|
|
// If B is zero, then A must also be zero
|
|
if b == 0 {
|
|
return a == 0
|
|
}
|
|
|
|
var lvlA, lvlB int
|
|
|
|
if lvlA, ok = sli.byID[a]; !ok {
|
|
return false
|
|
}
|
|
|
|
if lvlB, ok = sli.byID[b]; !ok {
|
|
return false
|
|
}
|
|
|
|
return lvlA <= lvlB
|
|
}
|
|
|
|
func (a SensitivityLevelSet) Len() int { return len(a) }
|
|
func (a SensitivityLevelSet) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
func (a SensitivityLevelSet) Less(i, j int) bool { return a[i].Level < a[j].Level }
|