more idiomatic swift test for optionset? - swift

Question

Still getting used to the use of OptionSetType in Swift.
In good ol' C, if I had something like
typedef enum {
CHAR_PROP_BROADCAST =0x01,
CHAR_PROP_READ =0x02,
CHAR_PROP_WRITE_WITHOUT_RESP =0x04,
CHAR_PROP_WRITE =0x08,
CHAR_PROP_NOTIFY =0x10,
CHAR_PROP_INDICATE =0x20,
CHAR_PROP_SIGNED_WRITE =0x40,
CHAR_PROP_EXT =0x80
} CharacteristicProperty;
I could test a set of flags with something simple like:
if ((propertiesMask & (CHAR_PROP_NOTIFY | CHAR_PROP_INDICATE)) != 0) ...
The Swift alternative might look like
let properties:CBCharacteristicProperties = [.Write, .Read, .Indicate]
!properties.intersect([.Indicate, .Notify]).isEmpty
Is there a more idiomatic way to do this test? Not a fan of the ! out front. But otherwise, seems straightforward enough, except I'm really interested in when there IS an intersection. This led me to want to add my own.
extension OptionSetType {
func hasIntersection(other:Self) -> Bool {
return !self.intersect(other).isEmpty
}
}
Which then allows me to write
properties.hasIntersection([.Indicate, .Notify])
Is there a better/more idiomatic way to do this? Did I roll my own and miss something?

Answer 1

There's this method from the protocol SetAlgebraType which OptionSetType implements:
isDisjointWith(_: Self) -> Bool
Returns true iff self.intersect(other).isEmpty.
So you could shorten your test to:
!properties.isDisjointWith([.Indicate, .Notify])
or
properties.isDisjointWith([.Indicate, .Notify]) == false
You can also compare the raw values with bitwise operators, just as you would do in C:
(properties.rawValue & (CharacteristicProperties.Notify.rawValue | CharacteristicProperties.Indicate.rawValue)) != 0
Full example code (in a playground):
struct CBCharacteristicProperties : OptionSetType {
let rawValue: UInt
init(rawValue: UInt) { self.rawValue = rawValue }
static let Broadcast = CBCharacteristicProperties(rawValue:0x01)
static let Read = CBCharacteristicProperties(rawValue:0x02)
static let WriteWithoutResp = CBCharacteristicProperties(rawValue:0x04)
static let Write = CBCharacteristicProperties(rawValue:0x08)
static let Notify = CBCharacteristicProperties(rawValue:0x10)
static let Indicate = CBCharacteristicProperties(rawValue:0x20)
static let SignedWrite = CBCharacteristicProperties(rawValue:0x40)
static let Ext = CBCharacteristicProperties(rawValue:0x80)
}
let properties = CBCharacteristicProperties([.Write, .Read, .Indicate])
print(!properties.intersect([.Indicate, .Notify]).isEmpty)
print(!properties.isDisjointWith([.Indicate, .Notify]))
print(properties.isDisjointWith([.Indicate, .Notify]) == false)
print((properties.rawValue & (CBCharacteristicProperties.Notify.rawValue | CBCharacteristicProperties.Indicate.rawValue)) != 0)
result:
"true"
"true"
"true"
"true"

Answer 2

The actual solution I found most appealing in the end was to simply add the following extension:
extension SetAlgebraType {
var notEmpty:Bool {
return self.isEmpty.NOT
}
}
This allowed me to write code:
if properties.intersect([.Indicate, .Notify]).notEmpty {
...
}