Как создать перечисления битовой маски в стиле NS_OPTIONS в Swift?
В документации Apple о взаимодействии с C API, они описывают способ NS_ENUMперечисления в C-стиле импортируются как перечисления Swift. Это имеет смысл, и поскольку перечисления в Swift легко предоставляются как enum Тип значения легко увидеть, как создать свой собственный.
Далее это говорит об этом NS_OPTIONSопции в стиле C:
Swift также импортирует опции, отмеченные
NS_OPTIONSмакро. Принимая во внимание, что параметры ведут себя подобно импортированным перечислениям, параметры могут также поддерживать некоторые побитовые операции, такие как&,|, а также~, В Objective-C вы представляете пустой набор параметров с постоянным нулем (0). В Swift используйтеnilпредставлять отсутствие каких-либо вариантов.
Учитывая, что нет options тип значения в Swift, как мы можем создать переменную параметров C-Style для работы?
15 ответов
Swift 3.0
Практически идентичен Swift 2.0. OptionSetType был переименован в OptionSet, а перечисления записываются строчными буквами по соглашению.
struct MyOptions : OptionSet {
let rawValue: Int
static let firstOption = MyOptions(rawValue: 1 << 0)
static let secondOption = MyOptions(rawValue: 1 << 1)
static let thirdOption = MyOptions(rawValue: 1 << 2)
}
Вместо предоставления none В этом случае Swift 3 рекомендует просто использовать литерал пустого массива:
let noOptions: MyOptions = []
Другое использование:
let singleOption = MyOptions.firstOption
let multipleOptions: MyOptions = [.firstOption, .secondOption]
if multipleOptions.contains(.secondOption) {
print("multipleOptions has SecondOption")
}
let allOptions = MyOptions(rawValue: 7)
if allOptions.contains(.thirdOption) {
print("allOptions has ThirdOption")
}
Swift 2.0
В Swift 2.0 расширения протокола заботятся о большинстве шаблонов для них, которые теперь импортируются как структура, которая соответствует OptionSetType, (RawOptionSetType исчезла с Swift 2 бета 2). Объявление гораздо проще:
struct MyOptions : OptionSetType {
let rawValue: Int
static let None = MyOptions(rawValue: 0)
static let FirstOption = MyOptions(rawValue: 1 << 0)
static let SecondOption = MyOptions(rawValue: 1 << 1)
static let ThirdOption = MyOptions(rawValue: 1 << 2)
}
Теперь мы можем использовать основанную на множестве семантику с MyOptions:
let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = [.FirstOption, .SecondOption]
if multipleOptions.contains(.SecondOption) {
print("multipleOptions has SecondOption")
}
let allOptions = MyOptions(rawValue: 7)
if allOptions.contains(.ThirdOption) {
print("allOptions has ThirdOption")
}
Swift 1.2
Рассматривая опции Objective C, которые были импортированы Swift (UIViewAutoresizingнапример), мы можем видеть, что параметры объявлены как struct что соответствует протоколу RawOptionSetTypeчто в свою очередь соответствует _RawOptionSetType, Equatable, RawRepresentable, BitwiseOperationsType, а также NilLiteralConvertible, Мы можем создать свой собственный, как это:
struct MyOptions : RawOptionSetType {
typealias RawValue = UInt
private var value: UInt = 0
init(_ value: UInt) { self.value = value }
init(rawValue value: UInt) { self.value = value }
init(nilLiteral: ()) { self.value = 0 }
static var allZeros: MyOptions { return self(0) }
static func fromMask(raw: UInt) -> MyOptions { return self(raw) }
var rawValue: UInt { return self.value }
static var None: MyOptions { return self(0) }
static var FirstOption: MyOptions { return self(1 << 0) }
static var SecondOption: MyOptions { return self(1 << 1) }
static var ThirdOption: MyOptions { return self(1 << 2) }
}
Теперь мы можем обработать этот новый набор параметров, MyOptionsтак же, как описано в документации Apple: вы можете использовать enum-подобный синтаксис:
let opt1 = MyOptions.FirstOption
let opt2: MyOptions = .SecondOption
let opt3 = MyOptions(4)
И это также ведет себя так, как мы ожидаем, что варианты будут вести себя:
let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = singleOption | .SecondOption
if multipleOptions & .SecondOption != nil { // see note
println("multipleOptions has SecondOption")
}
let allOptions = MyOptions.fromMask(7) // aka .fromMask(0b111)
if allOptions & .ThirdOption != nil {
println("allOptions has ThirdOption")
}
Я построил генератор для создания набора параметров Swift без поиска и замены.
Последнее: Модификации для Swift 1.1 beta 3.
Xcode 6.1 Beta 2 внес некоторые изменения в RawOptionSetTypeпротокол (см. эту запись в блоге Airspeedvelocity и заметки о выпуске Apple).
На основе примера Nate Cooks здесь представлено обновленное решение. Вы можете определить свой собственный набор параметров следующим образом:
struct MyOptions : RawOptionSetType, BooleanType {
private var value: UInt
init(_ rawValue: UInt) { self.value = rawValue }
// MARK: _RawOptionSetType
init(rawValue: UInt) { self.value = rawValue }
// MARK: NilLiteralConvertible
init(nilLiteral: ()) { self.value = 0}
// MARK: RawRepresentable
var rawValue: UInt { return self.value }
// MARK: BooleanType
var boolValue: Bool { return self.value != 0 }
// MARK: BitwiseOperationsType
static var allZeros: MyOptions { return self(0) }
// MARK: User defined bit values
static var None: MyOptions { return self(0) }
static var FirstOption: MyOptions { return self(1 << 0) }
static var SecondOption: MyOptions { return self(1 << 1) }
static var ThirdOption: MyOptions { return self(1 << 2) }
static var All: MyOptions { return self(0b111) }
}
Затем его можно использовать для определения переменных:
let opt1 = MyOptions.FirstOption
let opt2:MyOptions = .SecondOption
let opt3 = MyOptions(4)
И вот так для проверки битов:
let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = singleOption | .SecondOption
if multipleOptions & .SecondOption {
println("multipleOptions has SecondOption")
}
let allOptions = MyOptions.All
if allOptions & .ThirdOption {
println("allOptions has ThirdOption")
}
Пример Swift 2.0 из документации:
struct PackagingOptions : OptionSetType {
let rawValue: Int
init(rawValue: Int) { self.rawValue = rawValue }
static let Box = PackagingOptions(rawValue: 1)
static let Carton = PackagingOptions(rawValue: 2)
static let Bag = PackagingOptions(rawValue: 4)
static let Satchel = PackagingOptions(rawValue: 8)
static let BoxOrBag: PackagingOptions = [Box, Bag]
static let BoxOrCartonOrBag: PackagingOptions = [Box, Carton, Bag]
}
Вы можете найти это здесь
В Swift 2 (в настоящее время бета-версия как часть бета-версии Xcode 7), NS_OPTIONSтипы стилей импортируются как подтипы нового OptionSetType тип. И благодаря новой функции расширений протокола и способ OptionSetType реализован в стандартной библиотеке, вы можете объявить свои собственные типы, которые расширяют OptionsSetType и получить все те же функции и методы, которые импортированы NS_OPTIONS Типы стилей получают.
Но эти функции больше не основаны на побитовых арифметических операторах. То, что работа с набором неисключительных логических опций в C требует маскирования и переключения битов в поле, является деталью реализации. Действительно, набор опций - это набор... набор уникальных предметов. Так OptionsSetType получает все методы из SetAlgebraType протокол, как создание из массива буквального синтаксиса, запросы как contains, маскируясь с intersection и т. д. (Больше не нужно запоминать, какой забавный персонаж использовать для какого теста на членство!)
//Swift 2.0
//create
struct Direction : OptionSetType {
let rawValue: Int
static let None = Direction(rawValue: 0)
static let Top = Direction(rawValue: 1 << 0)
static let Bottom = Direction(rawValue: 1 << 1)
static let Left = Direction(rawValue: 1 << 2)
static let Right = Direction(rawValue: 1 << 3)
}
//declare
var direction: Direction = Direction.None
//using
direction.insert(Direction.Right)
//check
if direction.contains(.Right) {
//`enter code here`
}
Если вам не нужно взаимодействовать с Objective-C и просто нужна поверхностная семантика битовых масок в Swift, я написал простую "библиотеку" под названием BitwiseOptions, которая может делать это с обычными перечислениями Swift, например:
enum Animal: BitwiseOptionsType {
case Chicken
case Cow
case Goat
static let allOptions = [.Chicken, .Cow, .Goat]
}
var animals = Animal.Chicken | Animal.Goat
animals ^= .Goat
if animals & .Chicken == .Chicken {
println("Chick-Fil-A!")
}
и так далее. Никаких реальных битов здесь не переворачивается. Это операции над непрозрачными значениями. Вы можете найти суть здесь.
Как уже упоминал Рикстер, вы можете использовать OptionSetType в Swift 2.0. Типы NS_OPTIONS импортируются как соответствующие OptionSetType протокол, который представляет собой подобный множеству интерфейс для опций:
struct CoffeeManipulators : OptionSetType {
let rawValue: Int
static let Milk = CoffeeManipulators(rawValue: 1)
static let Sugar = CoffeeManipulators(rawValue: 2)
static let MilkAndSugar = [Milk, Sugar]
}
Это дает вам такой способ работы:
struct Coffee {
let manipulators:[CoffeeManipulators]
// You can now simply check if an option is used with contains
func hasMilk() -> Bool {
return manipulators.contains(.Milk)
}
func hasManipulators() -> Bool {
return manipulators.count != 0
}
}
Просто опубликуйте дополнительный пример для тех, кто интересуется, можете ли вы комбинировать составные варианты. Вы можете, и они объединяются, как и следовало ожидать, если вы привыкли к старым добрым битовым полям:
struct State: OptionSetType {
let rawValue: Int
static let A = State(rawValue: 1 << 0)
static let B = State(rawValue: 1 << 1)
static let X = State(rawValue: 1 << 2)
static let AB:State = [.A, .B]
static let ABX:State = [.AB, .X] // Combine compound state with .X
}
let state: State = .ABX
state.contains(.A) // true
state.contains(.AB) // true
Это выравнивает набор [.AB, .X] в [.A, .B, .X] (по крайней мере, семантически):
print(state) // 0b111 as expected: "State(rawValue: 7)"
print(State.AB) // 0b11 as expected: "State(rawValue: 3)"
Если единственная необходимая нам функциональность - это способ сочетания | и проверьте, содержат ли комбинированные опции конкретный параметр с & альтернатива ответу Нейта Кука может быть такой:
Создать варианты protocol и перегрузка | а также &:
protocol OptionsProtocol {
var value: UInt { get }
init (_ value: UInt)
}
func | <T: OptionsProtocol>(left: T, right: T) -> T {
return T(left.value | right.value)
}
func & <T: OptionsProtocol>(left: T, right: T) -> Bool {
if right.value == 0 {
return left.value == 0
}
else {
return left.value & right.value == right.value
}
}
Теперь мы можем создавать структуры опций более просто так:
struct MyOptions: OptionsProtocol {
private(set) var value: UInt
init (_ val: UInt) {value = val}
static var None: MyOptions { return self(0) }
static var One: MyOptions { return self(1 << 0) }
static var Two: MyOptions { return self(1 << 1) }
static var Three: MyOptions { return self(1 << 2) }
}
Их можно использовать следующим образом:
func myMethod(#options: MyOptions) {
if options & .One {
// Do something
}
}
myMethod(options: .One | .Three)
Re: Песочница и закладки создания с использованием наборов опций с несколькими опциями
let options:NSURL.BookmarkCreationOptions = [.withSecurityScope,.securityScopeAllowOnlyReadAccess]
let temp = try link.bookmarkData(options: options, includingResourceValuesForKeys: nil, relativeTo: nil)
Решение необходимости сочетать варианты для творчества, полезно, когда не все варианты являются взаимоисключающими.
Никто другой не упомянул об этом - и я немного ошибся после некоторого возни - но набор Swift, кажется, работает довольно хорошо.
Если мы подумаем (может быть, на диаграмме Венна?) О том, что на самом деле представляет битовая маска, то это возможно пустой набор.
Конечно, при подходе к проблеме из первых принципов мы теряем удобство побитовых операторов, но получаем мощные методы на основе множеств, которые улучшают читабельность.
Вот моя возня например:
enum Toppings : String {
// Just strings 'cause there's no other way to get the raw name that I know of...
// Could be 1 << x too...
case Tomato = "tomato"
case Salami = "salami"
case Cheese = "cheese"
case Chicken = "chicken"
case Beef = "beef"
case Anchovies = "anchovies"
static let AllOptions: Set<Toppings> = [.Tomato, .Salami, .Cheese, .Chicken, .Anchovies, .Beef]
}
func checkPizza(toppings: Set<Toppings>) {
if toppings.contains(.Cheese) {
print("Possible dairy allergies?")
}
let meats: Set<Toppings> = [.Beef, .Chicken, .Salami]
if toppings.isDisjointWith(meats) {
print("Vego-safe!")
}
if toppings.intersect(meats).count > 1 {
print("Limit one meat, or 50¢ extra charge!")
}
if toppings == [Toppings.Cheese] {
print("A bit boring?")
}
}
checkPizza([.Tomato, .Cheese, .Chicken, .Beef])
checkPizza([.Cheese])
Я нахожу это хорошим, потому что я чувствую, что он исходит из подхода, основанного на принципах первого принципа - во многом как Swift - вместо того, чтобы пытаться адаптировать решения в стиле C
Также хотелось бы услышать о некоторых случаях использования Obj-C, которые могли бы бросить вызов этой другой парадигме, где целочисленные необработанные значения все еще показывают ценность.
Во избежание жесткого кодирования битовых позиций, что неизбежно при использовании (1 << 0), (1 << 1), (1 << 15) и т.д. или еще хуже 1, 2, 16384 и т. д. или некоторое шестнадцатеричное изменение, можно сначала определить биты в enum, затем пусть указанное перечисление выполняет порядковый номер бита:
// Bits
enum Options : UInt {
case firstOption
case secondOption
case thirdOption
}
// Byte
struct MyOptions : OptionSet {
let rawValue: UInt
static let firstOption = MyOptions(rawValue: 1 << Options.firstOption.rawValue)
static let secondOption = MyOptions(rawValue: 1 << Options.secondOption.rawValue)
static let thirdOption = MyOptions(rawValue: 1 << Options.thirdOption.rawValue)
}
Я использую следующее, мне нужны оба значения, которые я могу получить, rawValue для индексирования массивов и значение для флагов.
enum MyEnum: Int {
case one
case two
case four
case eight
var value: UInt8 {
return UInt8(1 << self.rawValue)
}
}
let flags: UInt8 = MyEnum.one.value ^ MyEnum.eight.value
(flags & MyEnum.eight.value) > 0 // true
(flags & MyEnum.four.value) > 0 // false
(flags & MyEnum.two.value) > 0 // false
(flags & MyEnum.one.value) > 0 // true
MyEnum.eight.rawValue // 3
MyEnum.four.rawValue // 2
А если нужно больше, просто добавьте вычисляемое свойство.
enum MyEnum: Int {
case one
case two
case four
case eight
var value: UInt8 {
return UInt8(1 << self.rawValue)
}
var string: String {
switch self {
case .one:
return "one"
case .two:
return "two"
case .four:
return "four"
case .eight:
return "eight"
}
}
}
Ответ Нейта хорош, но я бы сделал это своими руками, вот так:
struct MyOptions : OptionSetType {
let rawValue: Int
static let None = Element(rawValue: 0)
static let FirstOption = Element(rawValue: 1 << 0)
static let SecondOption = Element(rawValue: 1 << 1)
static let ThirdOption = Element(rawValue: 1 << 2)
}
Использовать тип набора опций в swift 3 OptionSet
struct ShippingOptions: OptionSet {
let rawValue: Int
static let nextDay = ShippingOptions(rawValue: 1 << 0)
static let secondDay = ShippingOptions(rawValue: 1 << 1)
static let priority = ShippingOptions(rawValue: 1 << 2)
static let standard = ShippingOptions(rawValue: 1 << 3)
static let express: ShippingOptions = [.nextDay, .secondDay]
static let all: ShippingOptions = [.express, .priority, .standard]
}