57 lines
1.3 KiB
Go
57 lines
1.3 KiB
Go
package versions
|
|
|
|
import "fmt"
|
|
|
|
type setSubtract struct {
|
|
from setI
|
|
sub setI
|
|
}
|
|
|
|
func (s setSubtract) Has(v Version) bool {
|
|
return s.from.Has(v) && !s.sub.Has(v)
|
|
}
|
|
|
|
func (s setSubtract) AllRequested() Set {
|
|
// Our set requests anything that is requested by "from", unless it'd
|
|
// be excluded by "sub". Notice that the whole of "sub" is used, rather
|
|
// than just the requested parts, because requesting is a positive
|
|
// action only.
|
|
return Set{setI: s.from}.AllRequested().Subtract(Set{setI: s.sub})
|
|
}
|
|
|
|
func (s setSubtract) GoString() string {
|
|
return fmt.Sprintf("(%#v).Subtract(%#v)", s.from, s.sub)
|
|
}
|
|
|
|
// Subtract returns a new set that has all of the versions from the receiver
|
|
// except for any versions in the other given set.
|
|
//
|
|
// If the receiver is finite then the returned set is also finite.
|
|
func (s Set) Subtract(other Set) Set {
|
|
if other == None || s == None {
|
|
return s
|
|
}
|
|
if other == All {
|
|
return None
|
|
}
|
|
return Set{
|
|
setI: setSubtract{
|
|
from: s.setI,
|
|
sub: other.setI,
|
|
},
|
|
}
|
|
}
|
|
|
|
var _ setFinite = setSubtract{}
|
|
|
|
func (s setSubtract) isFinite() bool {
|
|
// subtract is finite if its "from" is finite
|
|
return isFinite(s.from)
|
|
}
|
|
|
|
func (s setSubtract) listVersions() List {
|
|
ret := s.from.(setFinite).listVersions()
|
|
ret = ret.Filter(Set{setI: s.sub})
|
|
return ret
|
|
}
|