idiomatischer Schnelltest für Optionsset?

Question

Noch gewöhnen an die Verwendung von OptionSetType in Swift.

In good ol‘C, wenn ich so etwas wie

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; 

habe, kann ich eine Reihe von Flaggen mit etwas Einfachen wie testen:

if ((propertiesMask & (CHAR_PROP_NOTIFY | CHAR_PROP_INDICATE)) != 0) ... 

Die Swift Alternative wie

aussehen könnte

let properties:CBCharacteristicProperties = [.Write, .Read, .Indicate] 
!properties.intersect([.Indicate, .Notify]).isEmpty 

Gibt es einen idiomatischen Weg, diesen Test zu machen? Kein Fan von! draußen. Aber ansonsten scheint das einfach genug, außer dass ich mich wirklich dafür interessiere, wenn es eine Kreuzung gibt. Das hat mich dazu gebracht, mein eigenes hinzufügen zu wollen.

extension OptionSetType { 
    func hasIntersection(other:Self) -> Bool { 
     return !self.intersect(other).isEmpty 
    } 
} 

Was mir dann

properties.hasIntersection([.Indicate, .Notify]) 

Gibt es einen besseren/mehr idiomatischen Weg, dies zu tun zu schreiben erlaubt? Habe ich mein eigenes gerollt und etwas verpasst?

Answer 1

Es gibt diese Methode aus dem Protokoll SetAlgebraType welche OptionSetType implementiert:

isDisjointWith(_: Self) -> Bool

Gibt true zurück iff self.intersect (andere) .isEmpty.

So können Sie Ihren Test verkürzen:

!properties.isDisjointWith([.Indicate, .Notify]) 

oder

properties.isDisjointWith([.Indicate, .Notify]) == false 

Sie können auch die Rohwerte mit Bitoperatoren vergleichen, so wie man in C tun würde:

(properties.rawValue & (CharacteristicProperties.Notify.rawValue | CharacteristicProperties.Indicate.rawValue)) != 0 

Vollständiger Beispielcode (auf einem Spielplatz):

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) 

Ergebnis:

"true" 
"true" 
"true" 
"true" 

Answer 2

Die eigentliche Lösung, die ich attraktivste am Ende gefunden wurde, einfach die folgende Erweiterung hinzufügen:

extension SetAlgebraType { 
    var notEmpty:Bool { 
     return self.isEmpty.NOT 
    } 
} 

Das erlaubte mir, Code zu schreiben:

if properties.intersect([.Indicate, .Notify]).notEmpty { 
    ... 
}