Passa a corrispondere a più casi da OptionSetType

Question

I have a struct Person estende OptionSetType. Più tardi nel codice, come posso utilizzare un'istruzione switch per verificare se un'istanza di Person è più di un valore?

Grazie

struct Person: OptionSetType { 
let rawValue: Int 
init(rawValue: Int){ 
    self.rawValue = rawValue 
} 

    static let boy   = Person(rawValue: 1 << 0) 
    static let young  = Person(rawValue: 1 << 1) 
    static let smart  = Person(rawValue: 1 << 2) 
    static let strong  = Person(rawValue: 1 << 3) 
} 

//later declared 
var him: Person! 

//later initialised 
him = [.boy, .young] 

//now test using a switch block 
Switch (him) { 
    case .boy & .young // <----- How do you get this to work? 

} 

Come ci si prova per lui == giovane e forte?
Come testarlo contiene giovani e ragazzi?

Answer 1

OptionSetType è un sottotipo di SetAlgebraType, quindi è possibile utilizzare i metodi di algebra per testare una combinazione di opzioni con un'altra. A seconda esattamente di cosa vuoi chiedere (e quali sono gli insiemi in questione), ci possono essere diversi modi per farlo.

In primo luogo, metto gli attributi che sto interrogazione in un costante locale:

let youngBoy: Person = [.Young, .Boy] 

Ora, per l'uso che per un tipo di prova che funziona bene:

if him.isSupersetOf(youngBoy) { 
    // go to Toshi station, pick up power converters 
} 

Ovviamente, ciò che viene specificamente chiesto è se lo him contenga tutte le opzioni elencate in youngBoy. Potrebbe essere tutto ciò che ti interessa, quindi va bene. Ed è anche sicuro se in seguito si estende Person per avere anche altre opzioni.

Ma cosa succede se Person avevano altre opzioni possibili, e di voler affermare che him contiene esattamente le opzioni elencate nella youngBoy, e non altre? SetAlgebraType estende Equatable, quindi si può semplicemente provare con ==:

if him == youngBoy { 
    // he'd better have those units on the south ridge repaired by midday 
} 

Tra l'altro, non si vuole usare una dichiarazione switch per questo. L'interruttore serve a selezionare uno tra più possibili casi (è A o B?), Quindi usarlo per testare i combinatori (è A, B, A e B, o nessuno dei due?) Rende il codice poco maneggevole.

Answer 2

Proprio semplice caso:

switch him { 
case [.boy, .young]: 
    // code 
default: 
    break 
}